mancode 0.3.16 → 0.3.17

package/dist/cli.js

@@ -2651,8 +2651,10 @@ function isNotFound4(error) {
 }
 
 // src/runtime/task-operation.ts
+import { execFile as execFileCallback2 } from "child_process";
 import { lstat as lstat4, mkdir as mkdir10, readFile as readFile11, rm as rm4, writeFile as writeFile10 } from "fs/promises";
 import path11 from "path";
+import { promisify as promisify2 } from "util";
 
 // src/context/compatibility.ts
 function evaluateCompatibilityGate(input) {
@@ -4420,6 +4422,7 @@ function isNotFound10(error) {
 }
 
 // src/runtime/task-operation.ts
+var execFile2 = promisify2(execFileCallback2);
 var TASK_AUTHORITY_FILES = new Set(TASK_AUTHORITY_FILE_NAMES);
 async function openV3TaskOperation(input) {
   const projectRoot = path11.resolve(requireProjectRoot(input.projectRoot));
@@ -4493,11 +4496,22 @@ async function openV3TaskOperation(input) {
         throw new Error("MANCODE_TASK_HEAD_FENCE_MISSING");
       }
       if (input.allowTaskHeadFenceMismatch !== true) {
-        assertTaskHeadFenceMatchesAggregate(
-          coordination.taskHeadFence,
-          task.aggregate,
-          codeHead
-        );
+        try {
+          assertTaskHeadFenceMatchesAggregate(
+            coordination.taskHeadFence,
+            task.aggregate,
+            codeHead
+          );
+        } catch (error) {
+          await assertOwnerCodeHeadAdvance({
+            projectRoot,
+            task,
+            fence: coordination.taskHeadFence,
+            codeHead,
+            actorId: session.actorId,
+            originalError: error
+          });
+        }
       }
     }
     return {
@@ -4527,6 +4541,21 @@ async function openV3TaskOperation(input) {
     throw error;
   }
 }
+async function assertOwnerCodeHeadAdvance(input) {
+  const { task, fence } = input;
+  if (task.aggregate === null || task.metadata.ownerActorId !== input.actorId || fence.taskRevision !== task.metadata.revision || fence.ownershipEpoch !== task.metadata.ownershipEpoch || fence.aggregateDigest !== taskAggregateDigest(task.aggregate)) {
+    throw input.originalError;
+  }
+  try {
+    await execFile2(
+      "git",
+      ["merge-base", "--is-ancestor", fence.codeRef.head, input.codeHead],
+      { cwd: input.projectRoot, windowsHide: true }
+    );
+  } catch {
+    throw input.originalError;
+  }
+}
 async function assertTaskParentIsWritable(store, task) {
   if (task.metadata.parent === null) return;
   try {
@@ -7638,9 +7667,9 @@ function compareUtf83(left, right) {
 }
 
 // src/context/task-head-reconcile.ts
-import { execFile as execFileCallback3 } from "child_process";
+import { execFile as execFileCallback4 } from "child_process";
 import path15 from "path";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify4 } from "util";
 
 // src/team/conflicts.ts
 function deriveClaimValidity(claim, context) {
@@ -7838,12 +7867,12 @@ function unique(values) {
 }
 
 // src/team/git-ref-transport.ts
-import { execFile as execFileCallback2 } from "child_process";
+import { execFile as execFileCallback3 } from "child_process";
 import { mkdtemp, rm as rm6, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir } from "os";
 import path14 from "path";
-import { promisify as promisify2 } from "util";
-var execFile2 = promisify2(execFileCallback2);
+import { promisify as promisify3 } from "util";
+var execFile3 = promisify3(execFileCallback3);
 var TEAM_REF = "refs/mancode/team";
 var MAX_MANIFEST_BYTES = 1e6;
 var MAX_ACTOR_PROFILES = 256;
@@ -8057,6 +8086,12 @@ var GitRefTeamManifestStore = class {
     const previousFence = base.ownershipFences.find(
       (candidate) => sameTaskRef(candidate.taskRef, taskRef)
     );
+    const previousTaskBundle = base.taskBundles.find(
+      (bundle) => sameTaskRef(bundle.taskRef, taskRef)
+    );
+    if ((previousTaskBundle?.bundleDigest ?? null) !== input.expectedTaskBundleDigest) {
+      throw new Error("MANCODE_TASK_BUNDLE_DIVERGED");
+    }
     if (!base.actorProfiles.some((profile) => profile.actorId === input.actorId)) {
       throw new Error("MANCODE_TRANSPORT_ACTOR_NOT_JOINED");
     }
@@ -8088,9 +8123,7 @@ var GitRefTeamManifestStore = class {
       previousHandoffs: base.handoffs.filter(
         (handoff) => sameTaskRef(handoff.taskRef, taskRef)
       ),
-      previousTaskBundle: base.taskBundles.find(
-        (bundle) => sameTaskRef(bundle.taskRef, taskRef)
-      ),
+      previousTaskBundle,
       expectedOwnershipEpoch,
       nextRevision,
       fence,
@@ -9690,7 +9723,7 @@ async function gitShow(projectRoot, revision) {
   }
 }
 async function runGit2(projectRoot, arguments_, env = process.env) {
-  const result2 = await execFile2("git", arguments_, {
+  const result2 = await execFile3("git", arguments_, {
     cwd: projectRoot,
     env,
     windowsHide: true,
@@ -9904,7 +9937,7 @@ function createGitRefTeamManifestStore(projectRoot, config, manifest) {
 }
 
 // src/context/task-head-reconcile.ts
-var execFile3 = promisify3(execFileCallback3);
+var execFile4 = promisify4(execFileCallback4);
 async function previewV3TaskHeadReconcile(input) {
   const taskRef = parseTaskRefValue(input.taskRef);
   if (taskRef.namespace !== "shared") {
@@ -10125,13 +10158,13 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
     "verification-ledger.json"
   ].map((file) => path15.join(relativeTaskRoot, file));
   try {
-    await execFile3("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
+    await execFile4("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
       cwd: projectRoot,
       encoding: "utf8",
       timeout: 5e3,
       maxBuffer: 64 * 1024
     });
-    await execFile3(
+    await execFile4(
       "git",
       ["ls-files", "--error-unmatch", "--", ...authorityFiles],
       {
@@ -10141,13 +10174,13 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
         maxBuffer: 64 * 1024
       }
     );
-    await execFile3("git", ["diff", "--quiet", "HEAD", "--", relativeTaskRoot], {
+    await execFile4("git", ["diff", "--quiet", "HEAD", "--", relativeTaskRoot], {
       cwd: projectRoot,
       encoding: "utf8",
       timeout: 5e3,
       maxBuffer: 64 * 1024
     });
-    await execFile3(
+    await execFile4(
       "git",
       ["diff", "--cached", "--quiet", "--", relativeTaskRoot],
       {
@@ -10157,7 +10190,7 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
         maxBuffer: 64 * 1024
       }
     );
-    const { stdout: status2 } = await execFile3(
+    const { stdout: status2 } = await execFile4(
       "git",
       [
         "status",
@@ -18533,22 +18566,376 @@ function isAlreadyExists17(error) {
 }
 
 // src/team/git-ref-workflow-repair.ts
-import { lstat as lstat15, mkdir as mkdir24, readFile as readFile27, readdir as readdir13, writeFile as writeFile27 } from "fs/promises";
-import path31 from "path";
+import { lstat as lstat17, mkdir as mkdir26, readFile as readFile29, readdir as readdir14, writeFile as writeFile29 } from "fs/promises";
+import path33 from "path";
 
 // src/team/git-ref-materialization.ts
 import {
-  lstat as lstat14,
-  mkdir as mkdir23,
-  readFile as readFile26,
-  readdir as readdir12,
+  lstat as lstat16,
+  mkdir as mkdir25,
+  readFile as readFile28,
+  readdir as readdir13,
   unlink as unlink2,
-  writeFile as writeFile26
+  writeFile as writeFile28
 } from "fs/promises";
+import path32 from "path";
+
+// src/team/git-ref-bundle.ts
+import { execFile as execFileCallback5 } from "child_process";
+import { lstat as lstat14, mkdir as mkdir23, readFile as readFile26, readdir as readdir12, writeFile as writeFile26 } from "fs/promises";
 import path30 from "path";
+import { promisify as promisify5 } from "util";
+var execFile5 = promisify5(execFileCallback5);
+function createGitRefTaskBundle(input) {
+  const { task } = input;
+  if (task.metadata.taskRef.namespace !== "shared") {
+    throw new Error("MANCODE_REMOTE_COORDINATION_REQUIRES_SHARED_TASK");
+  }
+  if (task.aggregate === null) {
+    throw new Error("MANCODE_TASK_UNAVAILABLE");
+  }
+  const artifacts = [
+    artifact("metadata", "metadata.json", task.metadata),
+    artifact("requirements", "requirements.json", task.requirements),
+    artifact("review", "review-ledger.json", task.review),
+    artifact("verification", "verification-ledger.json", task.verification)
+  ];
+  if (task.latestCheckpoint !== null) {
+    artifacts.push(
+      artifact(
+        "checkpoint",
+        `checkpoints/${task.latestCheckpoint.checkpointId}.json`,
+        task.latestCheckpoint
+      )
+    );
+  }
+  if (task.plan !== null) {
+    artifacts.push(artifact("plan", "plan.md", task.plan.content));
+  } else {
+    artifacts.push(
+      artifact(
+        "summary",
+        "summary.md",
+        task.latestCheckpoint?.summary ?? `Task ${formatTaskRef(task.metadata.taskRef)} revision ${task.metadata.revision}.`
+      )
+    );
+  }
+  artifacts.sort(
+    (left, right) => left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0
+  );
+  const body = {
+    schemaVersion: 1,
+    taskRef: task.metadata.taskRef,
+    taskRevision: task.metadata.revision,
+    ownershipEpoch: task.metadata.ownershipEpoch,
+    aggregate: task.aggregate,
+    aggregateDigest: digestCanonicalJson(task.aggregate),
+    codeRef: parseCodeRef(input.codeRef),
+    artifacts,
+    createdAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  return parseGitRefTaskBundle({
+    ...body,
+    bundleDigest: gitRefTaskBundleDigest(body)
+  });
+}
+async function assertGitRefBundleCodeReachable(projectRoot, bundle) {
+  const parsed = parseGitRefTaskBundle(bundle);
+  try {
+    await execFile5(
+      "git",
+      ["cat-file", "-e", `${parsed.codeRef.head}^{commit}`],
+      {
+        cwd: path30.resolve(projectRoot),
+        windowsHide: true
+      }
+    );
+  } catch {
+    throw new Error("MANCODE_TASK_BUNDLE_CODE_UNREACHABLE");
+  }
+}
+async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
+  if (!Number.isSafeInteger(remoteRevision) || remoteRevision < 1) {
+    throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
+  }
+  const parsed = parseGitRefTaskBundle(bundle);
+  const directory = path30.join(
+    path30.resolve(projectRoot),
+    ".mancode",
+    "local",
+    "quarantine",
+    "git-ref",
+    parsed.taskRef.taskId,
+    String(remoteRevision)
+  );
+  await ensureFixedDirectory(projectRoot, [
+    ".mancode",
+    "local",
+    "quarantine",
+    "git-ref",
+    parsed.taskRef.taskId,
+    String(remoteRevision)
+  ]);
+  const target = path30.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
+  try {
+    await writeFile26(target, `${JSON.stringify(parsed, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  } catch (error) {
+    if (!isAlreadyExists18(error)) throw error;
+  }
+  return target;
+}
+async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, taskRef, expected) {
+  if (!Number.isSafeInteger(remoteRevision) || remoteRevision < 1) {
+    throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
+  }
+  const parsedTaskRef = parseTaskRefValue(taskRef);
+  const directory = path30.join(
+    path30.resolve(projectRoot),
+    ".mancode",
+    "local",
+    "quarantine",
+    "git-ref",
+    parsedTaskRef.taskId,
+    String(remoteRevision)
+  );
+  let entries;
+  try {
+    await assertFixedDirectory(projectRoot, [
+      ".mancode",
+      "local",
+      "quarantine",
+      "git-ref",
+      parsedTaskRef.taskId,
+      String(remoteRevision)
+    ]);
+    entries = await readdir12(directory);
+  } catch (error) {
+    if (isNotFound22(error)) return null;
+    throw error;
+  }
+  const matches = [];
+  for (const entry of entries.sort()) {
+    if (!/^[a-f0-9]{64}\.json$/.test(entry)) continue;
+    const target = path30.join(directory, entry);
+    const before = await lstat14(target);
+    if (!before.isFile() || before.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+    const bundle = parseGitRefTaskBundle(
+      JSON.parse(await readFile26(target, "utf8"))
+    );
+    const after = await lstat14(target);
+    if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+    if (sameTaskRef(bundle.taskRef, parsedTaskRef) && bundle.taskRevision === expected.taskRevision && bundle.aggregateDigest === expected.aggregateDigest && bundle.ownershipEpoch === expected.ownershipEpoch && bundle.codeRef.head === expected.codeRefHead) {
+      matches.push(bundle);
+    }
+  }
+  if (matches.length > 1) {
+    throw new Error("MANCODE_TRANSPORT_CACHE_CORRUPT");
+  }
+  return matches[0] ?? null;
+}
+function artifact(kind, relativePath, value) {
+  const content = JSON.parse(JSON.stringify(value));
+  return {
+    kind,
+    relativePath,
+    content,
+    contentDigest: digestCanonicalJson(content)
+  };
+}
+function parseCodeRef(value) {
+  if (typeof value.branch !== "string" || !value.branch.trim() || value.branch.includes("\0") || typeof value.head !== "string" || !/^[0-9a-f]{40,64}$/.test(value.head)) {
+    throw new Error("MANCODE_TASK_BUNDLE_CODE_REF_INVALID");
+  }
+  return { branch: value.branch, head: value.head };
+}
+async function ensureFixedDirectory(projectRoot, segments) {
+  let current = path30.resolve(projectRoot);
+  for (const segment of segments) {
+    current = path30.join(current, segment);
+    try {
+      await mkdir23(current);
+    } catch (error) {
+      if (!isAlreadyExists18(error)) throw error;
+    }
+    const entry = await lstat14(current);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  }
+}
+async function assertFixedDirectory(projectRoot, segments) {
+  let current = path30.resolve(projectRoot);
+  for (const segment of segments) {
+    current = path30.join(current, segment);
+    const entry = await lstat14(current);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  }
+}
+function isAlreadyExists18(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isNotFound22(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/team/git-ref-task-base.ts
+import { lstat as lstat15, mkdir as mkdir24, readFile as readFile27, writeFile as writeFile27 } from "fs/promises";
+import path31 from "path";
+async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
+  const parsedTaskRef = parseTaskRefValue(taskRef);
+  const runtime = await readProjectRuntimeContext(projectRoot);
+  const target = remoteBasePath(projectRoot, parsedTaskRef);
+  try {
+    await assertRemoteBaseDirectory(projectRoot);
+    const before = await lstat15(target);
+    if (!before.isFile() || before.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+    const state = parseGitRefTaskRemoteBase(
+      JSON.parse(await readFile27(target, "utf8"))
+    );
+    const after = await lstat15(target);
+    if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+    if (state.workspaceId !== runtime.workspaceId || !sameTaskRef(state.taskRef, parsedTaskRef)) {
+      return null;
+    }
+    return state;
+  } catch (error) {
+    if (isNotFound23(error)) return null;
+    if (error instanceof SyntaxError) {
+      throw new Error("MANCODE_TRANSPORT_CACHE_CORRUPT");
+    }
+    throw error;
+  }
+}
+async function recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle) {
+  const parsedBundle = parseGitRefTaskBundle(bundle);
+  const revision = positiveInteger2(remoteRevision);
+  const runtime = await readProjectRuntimeContext(projectRoot);
+  const state = parseGitRefTaskRemoteBase({
+    schemaVersion: 1,
+    workspaceId: runtime.workspaceId,
+    taskRef: parsedBundle.taskRef,
+    remoteRevision: revision,
+    bundle: parsedBundle
+  });
+  const directory = await ensureRemoteBaseDirectory(projectRoot);
+  const target = remoteBasePath(projectRoot, parsedBundle.taskRef);
+  const temporary = path31.join(
+    directory,
+    `.${parsedBundle.taskRef.taskId}.${process.pid}.${Date.now()}.tmp`
+  );
+  await writeFile27(temporary, `${JSON.stringify(state, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  await replaceFileAtomically(temporary, target);
+  return state;
+}
+function parseGitRefTaskRemoteBase(value) {
+  assertRecord(value, "git-ref task remote base");
+  assertKnownKeys(
+    value,
+    ["schemaVersion", "workspaceId", "taskRef", "remoteRevision", "bundle"],
+    "git-ref task remote base"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("git-ref task remote base schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "git-ref task remote base workspaceId");
+  const taskRef = parseTaskRefValue(value.taskRef);
+  const bundle = parseGitRefTaskBundle(value.bundle);
+  if (!sameTaskRef(taskRef, bundle.taskRef)) {
+    throw new Error("MANCODE_TRANSPORT_CACHE_IDENTITY_MISMATCH");
+  }
+  return {
+    schemaVersion: 1,
+    workspaceId: value.workspaceId,
+    taskRef,
+    remoteRevision: positiveInteger2(value.remoteRevision),
+    bundle
+  };
+}
+async function ensureRemoteBaseDirectory(projectRoot) {
+  let current = path31.resolve(projectRoot);
+  for (const segment of [
+    ".mancode",
+    "local",
+    "cache",
+    "git-ref",
+    "remote-bases"
+  ]) {
+    current = path31.join(current, segment);
+    try {
+      await mkdir24(current);
+    } catch (error) {
+      if (!isAlreadyExists19(error)) throw error;
+    }
+    const entry = await lstat15(current);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  }
+  return current;
+}
+async function assertRemoteBaseDirectory(projectRoot) {
+  let current = path31.resolve(projectRoot);
+  for (const segment of [
+    ".mancode",
+    "local",
+    "cache",
+    "git-ref",
+    "remote-bases"
+  ]) {
+    current = path31.join(current, segment);
+    const entry = await lstat15(current);
+    if (!entry.isDirectory() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  }
+}
+function remoteBasePath(projectRoot, taskRef) {
+  const parsed = parseTaskRefValue(taskRef);
+  return path31.join(
+    path31.resolve(projectRoot),
+    ".mancode",
+    "local",
+    "cache",
+    "git-ref",
+    "remote-bases",
+    `${parsed.taskId}.json`
+  );
+}
+function positiveInteger2(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
+  }
+  return value;
+}
+function isAlreadyExists19(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isNotFound23(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/team/git-ref-materialization.ts
 async function materializeGitRefTaskBundle(input) {
-  const projectRoot = path30.resolve(input.projectRoot);
-  const remoteRevision = positiveInteger2(
+  const projectRoot = path32.resolve(input.projectRoot);
+  const remoteRevision = positiveInteger3(
     input.remoteRevision,
     "git-ref materialization remoteRevision"
   );
@@ -18580,16 +18967,32 @@ async function materializeGitRefTaskBundle(input) {
     );
     const current = await readLocalTaskOrNull(projectRoot, bundle);
     const currentFence = await readTaskHeadFence(store, bundle.taskRef);
+    const recordedBase = await readGitRefTaskRemoteBase(
+      projectRoot,
+      bundle.taskRef
+    );
+    const quarantinedBase = recordedBase === null && currentFence !== null && currentFence.remoteRevision !== null ? await readQuarantinedGitRefTaskBundle(
+      projectRoot,
+      currentFence.remoteRevision,
+      bundle.taskRef,
+      {
+        taskRevision: currentFence.taskRevision,
+        aggregateDigest: currentFence.aggregateDigest,
+        ownershipEpoch: currentFence.ownershipEpoch,
+        codeRefHead: currentFence.codeRef.head
+      }
+    ) : null;
+    const effectivePredecessor = recordedBase?.bundle ?? quarantinedBase ?? predecessor;
     const status2 = classifyMaterialization(
       current,
       bundle,
-      predecessor,
+      effectivePredecessor,
       pendingMetadata
     );
     if (status2 === "created" && currentFence !== null) {
       throw new Error("MANCODE_SPLIT_BRAIN");
     }
-    const materializedPredecessor = status2 === "created" ? null : predecessor;
+    const materializedPredecessor = status2 === "created" ? null : effectivePredecessor;
     const targetFence = buildTargetFence({
       runtime,
       remoteRevision,
@@ -18601,6 +19004,7 @@ async function materializeGitRefTaskBundle(input) {
     });
     if (status2 === "unchanged") {
       await writeTargetFence(store, currentFence, targetFence, predecessor);
+      await recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle);
       return result(status2, bundle, null, targetFence);
     }
     const timestamp4 = now.toISOString();
@@ -18621,6 +19025,7 @@ async function materializeGitRefTaskBundle(input) {
     journal = { ...journal, state: "applying", updatedAt: timestamp4 };
     await replaceJournal(projectRoot, journal);
     await applyJournal(projectRoot, journal);
+    await recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle);
     journal = {
       ...journal,
       state: "committed",
@@ -18646,6 +19051,11 @@ async function recoverTaskMaterializationsWhileLocked(projectRoot, taskId) {
       continue;
     }
     await applyJournal(projectRoot, journal);
+    await recordGitRefTaskRemoteBase(
+      projectRoot,
+      journal.remoteRevision,
+      journal.targetBundle
+    );
     await replaceJournal(projectRoot, {
       ...journal,
       state: "committed",
@@ -18812,7 +19222,7 @@ async function replaceVerifiedFile(taskRoot2, relativePath, targetContent, prede
   const target = safeTaskPath(taskRoot2, relativePath);
   await ensureSafeDirectory(
     taskRoot2,
-    path30.dirname(relativePath).split(path30.sep)
+    path32.dirname(relativePath).split(path32.sep)
   );
   const current = await readSafeFileOrNull(target);
   if (contentMatches(relativePath, current, targetContent)) return;
@@ -18822,11 +19232,11 @@ async function replaceVerifiedFile(taskRoot2, relativePath, targetContent, prede
   if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath !== "summary.md") {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
-  const temporary = path30.join(
-    path30.dirname(target),
-    `.${path30.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path32.join(
+    path32.dirname(target),
+    `.${path32.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile26(temporary, targetContent, { encoding: "utf8", flag: "wx" });
+  await writeFile28(temporary, targetContent, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 function contentMatches(relativePath, current, expected) {
@@ -18876,44 +19286,44 @@ async function removeVerifiedFile(taskRoot2, relativePath, predecessorContent) {
 }
 async function readSafeFileOrNull(target) {
   try {
-    const before = await lstat14(target);
+    const before = await lstat16(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    const content = await readFile26(target, "utf8");
-    const after = await lstat14(target);
+    const content = await readFile28(target, "utf8");
+    const after = await lstat16(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     return content;
   } catch (error) {
-    if (isNotFound22(error)) return null;
+    if (isNotFound24(error)) return null;
     throw error;
   }
 }
 async function ensureSafeDirectory(root, segments) {
-  let current = path30.resolve(root);
+  let current = path32.resolve(root);
   for (const segment of segments) {
     if (!segment || segment === ".") continue;
     if (segment === ".." || segment.includes("/") || segment.includes("\\")) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    current = path30.join(current, segment);
+    current = path32.join(current, segment);
     try {
-      await mkdir23(current);
+      await mkdir25(current);
     } catch (error) {
-      if (!isAlreadyExists18(error)) throw error;
+      if (!isAlreadyExists20(error)) throw error;
     }
-    const entry = await lstat14(current);
+    const entry = await lstat16(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 function safeTaskPath(taskRoot2, relativePath) {
-  const target = path30.resolve(taskRoot2, relativePath);
-  const relative = path30.relative(taskRoot2, target);
-  if (!relative || relative.startsWith("..") || path30.isAbsolute(relative)) {
+  const target = path32.resolve(taskRoot2, relativePath);
+  const relative = path32.relative(taskRoot2, target);
+  if (!relative || relative.startsWith("..") || path32.isAbsolute(relative)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return target;
@@ -18925,7 +19335,7 @@ async function createJournal(projectRoot, journal) {
     "journals",
     "git-ref-materialize"
   ]);
-  await writeFile26(
+  await writeFile28(
     journalPath(projectRoot, journal.operationId),
     serialize11(journal),
     {
@@ -18936,11 +19346,11 @@ async function createJournal(projectRoot, journal) {
 }
 async function replaceJournal(projectRoot, journal) {
   const target = journalPath(projectRoot, journal.operationId);
-  const temporary = path30.join(
-    path30.dirname(target),
+  const temporary = path32.join(
+    path32.dirname(target),
     `.${journal.operationId}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile26(temporary, serialize11(journal), {
+  await writeFile28(temporary, serialize11(journal), {
     encoding: "utf8",
     flag: "wx"
   });
@@ -18948,7 +19358,7 @@ async function replaceJournal(projectRoot, journal) {
 }
 async function readJournal(target) {
   try {
-    const raw = JSON.parse(await readFile26(target, "utf8"));
+    const raw = JSON.parse(await readFile28(target, "utf8"));
     return parseJournal(raw);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -18961,15 +19371,15 @@ async function listJournals(projectRoot) {
   const directory = journalDirectory(projectRoot);
   let entries;
   try {
-    entries = await readdir12(directory);
+    entries = await readdir13(directory);
   } catch (error) {
-    if (isNotFound22(error)) return [];
+    if (isNotFound24(error)) return [];
     throw error;
   }
   const journals = [];
   for (const entry of entries.sort()) {
     if (!entry.endsWith(".json")) continue;
-    journals.push(await readJournal(path30.join(directory, entry)));
+    journals.push(await readJournal(path32.join(directory, entry)));
   }
   return journals;
 }
@@ -19012,7 +19422,7 @@ function parseJournal(value) {
     schemaVersion: 1,
     operationId: value.operationId,
     workspaceId: value.workspaceId,
-    remoteRevision: positiveInteger2(
+    remoteRevision: positiveInteger3(
       value.remoteRevision,
       "git-ref materialization remoteRevision"
     ),
@@ -19035,8 +19445,8 @@ function result(status2, bundle, localJournalPath, taskHeadFence) {
   };
 }
 function journalDirectory(projectRoot) {
-  return path30.join(
-    path30.resolve(projectRoot),
+  return path32.join(
+    path32.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -19045,13 +19455,13 @@ function journalDirectory(projectRoot) {
 }
 function journalPath(projectRoot, operationId) {
   assertUlid(operationId, "git-ref materialization operationId");
-  return path30.join(journalDirectory(projectRoot), `${operationId}.json`);
+  return path32.join(journalDirectory(projectRoot), `${operationId}.json`);
 }
 function serialize11(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
-function positiveInteger2(value, label) {
+function positiveInteger3(value, label) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
     throw new Error(`${label} must be a positive integer`);
   }
@@ -19065,23 +19475,23 @@ function timestamp2(value) {
 }
 async function pathExists2(target) {
   try {
-    await lstat14(target);
+    await lstat16(target);
     return true;
   } catch (error) {
-    if (isNotFound22(error)) return false;
+    if (isNotFound24(error)) return false;
     throw error;
   }
 }
-function isAlreadyExists18(error) {
+function isAlreadyExists20(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound22(error) {
+function isNotFound24(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/git-ref-workflow-repair.ts
 async function prepareGitRefWorkflowRepair(input) {
-  const root = path31.resolve(input.projectRoot);
+  const root = path33.resolve(input.projectRoot);
   const prepared2 = parsePrepared(input.prepared);
   const pendingMetadata = parseWorkflowMetadata(input.pendingMetadata);
   assertPendingMetadata2(prepared2, pendingMetadata);
@@ -19116,7 +19526,7 @@ async function prepareGitRefWorkflowRepair(input) {
 }
 async function recoverGitRefWorkflowRepair(projectRoot, operationId, transportReceipt = null, options = {}) {
   assertUlid(operationId, "git-ref workflow repair operationId");
-  const root = path31.resolve(projectRoot);
+  const root = path33.resolve(projectRoot);
   let journal = await requireJournal(root, operationId);
   await assertRecoveryAuthorized(root, journal, options);
   if (journal.state === "committed" || journal.state === "aborted") {
@@ -19348,21 +19758,21 @@ function parsePrepared(value) {
     throw new Error("MANCODE_REMOTE_WORKFLOW_REPAIR_JOURNAL_CORRUPT");
   }
   assertUlid(value.operationId, "git-ref workflow prepared operationId");
-  const expectedRemoteRevision = positiveInteger3(
+  const expectedRemoteRevision = positiveInteger4(
     value.expectedRemoteRevision,
     "git-ref workflow expectedRemoteRevision",
     true
   );
-  const expectedOwnershipEpoch = positiveInteger3(
+  const expectedOwnershipEpoch = positiveInteger4(
     value.expectedOwnershipEpoch,
     "git-ref workflow expectedOwnershipEpoch",
     true
   );
-  const targetRemoteRevision = positiveInteger3(
+  const targetRemoteRevision = positiveInteger4(
     value.targetRemoteRevision,
     "git-ref workflow targetRemoteRevision"
   );
-  const targetOwnershipEpoch = positiveInteger3(
+  const targetOwnershipEpoch = positiveInteger4(
     value.targetOwnershipEpoch,
     "git-ref workflow targetOwnershipEpoch",
     true
@@ -19482,12 +19892,12 @@ async function createJournal2(projectRoot, journal) {
   await ensureJournalDirectory(projectRoot);
   const target = gitRefWorkflowRepairJournalPath(projectRoot, journal.operationId);
   try {
-    await writeFile27(target, serialize12(journal), {
+    await writeFile29(target, serialize12(journal), {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
-    if (!isAlreadyExists19(error)) throw error;
+    if (!isAlreadyExists21(error)) throw error;
     const existing = await requireJournal(projectRoot, journal.operationId);
     if (digestCanonicalJson(existing) !== digestCanonicalJson(journal)) {
       throw new Error("MANCODE_REMOTE_WORKFLOW_REPAIR_JOURNAL_CONFLICT");
@@ -19503,10 +19913,10 @@ async function replaceJournal2(projectRoot, journal) {
 async function requireJournal(projectRoot, operationId) {
   try {
     return parseJournal2(
-      JSON.parse(await readFile27(gitRefWorkflowRepairJournalPath(projectRoot, operationId), "utf8"))
+      JSON.parse(await readFile29(gitRefWorkflowRepairJournalPath(projectRoot, operationId), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound23(error)) {
+    if (error instanceof SyntaxError || isNotFound25(error)) {
       throw new Error("MANCODE_REMOTE_WORKFLOW_REPAIR_JOURNAL_NOT_FOUND");
     }
     throw error;
@@ -19522,44 +19932,44 @@ function metadataFromBundle(bundle) {
   return parseWorkflowMetadata(artifact2.content);
 }
 function metadataPath2(projectRoot, taskRef) {
-  return path31.join(taskRootPath(projectRoot, taskRef), "metadata.json");
+  return path33.join(taskRootPath(projectRoot, taskRef), "metadata.json");
 }
 async function readSafeFile(target) {
-  const before = await lstat15(target);
+  const before = await lstat17(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const content = await readFile27(target, "utf8");
-  const after = await lstat15(target);
+  const content = await readFile29(target, "utf8");
+  const after = await lstat17(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return content;
 }
 async function atomicWrite(target, content) {
-  const temporary = path31.join(
-    path31.dirname(target),
-    `.${path31.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path33.join(
+    path33.dirname(target),
+    `.${path33.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile27(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile29(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory(projectRoot) {
-  let current = path31.resolve(projectRoot);
+  let current = path33.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-workflow"]) {
-    current = path31.join(current, segment);
+    current = path33.join(current, segment);
     try {
-      await mkdir24(current);
+      await mkdir26(current);
     } catch (error) {
-      if (!isAlreadyExists19(error)) throw error;
+      if (!isAlreadyExists21(error)) throw error;
     }
-    const entry = await lstat15(current);
+    const entry = await lstat17(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
-function positiveInteger3(value, label, allowZero = false) {
+function positiveInteger4(value, label, allowZero = false) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) {
     throw new Error(`${label} is invalid`);
   }
@@ -19578,15 +19988,15 @@ function serialize12(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
-function isAlreadyExists19(error) {
+function isAlreadyExists21(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound23(error) {
+function isNotFound25(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/commands/v3-support.ts
-import path32 from "path";
+import path34 from "path";
 
 // src/runtime/session-identity.ts
 import { createHash as createHash7 } from "crypto";
@@ -19673,7 +20083,7 @@ var EXIT_V3_OK = 0;
 var EXIT_V3_INVALID_ARGUMENT = 2;
 var EXIT_V3_BLOCKED = 3;
 async function readV3CommandProject(projectRoot) {
-  const root = path32.resolve(projectRoot);
+  const root = path34.resolve(projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = new V3ContextStore(root);
   return {
@@ -20381,19 +20791,19 @@ function parseExpectedRevision2(value) {
 // src/commands/init.ts
 import { promises as fs4 } from "fs";
 import os from "os";
-import path46 from "path";
+import path48 from "path";
 import process5 from "process";
 
 // src/installers/claude-code.ts
 import {
   access,
-  mkdir as mkdir26,
-  readFile as readFile29,
-  readdir as readdir14,
+  mkdir as mkdir28,
+  readFile as readFile31,
+  readdir as readdir15,
   rm as rm13,
-  writeFile as writeFile29
+  writeFile as writeFile31
 } from "fs/promises";
-import path34 from "path";
+import path36 from "path";
 
 // src/templates/agents/scout.ts
 var SCOUT_AGENT = {
@@ -21714,8 +22124,8 @@ ${spec.body}
 }
 
 // src/installers/common.ts
-import { mkdir as mkdir25, readFile as readFile28, stat as stat3, writeFile as writeFile28 } from "fs/promises";
-import path33 from "path";
+import { mkdir as mkdir27, readFile as readFile30, stat as stat3, writeFile as writeFile30 } from "fs/promises";
+import path35 from "path";
 
 // src/templates/defaults.ts
 var DEFAULT_CONFIG = {
@@ -21750,50 +22160,50 @@ var EMPTY_STYLE_TOKENS = {
 
 // src/installers/common.ts
 async function installMancodeCore(projectRoot) {
-  const mancodeDir = path33.join(projectRoot, ".mancode");
-  await mkdir25(path33.join(mancodeDir, "hooks"), { recursive: true });
-  await mkdir25(path33.join(mancodeDir, "aesthetics"), { recursive: true });
-  await mkdir25(path33.join(mancodeDir, "logs"), { recursive: true });
-  await mkdir25(path33.join(mancodeDir, "workflows"), { recursive: true });
+  const mancodeDir = path35.join(projectRoot, ".mancode");
+  await mkdir27(path35.join(mancodeDir, "hooks"), { recursive: true });
+  await mkdir27(path35.join(mancodeDir, "aesthetics"), { recursive: true });
+  await mkdir27(path35.join(mancodeDir, "logs"), { recursive: true });
+  await mkdir27(path35.join(mancodeDir, "workflows"), { recursive: true });
   await ensureTeamMemory(projectRoot);
-  await mkdir25(path33.join(mancodeDir, "preseason-reports"), { recursive: true });
-  const configPath = path33.join(mancodeDir, "config.json");
+  await mkdir27(path35.join(mancodeDir, "preseason-reports"), { recursive: true });
+  const configPath = path35.join(mancodeDir, "config.json");
   if (!await pathExists3(configPath)) {
-    await writeFile28(
+    await writeFile30(
       configPath,
       `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
 `,
       "utf-8"
     );
   }
-  await installHooks(path33.join(mancodeDir, "hooks"));
-  const tokensPath = path33.join(mancodeDir, "aesthetics", "style-tokens.json");
+  await installHooks(path35.join(mancodeDir, "hooks"));
+  const tokensPath = path35.join(mancodeDir, "aesthetics", "style-tokens.json");
   if (!await pathExists3(tokensPath)) {
-    await writeFile28(
+    await writeFile30(
       tokensPath,
       `${JSON.stringify(EMPTY_STYLE_TOKENS, null, 2)}
 `,
       "utf-8"
     );
   }
-  const logPath = path33.join(mancodeDir, "logs", "hooks.log");
+  const logPath = path35.join(mancodeDir, "logs", "hooks.log");
   if (!await pathExists3(logPath)) {
-    await writeFile28(logPath, "", "utf-8");
+    await writeFile30(logPath, "", "utf-8");
   }
 }
 async function readTextIfExists(filePath) {
   try {
-    return await readFile28(filePath, "utf-8");
+    return await readFile30(filePath, "utf-8");
   } catch (err) {
     if (isNodeError2(err) && err.code === "ENOENT") return "";
     throw err;
   }
 }
 async function installHooks(hooksDir) {
-  const sessionStartDst = path33.join(hooksDir, "session-start.mjs");
-  await writeFile28(sessionStartDst, SESSION_START_HOOK, "utf-8");
-  const userPromptDst = path33.join(hooksDir, "user-prompt-submit.mjs");
-  await writeFile28(userPromptDst, USER_PROMPT_SUBMIT_HOOK, "utf-8");
+  const sessionStartDst = path35.join(hooksDir, "session-start.mjs");
+  await writeFile30(sessionStartDst, SESSION_START_HOOK, "utf-8");
+  const userPromptDst = path35.join(hooksDir, "user-prompt-submit.mjs");
+  await writeFile30(userPromptDst, USER_PROMPT_SUBMIT_HOOK, "utf-8");
 }
 async function pathExists3(p) {
   try {
@@ -21832,39 +22242,39 @@ var LEGACY_CLAUDE_SKILL_SETTINGS = {
 };
 var LEGACY_MVP2_SKILL_NAMES = ["mamba", "man8"];
 async function validateClaudeCodeSettings(projectRoot) {
-  await readClaudeSettings(path34.join(projectRoot, ".claude"));
+  await readClaudeSettings(path36.join(projectRoot, ".claude"));
 }
 async function installClaudeCode(projectRoot, options) {
-  const claudeDir = path34.join(projectRoot, ".claude");
+  const claudeDir = path36.join(projectRoot, ".claude");
   const settings = await readClaudeSettings(claudeDir);
   const force = options.force ?? false;
   await validateClaudeWriteTargets(claudeDir, options.minimal ?? false, force);
   await installMancodeCore(projectRoot);
-  await mkdir26(path34.join(claudeDir, "skills"), { recursive: true });
-  await installSoloSkill(path34.join(claudeDir, "skills"), force);
+  await mkdir28(path36.join(claudeDir, "skills"), { recursive: true });
+  await installSoloSkill(path36.join(claudeDir, "skills"), force);
   if (options.minimal) {
-    await uninstallMvp2Skills(path34.join(claudeDir, "skills"));
+    await uninstallMvp2Skills(path36.join(claudeDir, "skills"));
   } else {
-    await installMvp2Skills(path34.join(claudeDir, "skills"), force);
+    await installMvp2Skills(path36.join(claudeDir, "skills"), force);
   }
   if (options.minimal) {
-    await uninstallAgents(path34.join(claudeDir, "agents"));
+    await uninstallAgents(path36.join(claudeDir, "agents"));
   } else {
-    await installAgents(path34.join(claudeDir, "agents"), force);
+    await installAgents(path36.join(claudeDir, "agents"), force);
   }
   await updateClaudeSettings(claudeDir, settings);
   await removeLegacyHookFiles(projectRoot);
 }
 async function validateClaudeWriteTargets(claudeDir, minimal, force) {
   if (!force) return;
-  const skillsDir = path34.join(claudeDir, "skills");
+  const skillsDir = path36.join(claudeDir, "skills");
   await assertWritableClaudeSkill(skillsDir, "solo");
   if (minimal) return;
   for (const skill of MVP2_SKILLS) {
     await assertWritableClaudeSkill(skillsDir, skill.name);
   }
   for (const agent of ALL_AGENTS) {
-    const agentPath = path34.join(claudeDir, "agents", `${agent.name}.md`);
+    const agentPath = path36.join(claudeDir, "agents", `${agent.name}.md`);
     const existing = await readTextIfExists2(agentPath);
     if (existing !== null && !isGeneratedClaudeAgent(existing, agent.name)) {
       throw new Error(
@@ -21874,7 +22284,7 @@ async function validateClaudeWriteTargets(claudeDir, minimal, force) {
   }
 }
 async function assertWritableClaudeSkill(skillsDir, modeName) {
-  const skillPath = path34.join(skillsDir, modeName, "SKILL.md");
+  const skillPath = path36.join(skillsDir, modeName, "SKILL.md");
   const existing = await readTextIfExists2(skillPath);
   if (existing !== null && !isGeneratedClaudeSkill(existing, modeName)) {
     throw new Error(
@@ -21883,10 +22293,10 @@ async function assertWritableClaudeSkill(skillsDir, modeName) {
   }
 }
 async function removeLegacyHookFiles(projectRoot) {
-  const hooksDir = path34.join(projectRoot, ".mancode", "hooks");
+  const hooksDir = path36.join(projectRoot, ".mancode", "hooks");
   await Promise.all([
-    rm13(path34.join(hooksDir, "session-start.sh"), { force: true }),
-    rm13(path34.join(hooksDir, "user-prompt-submit.sh"), { force: true })
+    rm13(path36.join(hooksDir, "session-start.sh"), { force: true }),
+    rm13(path36.join(hooksDir, "user-prompt-submit.sh"), { force: true })
   ]);
 }
 async function installSoloSkill(skillsDir, force) {
@@ -21922,8 +22332,8 @@ async function uninstallMvp2Skills(skillsDir) {
   await removeManagedLegacyMvp2Skills(skillsDir);
 }
 async function installProjectSkill(skillsDir, skill, force = true) {
-  const skillDir = path34.join(skillsDir, skill.name);
-  const skillPath = path34.join(skillDir, "SKILL.md");
+  const skillDir = path36.join(skillsDir, skill.name);
+  const skillPath = path36.join(skillDir, "SKILL.md");
   const existing = await readTextIfExists2(skillPath);
   if (existing !== null && !force) {
     return;
@@ -21933,24 +22343,24 @@ async function installProjectSkill(skillsDir, skill, force = true) {
       `refusing to overwrite user-authored Claude Code skill: ${skillPath}`
     );
   }
-  await mkdir26(skillDir, { recursive: true });
-  await writeFile29(
+  await mkdir28(skillDir, { recursive: true });
+  await writeFile31(
     skillPath,
     addManagedMarker(renderSkill(skill), CLAUDE_SKILL_MANAGED_MARKER),
     "utf-8"
   );
 }
 async function removeLegacyFlatSkill(skillsDir, legacyName, modeName) {
-  const legacyPath = path34.join(skillsDir, `${legacyName}.md`);
+  const legacyPath = path36.join(skillsDir, `${legacyName}.md`);
   const content = await readTextIfExists2(legacyPath);
   if (content && isGeneratedClaudeSkill(content, modeName)) {
     await rm13(legacyPath, { force: true });
   }
 }
 async function installAgents(agentsDir, force) {
-  await mkdir26(agentsDir, { recursive: true });
+  await mkdir28(agentsDir, { recursive: true });
   for (const agent of ALL_AGENTS) {
-    const agentPath = path34.join(agentsDir, `${agent.name}.md`);
+    const agentPath = path36.join(agentsDir, `${agent.name}.md`);
     if (!force) {
       try {
         await access(agentPath);
@@ -21968,12 +22378,12 @@ async function installAgents(agentsDir, force) {
       renderAgent(agent),
       CLAUDE_AGENT_MANAGED_MARKER
     );
-    await writeFile29(agentPath, content, "utf-8");
+    await writeFile31(agentPath, content, "utf-8");
   }
 }
 async function uninstallAgents(agentsDir) {
   for (const agent of ALL_AGENTS) {
-    const agentPath = path34.join(agentsDir, `${agent.name}.md`);
+    const agentPath = path36.join(agentsDir, `${agent.name}.md`);
     const content = await readTextIfExists2(agentPath);
     if (content && isGeneratedClaudeAgent(content, agent.name)) {
       await rm13(agentPath, { force: true });
@@ -21981,8 +22391,8 @@ async function uninstallAgents(agentsDir) {
   }
 }
 async function removeClaudeGeneratedContent(projectRoot) {
-  const claudeDir = path34.join(projectRoot, ".claude");
-  const skillsDir = path34.join(claudeDir, "skills");
+  const claudeDir = path36.join(projectRoot, ".claude");
+  const skillsDir = path36.join(claudeDir, "skills");
   for (const modeName of [
     "solo",
     ...LEGACY_MVP2_SKILL_NAMES,
@@ -21991,11 +22401,11 @@ async function removeClaudeGeneratedContent(projectRoot) {
     await removeGeneratedSkillDir(skillsDir, modeName);
     await removeLegacyFlatSkill(skillsDir, `mancode-${modeName}`, modeName);
   }
-  await uninstallAgents(path34.join(claudeDir, "agents"));
+  await uninstallAgents(path36.join(claudeDir, "agents"));
 }
 async function removeGeneratedSkillDir(skillsDir, modeName) {
-  const skillDir = path34.join(skillsDir, modeName);
-  const skillPath = path34.join(skillDir, "SKILL.md");
+  const skillDir = path36.join(skillsDir, modeName);
+  const skillPath = path36.join(skillDir, "SKILL.md");
   const content = await readTextIfExists2(skillPath);
   if (!content || !isGeneratedClaudeSkill(content, modeName)) return;
   await rm13(skillPath, { force: true });
@@ -22019,7 +22429,7 @@ ${marker}
 }
 async function readTextIfExists2(filePath) {
   try {
-    return await readFile29(filePath, "utf-8");
+    return await readFile31(filePath, "utf-8");
   } catch (error) {
     if (isNodeError3(error) && error.code === "ENOENT") return null;
     throw error;
@@ -22027,16 +22437,16 @@ async function readTextIfExists2(filePath) {
 }
 async function removeIfEmpty(dir) {
   try {
-    if ((await readdir14(dir)).length === 0) {
+    if ((await readdir15(dir)).length === 0) {
       await rm13(dir, { recursive: true, force: true });
     }
   } catch {
   }
 }
 async function readClaudeSettings(claudeDir) {
-  const settingsPath = path34.join(claudeDir, "settings.json");
+  const settingsPath = path36.join(claudeDir, "settings.json");
   try {
-    const raw = await readFile29(settingsPath, "utf-8");
+    const raw = await readFile31(settingsPath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     if (isNodeError3(err) && err.code === "ENOENT") {
@@ -22049,7 +22459,7 @@ async function readClaudeSettings(claudeDir) {
   }
 }
 async function updateClaudeSettings(claudeDir, settings) {
-  const settingsPath = path34.join(claudeDir, "settings.json");
+  const settingsPath = path36.join(claudeDir, "settings.json");
   settings.hooks = settings.hooks || {};
   settings.hooks.SessionStart = [
     ...normalizeHookGroups(settings.hooks.SessionStart),
@@ -22062,7 +22472,7 @@ async function updateClaudeSettings(claudeDir, settings) {
   removeLegacyMancodeSkillSettings(settings);
   const content = `${JSON.stringify(settings, null, 2)}
 `;
-  await writeFile29(settingsPath, content, "utf-8");
+  await writeFile31(settingsPath, content, "utf-8");
 }
 function removeLegacyMancodeSkillSettings(settings) {
   if (!settings.skills) return;
@@ -22147,12 +22557,12 @@ function isNodeError3(err) {
 }
 
 // src/installers/cursor.ts
-import { mkdir as mkdir28, readFile as readFile32, rm as rm15, writeFile as writeFile31 } from "fs/promises";
-import path37 from "path";
+import { mkdir as mkdir30, readFile as readFile34, rm as rm15, writeFile as writeFile33 } from "fs/promises";
+import path39 from "path";
 
 // src/installers/mode-skills.ts
-import { mkdir as mkdir27, readFile as readFile30, readdir as readdir15, rm as rm14, writeFile as writeFile30 } from "fs/promises";
-import path35 from "path";
+import { mkdir as mkdir29, readFile as readFile32, readdir as readdir16, rm as rm14, writeFile as writeFile32 } from "fs/promises";
+import path37 from "path";
 var MODE_NAMES = [
   "manba",
   "man",
@@ -22210,10 +22620,10 @@ async function installCodexSkills(projectRoot, minimal) {
     await removeCodexSkills(projectRoot);
     return;
   }
-  const skillsDir = path35.join(projectRoot, ".agents", "skills");
+  const skillsDir = path37.join(projectRoot, ".agents", "skills");
   for (const mode of MODE_NAMES) {
-    const modeDir = path35.join(skillsDir, mode);
-    await mkdir27(modeDir, { recursive: true });
+    const modeDir = path37.join(skillsDir, mode);
+    await mkdir29(modeDir, { recursive: true });
     const meta = MODE_META[mode];
     const content = [
       "---",
@@ -22227,7 +22637,7 @@ async function installCodexSkills(projectRoot, minimal) {
       ""
     ].join("\n");
     await writeManagedSkill(
-      path35.join(modeDir, "SKILL.md"),
+      path37.join(modeDir, "SKILL.md"),
       content,
       CODEX_SKILL_MANAGED_MARKER,
       "Codex",
@@ -22241,10 +22651,10 @@ async function installZcodeSkills(projectRoot, minimal) {
     await removeZcodeSkills(projectRoot);
     return;
   }
-  const skillsDir = path35.join(projectRoot, ".agents", "skills");
+  const skillsDir = path37.join(projectRoot, ".agents", "skills");
   for (const mode of MODE_NAMES) {
-    const modeDir = path35.join(skillsDir, mode);
-    await mkdir27(modeDir, { recursive: true });
+    const modeDir = path37.join(skillsDir, mode);
+    await mkdir29(modeDir, { recursive: true });
     const meta = MODE_META[mode];
     const content = [
       "---",
@@ -22258,7 +22668,7 @@ async function installZcodeSkills(projectRoot, minimal) {
       ""
     ].join("\n");
     await writeManagedSkill(
-      path35.join(modeDir, "SKILL.md"),
+      path37.join(modeDir, "SKILL.md"),
       content,
       ZCODE_SKILL_MANAGED_MARKER,
       "ZCode",
@@ -22272,8 +22682,8 @@ async function installCursorCommands(projectRoot, minimal) {
     await removeCursorCommands(projectRoot);
     return;
   }
-  const commandsDir = path35.join(projectRoot, ".cursor", "commands");
-  await mkdir27(commandsDir, { recursive: true });
+  const commandsDir = path37.join(projectRoot, ".cursor", "commands");
+  await mkdir29(commandsDir, { recursive: true });
   for (const mode of MODE_NAMES) {
     const meta = MODE_META[mode];
     const content = [
@@ -22287,22 +22697,22 @@ async function installCursorCommands(projectRoot, minimal) {
       ""
     ].join("\n");
     await writeManagedModeFile(
-      path35.join(commandsDir, `${mode}.md`),
+      path37.join(commandsDir, `${mode}.md`),
       content,
       mode,
       "Cursor"
     );
   }
-  await removeManagedModeFile(path35.join(commandsDir, "mamba.md"), "mamba");
-  await removeLegacyGeneratedModeFile(path35.join(commandsDir, "man8.md"));
+  await removeManagedModeFile(path37.join(commandsDir, "mamba.md"), "mamba");
+  await removeLegacyGeneratedModeFile(path37.join(commandsDir, "man8.md"));
 }
 async function installCopilotPrompts(projectRoot, minimal) {
   if (minimal) {
     await removeCopilotPrompts(projectRoot);
     return;
   }
-  const promptsDir = path35.join(projectRoot, ".github", "prompts");
-  await mkdir27(promptsDir, { recursive: true });
+  const promptsDir = path37.join(projectRoot, ".github", "prompts");
+  await mkdir29(promptsDir, { recursive: true });
   for (const mode of MODE_NAMES) {
     const meta = MODE_META[mode];
     const content = [
@@ -22317,33 +22727,33 @@ async function installCopilotPrompts(projectRoot, minimal) {
       ""
     ].join("\n");
     await writeManagedModeFile(
-      path35.join(promptsDir, `${mode}.prompt.md`),
+      path37.join(promptsDir, `${mode}.prompt.md`),
       content,
       mode,
       "GitHub Copilot"
     );
   }
   await removeManagedModeFile(
-    path35.join(promptsDir, "mamba.prompt.md"),
+    path37.join(promptsDir, "mamba.prompt.md"),
     "mamba"
   );
-  await removeLegacyGeneratedModeFile(path35.join(promptsDir, "man8.prompt.md"));
+  await removeLegacyGeneratedModeFile(path37.join(promptsDir, "man8.prompt.md"));
 }
 async function removeCodexSkills(projectRoot) {
   if (!await platformNeedsSharedSkills(projectRoot, "zcode")) {
     await cleanManagedSkills(
-      path35.join(projectRoot, ".agents", "skills"),
+      path37.join(projectRoot, ".agents", "skills"),
       MANCODE_AGENT_SKILL_MARKERS
     );
   }
-  await cleanManagedSkills(path35.join(projectRoot, ".codex", "skills"), [
+  await cleanManagedSkills(path37.join(projectRoot, ".codex", "skills"), [
     CODEX_SKILL_MANAGED_MARKER
   ]);
 }
 async function cleanManagedSkills(skillsDir, markers) {
   for (const mode of [...MODE_NAMES, ...LEGACY_MODE_NAMES]) {
-    const modeDir = path35.join(skillsDir, mode);
-    const skillPath = path35.join(modeDir, "SKILL.md");
+    const modeDir = path37.join(skillsDir, mode);
+    const skillPath = path37.join(modeDir, "SKILL.md");
     if (await isManagedByAnyMarker(skillPath, markers)) {
       await rm14(skillPath, { force: true });
       await removeIfEmpty2(modeDir);
@@ -22354,17 +22764,17 @@ async function cleanManagedSkills(skillsDir, markers) {
 async function removeZcodeSkills(projectRoot) {
   if (!await platformNeedsSharedSkills(projectRoot, "codex")) {
     await cleanManagedSkills(
-      path35.join(projectRoot, ".agents", "skills"),
+      path37.join(projectRoot, ".agents", "skills"),
       MANCODE_AGENT_SKILL_MARKERS
     );
   }
-  await cleanManagedSkills(path35.join(projectRoot, ".zcode", "skills"), [
+  await cleanManagedSkills(path37.join(projectRoot, ".zcode", "skills"), [
     ZCODE_SKILL_MANAGED_MARKER
   ]);
 }
 async function removeCursorCommands(projectRoot) {
   for (const mode of [...MODE_NAMES, ...LEGACY_MODE_NAMES]) {
-    const filePath = path35.join(
+    const filePath = path37.join(
       projectRoot,
       ".cursor",
       "commands",
@@ -22376,7 +22786,7 @@ async function removeCursorCommands(projectRoot) {
 }
 async function removeCopilotPrompts(projectRoot) {
   for (const mode of [...MODE_NAMES, ...LEGACY_MODE_NAMES]) {
-    const filePath = path35.join(
+    const filePath = path37.join(
       projectRoot,
       ".github",
       "prompts",
@@ -22393,7 +22803,7 @@ async function writeManagedModeFile(filePath, content, mode, platformLabel) {
       `refusing to overwrite user-authored ${platformLabel} mode file: ${filePath}`
     );
   }
-  await writeFile30(filePath, content, "utf-8");
+  await writeFile32(filePath, content, "utf-8");
 }
 async function removeManagedModeFile(filePath, mode) {
   const content = await readTextIfExists3(filePath);
@@ -22412,8 +22822,8 @@ function isGeneratedModeFile(content, mode) {
 }
 async function removeLegacyManagedSkills(skillsDir, markers) {
   for (const mode of LEGACY_MODE_NAMES) {
-    const modeDir = path35.join(skillsDir, mode);
-    const skillPath = path35.join(modeDir, "SKILL.md");
+    const modeDir = path37.join(skillsDir, mode);
+    const skillPath = path37.join(modeDir, "SKILL.md");
     const content = await readTextIfExists3(skillPath);
     if (content && markers.some((marker) => content.includes(marker))) {
       await rm14(skillPath, { force: true });
@@ -22423,7 +22833,7 @@ async function removeLegacyManagedSkills(skillsDir, markers) {
 }
 async function removeIfEmpty2(dir) {
   try {
-    const entries = await readdir15(dir);
+    const entries = await readdir16(dir);
     if (entries.length === 0) {
       await rm14(dir, { recursive: true, force: true });
     }
@@ -22437,7 +22847,7 @@ async function writeManagedSkill(skillPath, content, marker, platformLabel, reco
       `refusing to overwrite user-authored ${platformLabel} skill: ${skillPath}`
     );
   }
-  await writeFile30(skillPath, content, "utf-8");
+  await writeFile32(skillPath, content, "utf-8");
 }
 async function isManagedByAnyMarker(skillPath, markers) {
   const content = await readTextIfExists3(skillPath);
@@ -22445,8 +22855,8 @@ async function isManagedByAnyMarker(skillPath, markers) {
 }
 async function platformNeedsSharedSkills(projectRoot, platform) {
   try {
-    const raw = await readFile30(
-      path35.join(projectRoot, ".mancode", "config.json"),
+    const raw = await readFile32(
+      path37.join(projectRoot, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -22465,7 +22875,7 @@ function isRecord5(value) {
 }
 async function readTextIfExists3(filePath) {
   try {
-    return await readFile30(filePath, "utf-8");
+    return await readFile32(filePath, "utf-8");
   } catch (error) {
     if (isNodeError4(error) && error.code === "ENOENT") return null;
     throw error;
@@ -22584,18 +22994,18 @@ var MODE_META = {
 };
 
 // src/installers/shared-content.ts
-import { readFile as readFile31 } from "fs/promises";
-import path36 from "path";
+import { readFile as readFile33 } from "fs/promises";
+import path38 from "path";
 async function generateSharedContent(projectRoot, options) {
   const [state, tokens, profile] = await Promise.all([
     readJson(
-      path36.join(projectRoot, ".mancode", "state.json")
+      path38.join(projectRoot, ".mancode", "state.json")
     ),
     readJson(
-      path36.join(projectRoot, ".mancode", "aesthetics", "style-tokens.json")
+      path38.join(projectRoot, ".mancode", "aesthetics", "style-tokens.json")
     ),
     readJson(
-      path36.join(projectRoot, ".mancode", "project-profile.json")
+      path38.join(projectRoot, ".mancode", "project-profile.json")
     )
   ]);
   const currentProfile = options.projectProfile ?? profile;
@@ -22725,7 +23135,7 @@ function renderPlatformDowngrade(options) {
 }
 async function readJson(filePath) {
   try {
-    return JSON.parse(await readFile31(filePath, "utf-8"));
+    return JSON.parse(await readFile33(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -22770,8 +23180,8 @@ var MANCODE_CURSOR_RULE_FILES = [
 ];
 async function installCursor(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const rulesDir = path37.join(projectRoot, ".cursor", "rules");
-  await mkdir28(rulesDir, { recursive: true });
+  const rulesDir = path39.join(projectRoot, ".cursor", "rules");
+  await mkdir30(rulesDir, { recursive: true });
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "cursor",
     displayName: "Cursor",
@@ -22859,14 +23269,14 @@ async function writeRule(rulesDir, fileName, description, alwaysApply, body) {
 
 ${body.trim()}
 `;
-  const rulePath = path37.join(rulesDir, fileName);
+  const rulePath = path39.join(rulesDir, fileName);
   const existing = await readTextIfExists4(rulePath);
   if (existing !== null && !isGeneratedCursorRule(existing, fileName)) {
     throw new Error(
       `refusing to overwrite user-authored Cursor rule: ${rulePath}`
     );
   }
-  await writeFile31(
+  await writeFile33(
     rulePath,
     content.replace("---\n\n", `---
 
@@ -22880,23 +23290,23 @@ async function removeAdvancedRules(rulesDir) {
   for (const fileName of MANCODE_CURSOR_ADVANCED_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
-  await removeLegacyCursorRules(path37.dirname(path37.dirname(rulesDir)));
+  await removeLegacyCursorRules(path39.dirname(path39.dirname(rulesDir)));
 }
 async function removeCursorGeneratedRules(projectRoot) {
-  const rulesDir = path37.join(projectRoot, ".cursor", "rules");
+  const rulesDir = path39.join(projectRoot, ".cursor", "rules");
   for (const fileName of MANCODE_CURSOR_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
   await removeLegacyCursorRules(projectRoot);
 }
 async function removeLegacyCursorRules(projectRoot) {
-  const rulesDir = path37.join(projectRoot, ".cursor", "rules");
+  const rulesDir = path39.join(projectRoot, ".cursor", "rules");
   for (const fileName of MANCODE_CURSOR_LEGACY_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
 }
 async function removeGeneratedCursorRule(rulesDir, fileName) {
-  const rulePath = path37.join(rulesDir, fileName);
+  const rulePath = path39.join(rulesDir, fileName);
   const content = await readTextIfExists4(rulePath);
   if (content && isGeneratedCursorRule(content, fileName)) {
     await rm15(rulePath, { force: true });
@@ -22918,7 +23328,7 @@ function isGeneratedCursorRule(content, fileName) {
 }
 async function readTextIfExists4(filePath) {
   try {
-    return await readFile32(filePath, "utf-8");
+    return await readFile34(filePath, "utf-8");
   } catch (error) {
     if (isNodeError5(error) && error.code === "ENOENT") return null;
     throw error;
@@ -22972,16 +23382,16 @@ function renderManpsRule() {
 
 // src/installers/platform-status.ts
 import { promises as fs } from "fs";
-import path39 from "path";
+import path41 from "path";
 
 // src/installers/zcode.ts
-import { writeFile as writeFile32 } from "fs/promises";
-import path38 from "path";
+import { writeFile as writeFile34 } from "fs/promises";
+import path40 from "path";
 var ZCODE_MANCODE_START_MARKER = "<!-- mancode:zcode:start -->";
 var ZCODE_MANCODE_END_MARKER = "<!-- mancode:zcode:end -->";
 async function installZcode(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path38.join(projectRoot, "AGENTS.md");
+  const agentsPath = path40.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "zcode",
@@ -23006,7 +23416,7 @@ async function installZcode(projectRoot, options) {
     sharedContent.trim(),
     ZCODE_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile32(
+  await writeFile34(
     agentsPath,
     replaceManagedBlock(
       existing,
@@ -23036,13 +23446,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path39.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path41.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path39.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path39.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path41.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path41.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -23058,7 +23468,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path39.join(rootDir, ".cursor", "rules", file)
+        (file) => path41.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -23073,13 +23483,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path39.join(rootDir, ".cursor", "rules", file)
+          (file) => path41.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path39.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path41.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -23092,7 +23502,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path39.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path41.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -23109,9 +23519,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path39.join(rootDir, ".agents", "skills");
+    const skillsDir = path41.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path39.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path41.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -23123,7 +23533,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path39.join(rootDir, "AGENTS.md"),
+      path41.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -23143,9 +23553,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path39.join(rootDir, ".agents", "skills");
+    const skillsDir = path41.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path39.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path41.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -23156,7 +23566,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path39.join(rootDir, ".github", "copilot-instructions.md")
+    path41.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -23167,9 +23577,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path39.join(rootDir, ".github", "prompts");
+    const promptsDir = path41.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path39.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path41.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -23202,13 +23612,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path39.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path41.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path39.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path41.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -23236,7 +23646,7 @@ async function fileHasAnyMarker(filePath, needles) {
 async function isPlatformMinimal(rootDir, platform) {
   try {
     const raw = await fs.readFile(
-      path39.join(rootDir, ".mancode", "config.json"),
+      path41.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -23258,7 +23668,7 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs.readFile(
-      path39.join(rootDir, ".claude", "settings.json"),
+      path41.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -23299,11 +23709,11 @@ function isRecord6(value) {
 }
 
 // src/installers/codex.ts
-import { writeFile as writeFile33 } from "fs/promises";
-import path40 from "path";
+import { writeFile as writeFile35 } from "fs/promises";
+import path42 from "path";
 async function installCodex(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path40.join(projectRoot, "AGENTS.md");
+  const agentsPath = path42.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "codex",
@@ -23328,18 +23738,18 @@ async function installCodex(projectRoot, options) {
     sharedContent.trim(),
     DEFAULT_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile33(agentsPath, replaceManagedBlock(existing, block), "utf-8");
+  await writeFile35(agentsPath, replaceManagedBlock(existing, block), "utf-8");
   await installCodexSkills(projectRoot, options.minimal ?? false);
 }
 
 // src/installers/copilot.ts
-import { mkdir as mkdir29, writeFile as writeFile34 } from "fs/promises";
-import path41 from "path";
+import { mkdir as mkdir31, writeFile as writeFile36 } from "fs/promises";
+import path43 from "path";
 async function installCopilot(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const githubDir = path41.join(projectRoot, ".github");
-  await mkdir29(githubDir, { recursive: true });
-  const instructionsPath = path41.join(githubDir, "copilot-instructions.md");
+  const githubDir = path43.join(projectRoot, ".github");
+  await mkdir31(githubDir, { recursive: true });
+  const instructionsPath = path43.join(githubDir, "copilot-instructions.md");
   const existing = await readTextIfExists(instructionsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "copilot",
@@ -23367,7 +23777,7 @@ async function installCopilot(projectRoot, options) {
     sections.push("", renderCopilotPromptConventions());
   }
   sections.push(DEFAULT_MANCODE_END_MARKER);
-  await writeFile34(
+  await writeFile36(
     instructionsPath,
     replaceManagedBlock(existing, sections.join("\n")),
     "utf-8"
@@ -23463,12 +23873,12 @@ function isPlatformName(platform) {
 }
 
 // src/system/detect-team.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { access as access2 } from "fs/promises";
-import path42 from "path";
+import path44 from "path";
 import process2 from "process";
-import { promisify as promisify4 } from "util";
-var execFileAsync = promisify4(execFile4);
+import { promisify as promisify6 } from "util";
+var execFileAsync = promisify6(execFile6);
 var NO_TEAM = {
   isTeam: false,
   contributors: 1,
@@ -23575,7 +23985,7 @@ async function anyPathExists(projectRoot, candidates) {
   const results = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access2(path42.join(projectRoot, candidate));
+        await access2(path44.join(projectRoot, candidate));
         return true;
       } catch {
         return false;
@@ -23597,10 +24007,10 @@ function emptySignals(isGitRepository) {
 }
 
 // src/system/detect.ts
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import process3 from "process";
-import { promisify as promisify5 } from "util";
-var execFileAsync2 = promisify5(execFile5);
+import { promisify as promisify7 } from "util";
+var execFileAsync2 = promisify7(execFile7);
 async function detectSystemDeps(env = process3.env) {
   try {
     await execFileAsync2("git", ["--version"], {
@@ -23616,7 +24026,7 @@ async function detectSystemDeps(env = process3.env) {
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
 import { promises as fs2 } from "fs";
-import path43 from "path";
+import path45 from "path";
 import process4 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -23721,7 +24131,7 @@ async function detectPlatformHints(rootDir, environment = process4.env) {
     hints.add("copilot");
   const exists = async (relative) => {
     try {
-      await fs2.access(path43.join(rootDir, relative));
+      await fs2.access(path45.join(rootDir, relative));
       return true;
     } catch {
       return false;
@@ -23797,7 +24207,7 @@ function createTerminalPrompter() {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs3 } from "fs";
-import path44 from "path";
+import path46 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null) {
@@ -23833,7 +24243,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists5(path44.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists5(path46.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -23858,7 +24268,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path44.join(projectRoot, name);
+    const absPath = path46.join(projectRoot, name);
     if (await pathExists5(absPath)) {
       return { absPath, relPath: name };
     }
@@ -24085,7 +24495,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path44.join(projectRoot, relRoot);
+    const absRoot = path46.join(projectRoot, relRoot);
     if (!await pathExists5(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -24105,7 +24515,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path44.join(dir, entry);
+    const abs = path46.join(dir, entry);
     let info;
     try {
       info = await fs3.lstat(abs);
@@ -24126,7 +24536,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path44.basename(dir);
+      base = path46.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -24148,7 +24558,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path44.join(projectRoot, relPath);
+    const absPath = path46.join(projectRoot, relPath);
     if (!await pathExists5(absPath)) continue;
     const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -24194,7 +24604,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs3.readFile(
-      path44.join(projectRoot, "package.json"),
+      path46.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -24219,15 +24629,15 @@ async function pathExists5(p) {
 
 // src/context/greenfield-init.ts
 import {
-  lstat as lstat16,
-  mkdir as mkdir30,
-  readFile as readFile33,
+  lstat as lstat18,
+  mkdir as mkdir32,
+  readFile as readFile35,
   rename as rename8,
   rm as rm16,
-  writeFile as writeFile35
+  writeFile as writeFile37
 } from "fs/promises";
-import path45 from "path";
-var JOURNAL_RELATIVE_DIRECTORY = path45.join(
+import path47 from "path";
+var JOURNAL_RELATIVE_DIRECTORY = path47.join(
   "local",
   "runtime",
   "initialization"
@@ -24250,9 +24660,9 @@ async function stageGreenfieldInitialization(input) {
     normalized.operationId
   );
   try {
-    await mkdir30(stagingRoot);
+    await mkdir32(stagingRoot);
   } catch (error) {
-    if (isAlreadyExists20(error)) {
+    if (isAlreadyExists22(error)) {
       throw new Error("MANCODE_GREENFIELD_STAGING_EXISTS");
     }
     throw error;
@@ -24271,7 +24681,7 @@ async function stageGreenfieldInitialization(input) {
     operationId: normalized.operationId,
     workspaceId: normalized.workspaceId,
     state: "staged",
-    stagingDirectoryName: path45.basename(stagingRoot),
+    stagingDirectoryName: path47.basename(stagingRoot),
     targetDirectoryName: ".mancode",
     manifestDigest: digestCanonicalJson(manifest),
     configDigest: digestCanonicalJson(config),
@@ -24301,7 +24711,7 @@ async function stageGreenfieldInitialization(input) {
   return journal;
 }
 async function publishGreenfieldInitialization(input) {
-  const root = path45.resolve(input.projectRoot);
+  const root = path47.resolve(input.projectRoot);
   assertUlid(input.operationId, "greenfield operationId");
   const stagingRoot = greenfieldStagingPath(root, input.operationId);
   const targetRoot = greenfieldTargetPath(root);
@@ -24330,10 +24740,10 @@ async function initializeGreenfield(input, publication) {
 }
 function greenfieldStagingPath(projectRoot, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path45.join(path45.resolve(projectRoot), `.mancode.init-${operationId}`);
+  return path47.join(path47.resolve(projectRoot), `.mancode.init-${operationId}`);
 }
 function greenfieldTargetPath(projectRoot) {
-  return path45.join(path45.resolve(projectRoot), ".mancode");
+  return path47.join(path47.resolve(projectRoot), ".mancode");
 }
 function parseGreenfieldInitializationJournal(value) {
   assertRecord(value, "greenfield initialization journal");
@@ -24436,7 +24846,7 @@ async function finishPublishedInitialization(input, stagedJournal) {
     activatedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
   };
   assertSchemaManifestTransition(manifest, activeManifest);
-  await writeJson(path45.join(targetRoot, "schema.json"), activeManifest);
+  await writeJson(path47.join(targetRoot, "schema.json"), activeManifest);
   throwIfOperationCrashInjected(
     "greenfield_initialize",
     "activate-v3-manifest"
@@ -24452,46 +24862,46 @@ async function finishPublishedInitialization(input, stagedJournal) {
 }
 async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, projectFacts, journal) {
   await Promise.all([
-    mkdir30(path45.join(stagingRoot, "shared", "context"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "shared", "memory", "decisions"), {
+    mkdir32(path47.join(stagingRoot, "shared", "context"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "shared", "memory", "decisions"), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "shared", "team", "actors"), {
+    mkdir32(path47.join(stagingRoot, "shared", "team", "actors"), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "shared", "team", "handoffs"), {
+    mkdir32(path47.join(stagingRoot, "shared", "team", "handoffs"), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "shared", "team", "events"), {
+    mkdir32(path47.join(stagingRoot, "shared", "team", "events"), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "shared", "team", "transport"), {
+    mkdir32(path47.join(stagingRoot, "shared", "team", "transport"), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "local", "sessions"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
+    mkdir32(path47.join(stagingRoot, "local", "sessions"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
       recursive: true
     }),
-    mkdir30(path45.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "local", "overlays"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "local", "quarantine"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "local", "publish"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "local", "cache"), { recursive: true }),
-    mkdir30(path45.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
+    mkdir32(path47.join(stagingRoot, "local", "workflows"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "local", "overlays"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "local", "quarantine"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "local", "publish"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "local", "cache"), { recursive: true }),
+    mkdir32(path47.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
       recursive: true
     })
   ]);
   await Promise.all([
-    writeJson(path45.join(stagingRoot, "schema.json"), manifest),
-    writeJson(path45.join(stagingRoot, "shared", "config.json"), config),
-    writeJson(path45.join(stagingRoot, "shared", "team", "policy.json"), policy),
+    writeJson(path47.join(stagingRoot, "schema.json"), manifest),
+    writeJson(path47.join(stagingRoot, "shared", "config.json"), config),
+    writeJson(path47.join(stagingRoot, "shared", "team", "policy.json"), policy),
     writeJson(
-      path45.join(stagingRoot, "shared", "context", "project.json"),
+      path47.join(stagingRoot, "shared", "context", "project.json"),
       projectFacts
     ),
     writeJson(journalPath2(stagingRoot, journal.operationId), journal),
-    writeFile35(
-      path45.join(stagingRoot, ".gitignore"),
+    writeFile37(
+      path47.join(stagingRoot, ".gitignore"),
       `${V3_IGNORE.join("\n")}
 `,
       { encoding: "utf8", flag: "wx" }
@@ -24500,14 +24910,14 @@ async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, proj
 }
 async function readGreenfieldJournal(root, operationId) {
   try {
-    const raw = await readFile33(journalPath2(root, operationId), "utf8");
+    const raw = await readFile35(journalPath2(root, operationId), "utf8");
     const journal = parseGreenfieldInitializationJournal(JSON.parse(raw));
     if (journal.operationId !== operationId) {
       throw new Error("MANCODE_GREENFIELD_JOURNAL_CORRUPT");
     }
     return journal;
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound24(error)) {
+    if (error instanceof SyntaxError || isNotFound26(error)) {
       throw new Error("MANCODE_GREENFIELD_JOURNAL_CORRUPT");
     }
     throw error;
@@ -24516,10 +24926,10 @@ async function readGreenfieldJournal(root, operationId) {
 async function readManifest(root) {
   try {
     return parseSchemaManifest(
-      JSON.parse(await readFile33(path45.join(root, "schema.json"), "utf8"))
+      JSON.parse(await readFile35(path47.join(root, "schema.json"), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound24(error)) {
+    if (error instanceof SyntaxError || isNotFound26(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -24554,7 +24964,7 @@ async function readConfig(root) {
   try {
     config = parseProjectConfig(
       JSON.parse(
-        await readFile33(path45.join(root, "shared", "config.json"), "utf8")
+        await readFile35(path47.join(root, "shared", "config.json"), "utf8")
       )
     );
   } catch (error) {
@@ -24570,8 +24980,8 @@ async function readPolicy(root) {
   try {
     policy = parseTeamPolicy(
       JSON.parse(
-        await readFile33(
-          path45.join(root, "shared", "team", "policy.json"),
+        await readFile35(
+          path47.join(root, "shared", "team", "policy.json"),
           "utf8"
         )
       )
@@ -24588,14 +24998,14 @@ async function readProjectFactsAt(root) {
   try {
     return parseProjectFacts(
       JSON.parse(
-        await readFile33(
-          path45.join(root, "shared", "context", "project.json"),
+        await readFile35(
+          path47.join(root, "shared", "context", "project.json"),
           "utf8"
         )
       )
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound24(error)) {
+    if (error instanceof SyntaxError || isNotFound26(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -24628,7 +25038,7 @@ function normalizeInput(input) {
   parseSchemaManifest(manifest);
   return {
     ...input,
-    projectRoot: path45.resolve(input.projectRoot),
+    projectRoot: path47.resolve(input.projectRoot),
     projectConfig: config,
     teamPolicy: policy,
     projectFacts: input.projectFacts === void 0 ? void 0 : parseProjectFacts(input.projectFacts)
@@ -24677,16 +25087,16 @@ function initializationProjectFacts(input, now) {
 }
 function journalPath2(root, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path45.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
+  return path47.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
 }
 async function writeJson(target, value) {
-  const directory = path45.dirname(target);
-  await mkdir30(directory, { recursive: true });
-  const temporary = path45.join(
+  const directory = path47.dirname(target);
+  await mkdir32(directory, { recursive: true });
+  const temporary = path47.join(
     directory,
-    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
+    `.${path47.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile35(temporary, `${JSON.stringify(value, null, 2)}
+  await writeFile37(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -24710,16 +25120,16 @@ function isState(value) {
 }
 async function lstatOrNull4(target) {
   try {
-    return await lstat16(target);
+    return await lstat18(target);
   } catch (error) {
-    if (isNotFound24(error)) return null;
+    if (isNotFound26(error)) return null;
     throw error;
   }
 }
-function isNotFound24(error) {
+function isNotFound26(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function isAlreadyExists20(error) {
+function isAlreadyExists22(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
 
@@ -24813,9 +25223,9 @@ async function init(rootDir = process5.cwd(), options = {}) {
     return EXIT_INIT_FAILED;
   }
   const authority = resolveInitAuthority(options);
-  const mancodeDir = path46.join(rootDir, ".mancode");
-  const stateFile = path46.join(mancodeDir, "state.json");
-  const v3SchemaFile = path46.join(mancodeDir, "schema.json");
+  const mancodeDir = path48.join(rootDir, ".mancode");
+  const stateFile = path48.join(mancodeDir, "state.json");
+  const v3SchemaFile = path48.join(mancodeDir, "schema.json");
   const wasInitialized = await pathExists6(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
@@ -24883,7 +25293,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
     }
     return initializeV3(rootDir, options);
   }
-  const isGitRepo = await pathExists6(path46.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path48.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   let isGenericProject = false;
   if (!isGitRepo && !hasManifest) {
@@ -25001,8 +25411,8 @@ async function init(rootDir = process5.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path46.join(mancodeDir, "workflows"),
-      path46.join(mancodeDir, "preseason-reports")
+      path48.join(mancodeDir, "workflows"),
+      path48.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
     const platformMinimal = Object.fromEntries(
@@ -25063,7 +25473,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
 `;
     await fs4.writeFile(stateFile, stateContent, "utf-8");
     await fs4.writeFile(
-      path46.join(mancodeDir, "project-profile.json"),
+      path48.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -25100,7 +25510,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path46.join(
+      const tokensPath = path48.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -25264,7 +25674,7 @@ async function initializeV3(rootDir, options) {
     );
     return EXIT_INIT_FAILED;
   }
-  const schemaPath = path46.join(rootDir, ".mancode", "schema.json");
+  const schemaPath = path48.join(rootDir, ".mancode", "schema.json");
   let existingV3 = false;
   if (await pathExists6(schemaPath)) {
     try {
@@ -25356,7 +25766,7 @@ function printV3InitError(error) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path46.join(mancodeDir, "config.json");
+  const configPath = path48.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
@@ -25389,7 +25799,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs4.readFile(path46.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path48.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {
       platforms: Array.isArray(config.platforms) ? config.platforms.filter(
@@ -25455,13 +25865,13 @@ async function selectInitPlatforms(input) {
 }
 async function hasProjectManifest(rootDir) {
   for (const name of PROJECT_MANIFESTS) {
-    if (await pathExists6(path46.join(rootDir, name))) return true;
+    if (await pathExists6(path48.join(rootDir, name))) return true;
   }
   return false;
 }
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path46.resolve(rootDir);
-  if (resolved === path46.parse(resolved).root || resolved === path46.resolve(os.homedir())) {
+  const resolved = path48.resolve(rootDir);
+  if (resolved === path48.parse(resolved).root || resolved === path48.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
@@ -25475,11 +25885,11 @@ async function canInitializeGenericProject(rootDir) {
   }
 }
 async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInitialized) {
-  const isGitRepo = await pathExists6(path46.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path48.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   if (isGitRepo || hasManifest) return null;
   const v3Initialized = await pathExists6(
-    path46.join(rootDir, ".mancode", "schema.json")
+    path48.join(rootDir, ".mancode", "schema.json")
   );
   const legacyAuthorityPresent = legacyInitialized || (await scanLegacyAuthority(rootDir)).authorityPresent;
   const genericSafety = await canInitializeGenericProject(rootDir);
@@ -25608,7 +26018,7 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path46.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path48.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
@@ -25627,10 +26037,10 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path46.dirname(filePath);
-    while (current !== path46.dirname(current)) {
+    let current = path48.dirname(filePath);
+    while (current !== path48.dirname(current)) {
       directories.add(current);
-      current = path46.dirname(current);
+      current = path48.dirname(current);
     }
   }
   return Promise.all(
@@ -25646,7 +26056,7 @@ async function restoreFiles(snapshots) {
       await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs4.mkdir(path46.dirname(snapshot.filePath), { recursive: true });
+    await fs4.mkdir(path48.dirname(snapshot.filePath), { recursive: true });
     await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
@@ -25713,15 +26123,15 @@ async function pathExists6(p) {
 
 // src/commands/install.ts
 import { promises as fs5 } from "fs";
-import path47 from "path";
+import path49 from "path";
 import process6 from "process";
 var EXIT_OK2 = 0;
 var EXIT_NOT_INITIALIZED = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
 async function install(rootDir = process6.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path47.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path47.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path49.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path49.join(rootDir, ".mancode", "schema.json");
   if (await pathExists7(v3SchemaFile)) {
     return installV3(rootDir, platform, options);
   }
@@ -25864,7 +26274,7 @@ function printUnsupportedPlatform(platform) {
   }
 }
 async function readConfig2(rootDir) {
-  const configPath = path47.join(rootDir, ".mancode", "config.json");
+  const configPath = path49.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
@@ -25879,7 +26289,7 @@ function isNodeError7(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path47.join(rootDir, ".mancode", "config.json");
+  const configPath = path49.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs5.writeFile(configPath, content, "utf-8");
@@ -25915,7 +26325,7 @@ function readConfiguredMinimal(value, platform) {
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path47.join(rootDir, ".mancode", "state.json"),
+      path49.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -25938,11 +26348,11 @@ function isRecord8(value) {
 
 // src/commands/list-platforms.ts
 import { promises as fs6 } from "fs";
-import path48 from "path";
+import path50 from "path";
 import process7 from "process";
 var EXIT_OK3 = 0;
 async function listPlatforms(rootDir = process7.cwd()) {
-  if (await pathExists8(path48.join(rootDir, ".mancode", "schema.json"))) {
+  if (await pathExists8(path50.join(rootDir, ".mancode", "schema.json"))) {
     return listV3Platforms(rootDir);
   }
   const installed = new Set(await readInstalledPlatforms(rootDir));
@@ -25978,7 +26388,7 @@ async function listV3Platforms(rootDir) {
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path48.join(rootDir, ".mancode", "config.json"),
+      path50.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -26010,24 +26420,24 @@ function describePlatform(platform) {
 }
 
 // src/commands/manps.ts
-import { access as access4, readFile as readFile35 } from "fs/promises";
-import path50 from "path";
+import { access as access4, readFile as readFile37 } from "fs/promises";
+import path52 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { createHash as createHash8 } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   access as access3,
-  lstat as lstat17,
-  mkdir as mkdir31,
-  readFile as readFile34,
-  readdir as readdir16,
+  lstat as lstat19,
+  mkdir as mkdir33,
+  readFile as readFile36,
+  readdir as readdir17,
   rename as rename9,
-  writeFile as writeFile36
+  writeFile as writeFile38
 } from "fs/promises";
-import path49 from "path";
+import path51 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -26107,10 +26517,10 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   const needsFiles = normalizedArea === "all" || normalizedArea === "dead-code" || normalizedArea === "config";
   const files = needsFiles ? await listProjectFiles(projectRoot) : [];
   const issues = (await scanArea(projectRoot, normalizedArea, pkg, files)).slice(0, 20);
-  const storageRoot = options.storageRoot ?? path49.join(projectRoot, ".mancode");
-  const reportDir = path49.join(storageRoot, "preseason-reports");
-  await mkdir31(reportDir, { recursive: true });
-  const issueDbPath = path49.join(storageRoot, "preseason-issues.json");
+  const storageRoot = options.storageRoot ?? path51.join(projectRoot, ".mancode");
+  const reportDir = path51.join(storageRoot, "preseason-reports");
+  await mkdir33(reportDir, { recursive: true });
+  const issueDbPath = path51.join(storageRoot, "preseason-issues.json");
   const reportPath = await allocateReportPath(
     reportDir,
     `${generatedAt.replace(/[:.]/g, "-")}-${normalizedArea}`
@@ -26124,9 +26534,9 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
     issueDbPath
   };
   const database = await buildIssueDatabase(projectRoot, report);
-  await writeFile36(reportPath, renderPreseasonReport(report), "utf-8");
-  await writeFile36(
-    path49.join(storageRoot, "preseason-report.md"),
+  await writeFile38(reportPath, renderPreseasonReport(report), "utf-8");
+  await writeFile38(
+    path51.join(storageRoot, "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -26134,7 +26544,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = options.issueDbPath ?? path49.join(projectRoot, ".mancode", "preseason-issues.json");
+  const issueDbPath = options.issueDbPath ?? path51.join(projectRoot, ".mancode", "preseason-issues.json");
   const database = await readIssueDatabase(issueDbPath);
   const keys = new Set(issues.map((issue) => issueKey(issue)));
   const targets = database.issues.filter(
@@ -26212,7 +26622,7 @@ async function runPreseasonRemediation(projectRoot, issues, options = {}) {
     write2("   Decision: skipped.");
   }
   database.updatedAt = now;
-  await writeFile36(
+  await writeFile38(
     issueDbPath,
     `${JSON.stringify(database, null, 2)}
 `,
@@ -26244,7 +26654,7 @@ async function scanArea(projectRoot, area, pkg, files) {
 async function allocateReportPath(reportDir, baseName) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
-    const candidate = path49.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path51.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -26287,24 +26697,24 @@ async function walk(root, current, results, depth) {
   if (depth > MAX_SCAN_DEPTH || results.length >= MAX_PROJECT_FILES) return;
   let entries;
   try {
-    entries = await readdir16(current);
+    entries = await readdir17(current);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path49.join(current, entry);
-    const rel = path49.relative(root, abs);
+    const abs = path51.join(current, entry);
+    const rel = path51.relative(root, abs);
     let info;
     try {
-      info = await lstat17(abs);
+      info = await lstat19(abs);
     } catch {
       continue;
     }
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path49.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path51.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -26312,7 +26722,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile34(path49.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile36(path51.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -26405,7 +26815,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path49.join(projectRoot, file);
+    const abs = path51.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -26446,7 +26856,7 @@ function scanTestGaps(files) {
   if (sourceFiles.length === 0) return [];
   const tests = new Set(files.filter((file) => file.startsWith("tests/")));
   const missing = sourceFiles.filter((file) => {
-    const base = path49.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path51.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -26455,13 +26865,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path49.basename(file)}.`,
+    detail: `No matching test file was found for ${path51.basename(file)}.`,
     recommendation: "Add focused coverage for the public behavior or document why this module is exercised indirectly."
   }));
 }
 function scanConfig(projectRoot, files) {
   const issues = [];
-  if (!files.includes(".gitignore") && !pathExistsSync(path49.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path51.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -26472,7 +26882,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path49.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path51.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -26491,7 +26901,7 @@ function scanAestheticDrift(projectRoot, files) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path49.join(projectRoot, file));
+      content = readFileSyncSafe(path51.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -26511,7 +26921,7 @@ function scanAestheticDrift(projectRoot, files) {
   return issues;
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path49.join(
+  const localBinary = path51.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -26559,7 +26969,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists9(path49.join(projectRoot, file)))
+    files.map((file) => pathExists9(path51.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -26576,7 +26986,7 @@ function architectureScannerUnavailableIssue() {
 function runDepcruise(binary, projectRoot) {
   return new Promise((resolve) => {
     const needsShell = process.platform === "win32";
-    execFile6(
+    execFile8(
       binary,
       ["--output-type", "json", "."],
       {
@@ -26665,9 +27075,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path49.relative(projectRoot, report.reportPath);
+  const reportRef = path51.relative(projectRoot, report.reportPath);
   const run = {
-    id: path49.basename(report.reportPath, ".md"),
+    id: path51.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -26709,7 +27119,7 @@ async function buildIssueDatabase(projectRoot, report) {
 async function readIssueDatabase(issueDbPath) {
   let raw;
   try {
-    raw = await readFile34(issueDbPath, "utf-8");
+    raw = await readFile36(issueDbPath, "utf-8");
   } catch (err) {
     if (isNodeError8(err) && err.code === "ENOENT") {
       return emptyIssueDatabase();
@@ -26730,7 +27140,7 @@ async function readIssueDatabase(issueDbPath) {
 }
 async function writeJsonAtomic3(file, value) {
   const tmp = `${file}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await writeFile36(tmp, `${JSON.stringify(value, null, 2)}
+  await writeFile38(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
   await rename9(tmp, file);
 }
@@ -26773,20 +27183,20 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path49.join(projectRoot, ".gitignore");
+    const gitignorePath = path51.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
-    await writeFile36(gitignorePath, `${DEFAULT_GITIGNORE}
+    await writeFile38(gitignorePath, `${DEFAULT_GITIGNORE}
 `, "utf-8");
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path49.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path51.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
-    await writeFile36(editorconfigPath, `${DEFAULT_EDITORCONFIG}
+    await writeFile38(editorconfigPath, `${DEFAULT_EDITORCONFIG}
 `, "utf-8");
     return { applied: true, action: "created .editorconfig" };
   }
@@ -26822,10 +27232,10 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path49.join(projectRoot, "package.json");
+  const packagePath = path51.join(projectRoot, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile34(packagePath, "utf-8"));
+    pkg = JSON.parse(await readFile36(packagePath, "utf-8"));
   } catch {
     return false;
   }
@@ -26835,7 +27245,7 @@ async function addPackageScript(projectRoot, scriptName, script) {
     ...scripts,
     [scriptName]: script
   };
-  await writeFile36(packagePath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile38(packagePath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
   return true;
 }
@@ -26935,7 +27345,7 @@ var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  const v3SchemaPath = path50.join(rootDir, ".mancode", "schema.json");
+  const v3SchemaPath = path52.join(rootDir, ".mancode", "schema.json");
   const v3Activation = await readV3ActivationState(v3SchemaPath);
   if (v3Activation !== null && v3Activation !== "v3_active" && v3Activation !== "dual_read") {
     const message = `manps is unavailable while mancode activation is ${v3Activation}`;
@@ -26948,7 +27358,7 @@ async function manps(rootDir, area = "all", options = {}) {
     return EXIT_SCAN_FAILED;
   }
   const v3Initialized = v3Activation === "v3_active";
-  const initialized = v3Initialized || await pathExists10(path50.join(rootDir, ".mancode", "state.json"));
+  const initialized = v3Initialized || await pathExists10(path52.join(rootDir, ".mancode", "state.json"));
   if (!initialized) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
@@ -26961,7 +27371,7 @@ async function manps(rootDir, area = "all", options = {}) {
   let report;
   try {
     report = await runPreseasonScan(rootDir, area, {
-      storageRoot: v3Initialized ? path50.join(rootDir, ".mancode", "local") : void 0
+      storageRoot: v3Initialized ? path52.join(rootDir, ".mancode", "local") : void 0
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -27030,8 +27440,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path50.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path50.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path52.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path52.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -27047,7 +27457,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path50.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path52.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK4;
@@ -27108,7 +27518,7 @@ async function readV3ActivationState(schemaPath) {
   if (!await pathExists10(schemaPath)) return null;
   try {
     const manifest = parseSchemaManifest(
-      JSON.parse(await readFile35(schemaPath, "utf8"))
+      JSON.parse(await readFile37(schemaPath, "utf8"))
     );
     return manifest.activationState;
   } catch {
@@ -27117,8 +27527,8 @@ async function readV3ActivationState(schemaPath) {
 }
 
 // src/commands/migrate.ts
-import { readFile as readFile36 } from "fs/promises";
-import path51 from "path";
+import { readFile as readFile38 } from "fs/promises";
+import path53 from "path";
 var EXIT_OK5 = 0;
 var EXIT_INVALID_ARG2 = 2;
 var EXIT_MIGRATION_BLOCKED = 3;
@@ -27244,14 +27654,14 @@ async function readScopeFile(rootDir, file) {
   if (!file.trim() || file.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
-  const resolved = path51.resolve(rootDir, file);
-  const relative = path51.relative(path51.resolve(rootDir), resolved);
-  if (relative === ".." || relative.startsWith(`..${path51.sep}`) || path51.isAbsolute(relative)) {
+  const resolved = path53.resolve(rootDir, file);
+  const relative = path53.relative(path53.resolve(rootDir), resolved);
+  if (relative === ".." || relative.startsWith(`..${path53.sep}`) || path53.isAbsolute(relative)) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
   try {
     return JSON.parse(
-      await readFile36(resolved, "utf8")
+      await readFile38(resolved, "utf8")
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -27353,16 +27763,16 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
 // src/commands/refresh-project.ts
 import { randomUUID } from "crypto";
 import { promises as fs7 } from "fs";
-import path52 from "path";
+import path54 from "path";
 import process8 from "process";
 var EXIT_OK6 = 0;
 var EXIT_NOT_INITIALIZED3 = 1;
 var EXIT_CORRUPT_STATE = 2;
 var EXIT_REFRESH_FAILED = 3;
 async function refreshProject(rootDir = process8.cwd()) {
-  const mancodeDir = path52.join(rootDir, ".mancode");
-  const statePath = path52.join(mancodeDir, "state.json");
-  if (await pathExists11(path52.join(mancodeDir, "schema.json"))) {
+  const mancodeDir = path54.join(rootDir, ".mancode");
+  const statePath = path54.join(mancodeDir, "state.json");
+  if (await pathExists11(path54.join(mancodeDir, "schema.json"))) {
     return refreshV3Project(rootDir);
   }
   if (!await pathExists11(statePath)) {
@@ -27381,12 +27791,12 @@ async function refreshProject(rootDir = process8.cwd()) {
     const [profile, team, hasGit, hasManifest] = await Promise.all([
       detectProjectProfile(rootDir),
       detectTeamStatus(rootDir),
-      pathExists11(path52.join(rootDir, ".git")),
+      pathExists11(path54.join(rootDir, ".git")),
       hasProjectManifest2(rootDir)
     ]);
     const uiLibrary = primaryUiLibrary(profile);
     const stack = [...profile.languages, ...profile.frameworks];
-    const config = await readJson2(path52.join(mancodeDir, "config.json"));
+    const config = await readJson2(path54.join(mancodeDir, "config.json"));
     const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
     const nextState = {
       ...state,
@@ -27398,7 +27808,7 @@ async function refreshProject(rootDir = process8.cwd()) {
     };
     await writeProjectFacts2(
       statePath,
-      path52.join(mancodeDir, "project-profile.json"),
+      path54.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(nextState, null, 2)}
 `,
       `${JSON.stringify(profile, null, 2)}
@@ -27465,7 +27875,7 @@ async function refreshV3Project(rootDir) {
 }
 async function hasProjectManifest2(rootDir) {
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists11(path52.join(rootDir, manifest))) return true;
+    if (await pathExists11(path54.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -27531,9 +27941,9 @@ async function readOptionalText(filePath) {
   }
 }
 function temporaryPath(filePath) {
-  return path52.join(
-    path52.dirname(filePath),
-    `.${path52.basename(filePath)}.${process8.pid}.${randomUUID()}.tmp`
+  return path54.join(
+    path54.dirname(filePath),
+    `.${path54.basename(filePath)}.${process8.pid}.${randomUUID()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -27603,14 +28013,14 @@ async function pathExists11(filePath) {
 
 // src/commands/refresh-style.ts
 import { promises as fs8 } from "fs";
-import path53 from "path";
+import path55 from "path";
 import process9 from "process";
 var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED4 = 1;
 var EXIT_V3_REFRESH_FAILED = 2;
 async function refreshStyle(rootDir = process9.cwd()) {
-  const stateFile = path53.join(rootDir, ".mancode", "state.json");
-  if (await pathExists12(path53.join(rootDir, ".mancode", "schema.json"))) {
+  const stateFile = path55.join(rootDir, ".mancode", "state.json");
+  if (await pathExists12(path55.join(rootDir, ".mancode", "schema.json"))) {
     return refreshV3Style(rootDir);
   }
   if (!await pathExists12(stateFile)) {
@@ -27620,7 +28030,7 @@ async function refreshStyle(rootDir = process9.cwd()) {
   }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path53.join(rootDir, ".mancode", "project-profile.json");
+  const profilePath = path55.join(rootDir, ".mancode", "project-profile.json");
   await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
@@ -27642,13 +28052,13 @@ async function refreshStyle(rootDir = process9.cwd()) {
   }
   console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
   const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-  const tokensPath = path53.join(
+  const tokensPath = path55.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs8.mkdir(path53.dirname(tokensPath), { recursive: true });
+  await fs8.mkdir(path55.dirname(tokensPath), { recursive: true });
   await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -27720,7 +28130,7 @@ async function refreshV3Style(rootDir) {
     console.log(
       `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
     );
-    const tokensPath = path53.join(
+    const tokensPath = path55.join(
       rootDir,
       ".mancode",
       "local",
@@ -27737,7 +28147,7 @@ async function refreshV3Style(rootDir) {
     }
     console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
     const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-    await fs8.mkdir(path53.dirname(tokensPath), { recursive: true });
+    await fs8.mkdir(path55.dirname(tokensPath), { recursive: true });
     await fs8.writeFile(
       tokensPath,
       `${JSON.stringify(tokens, null, 2)}
@@ -27771,7 +28181,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path53.join(rootDir, ".mancode", "state.json");
+  const statePath = path55.join(rootDir, ".mancode", "state.json");
   try {
     const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
@@ -27795,7 +28205,7 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs8.readFile(
-      path53.join(rootDir, ".mancode", "config.json"),
+      path55.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -27818,7 +28228,7 @@ async function pathExists12(p) {
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs9 } from "fs";
-import path54 from "path";
+import path56 from "path";
 import process10 from "process";
 
 // src/team/assessment.ts
@@ -27974,8 +28384,8 @@ var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
 async function status(rootDir = process10.cwd(), options = {}) {
-  const stateFile = path54.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path54.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path56.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path56.join(rootDir, ".mancode", "schema.json");
   if (await pathExists13(v3SchemaFile)) {
     return statusV3(rootDir, options);
   }
@@ -28207,10 +28617,10 @@ async function readV3StatusSession(rootDir) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists13(path54.join(rootDir, ".git"));
+  const hasGit = await pathExists13(path56.join(rootDir, ".git"));
   if (hasGit) return true;
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists13(path54.join(rootDir, manifest))) return true;
+    if (await pathExists13(path56.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -28254,19 +28664,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs9.readFile(path54.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path56.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path54.basename(rootDir);
+  return path56.basename(rootDir);
 }
 async function readConfig3(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path54.join(rootDir, ".mancode", "config.json"),
+      path56.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -28294,9 +28704,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists13(path54.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists13(path56.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists13(
-      path54.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path56.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -28305,7 +28715,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path54.join(rootDir, ".claude", "settings.json"),
+      path56.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -28334,7 +28744,7 @@ function hasHookCommand2(value, needle) {
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path54.join(
+  const hookPath = path56.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -29825,162 +30235,24 @@ function assertPositiveRevision2(value, label) {
   }
 }
 
-// src/team/git-ref-bundle.ts
-import { execFile as execFileCallback4 } from "child_process";
-import { lstat as lstat18, mkdir as mkdir32, writeFile as writeFile37 } from "fs/promises";
-import path55 from "path";
-import { promisify as promisify6 } from "util";
-var execFile7 = promisify6(execFileCallback4);
-function createGitRefTaskBundle(input) {
-  const { task } = input;
-  if (task.metadata.taskRef.namespace !== "shared") {
-    throw new Error("MANCODE_REMOTE_COORDINATION_REQUIRES_SHARED_TASK");
-  }
-  if (task.aggregate === null) {
-    throw new Error("MANCODE_TASK_UNAVAILABLE");
-  }
-  const artifacts = [
-    artifact("metadata", "metadata.json", task.metadata),
-    artifact("requirements", "requirements.json", task.requirements),
-    artifact("review", "review-ledger.json", task.review),
-    artifact("verification", "verification-ledger.json", task.verification)
-  ];
-  if (task.latestCheckpoint !== null) {
-    artifacts.push(
-      artifact(
-        "checkpoint",
-        `checkpoints/${task.latestCheckpoint.checkpointId}.json`,
-        task.latestCheckpoint
-      )
-    );
-  }
-  if (task.plan !== null) {
-    artifacts.push(artifact("plan", "plan.md", task.plan.content));
-  } else {
-    artifacts.push(
-      artifact(
-        "summary",
-        "summary.md",
-        task.latestCheckpoint?.summary ?? `Task ${formatTaskRef(task.metadata.taskRef)} revision ${task.metadata.revision}.`
-      )
-    );
-  }
-  artifacts.sort(
-    (left, right) => left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0
-  );
-  const body = {
-    schemaVersion: 1,
-    taskRef: task.metadata.taskRef,
-    taskRevision: task.metadata.revision,
-    ownershipEpoch: task.metadata.ownershipEpoch,
-    aggregate: task.aggregate,
-    aggregateDigest: digestCanonicalJson(task.aggregate),
-    codeRef: parseCodeRef(input.codeRef),
-    artifacts,
-    createdAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
-  };
-  return parseGitRefTaskBundle({
-    ...body,
-    bundleDigest: gitRefTaskBundleDigest(body)
-  });
-}
-async function assertGitRefBundleCodeReachable(projectRoot, bundle) {
-  const parsed = parseGitRefTaskBundle(bundle);
-  try {
-    await execFile7(
-      "git",
-      ["cat-file", "-e", `${parsed.codeRef.head}^{commit}`],
-      {
-        cwd: path55.resolve(projectRoot),
-        windowsHide: true
-      }
-    );
-  } catch {
-    throw new Error("MANCODE_TASK_BUNDLE_CODE_UNREACHABLE");
-  }
-}
-async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
-  if (!Number.isSafeInteger(remoteRevision) || remoteRevision < 1) {
-    throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
-  }
-  const parsed = parseGitRefTaskBundle(bundle);
-  const directory = path55.join(
-    path55.resolve(projectRoot),
-    ".mancode",
-    "local",
-    "quarantine",
-    "git-ref",
-    parsed.taskRef.taskId,
-    String(remoteRevision)
-  );
-  await ensureFixedDirectory(projectRoot, [
-    ".mancode",
-    "local",
-    "quarantine",
-    "git-ref",
-    parsed.taskRef.taskId,
-    String(remoteRevision)
-  ]);
-  const target = path55.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
-  try {
-    await writeFile37(target, `${JSON.stringify(parsed, null, 2)}
-`, {
-      encoding: "utf8",
-      flag: "wx"
-    });
-  } catch (error) {
-    if (!isAlreadyExists21(error)) throw error;
-  }
-  return target;
-}
-function artifact(kind, relativePath, value) {
-  const content = JSON.parse(JSON.stringify(value));
-  return {
-    kind,
-    relativePath,
-    content,
-    contentDigest: digestCanonicalJson(content)
-  };
-}
-function parseCodeRef(value) {
-  if (typeof value.branch !== "string" || !value.branch.trim() || value.branch.includes("\0") || typeof value.head !== "string" || !/^[0-9a-f]{40,64}$/.test(value.head)) {
-    throw new Error("MANCODE_TASK_BUNDLE_CODE_REF_INVALID");
-  }
-  return { branch: value.branch, head: value.head };
-}
-async function ensureFixedDirectory(projectRoot, segments) {
-  let current = path55.resolve(projectRoot);
-  for (const segment of segments) {
-    current = path55.join(current, segment);
-    try {
-      await mkdir32(current);
-    } catch (error) {
-      if (!isAlreadyExists21(error)) throw error;
-    }
-    const entry = await lstat18(current);
-    if (!entry.isDirectory() || entry.isSymbolicLink()) {
-      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
-    }
-  }
-}
-function isAlreadyExists21(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-}
-
 // src/team/git-ref-handoff-repair.ts
-import { lstat as lstat19, mkdir as mkdir33, readFile as readFile37, readdir as readdir17, writeFile as writeFile38 } from "fs/promises";
-import path56 from "path";
+import { lstat as lstat20, mkdir as mkdir34, readFile as readFile39, readdir as readdir18, writeFile as writeFile39 } from "fs/promises";
+import path57 from "path";
 
 // src/team/git-ref-operation.ts
-import { execFile as execFileCallback5 } from "child_process";
-import { promisify as promisify7 } from "util";
+import { execFile as execFileCallback6 } from "child_process";
+import { promisify as promisify8 } from "util";
 
 // src/team/git-ref-coordination.ts
 function prepareGitRefCoordinationMutation(manifest, input) {
   const context = openMutationContext(manifest, input);
   switch (input.kind) {
     case "ownership_fence":
-      return prepareOwnershipFence(context, input.taskBundle);
+      return prepareOwnershipFence(
+        context,
+        input.taskBundle,
+        input.expectedPredecessorBundleDigest
+      );
     case "claim_acquire":
       return prepareClaimAcquire(
         context,
@@ -30099,13 +30371,16 @@ function openMutationContext(manifest, input) {
     metadata
   };
 }
-function prepareOwnershipFence(context, taskBundle) {
+function prepareOwnershipFence(context, taskBundle, expectedPredecessorBundleDigest) {
   const metadata = metadataFromBundle2(taskBundle);
   assertRemoteTaskEligible(metadata);
   assertTaskBundleIdentity(taskBundle, context.taskRef);
   if (metadata.ownerActorId === null) {
     throw new Error("MANCODE_TASK_OWNER_REQUIRED");
   }
+  if ((context.taskBundle?.bundleDigest ?? null) !== expectedPredecessorBundleDigest) {
+    throw new Error("MANCODE_TASK_BUNDLE_DIVERGED");
+  }
   if (context.fence === null) {
     if (metadata.ownerActorId !== context.input.actorId || metadata.ownershipEpoch !== 0 || taskBundle.ownershipEpoch !== 0) {
       throw new Error("MANCODE_TASK_OWNER_REQUIRED");
@@ -30119,14 +30394,45 @@ function prepareOwnershipFence(context, taskBundle) {
       throw new Error("MANCODE_TASK_REVISION_CONFLICT");
     }
     if (taskBundle.taskRevision === context.fence.taskRevision) {
-      if (taskBundle.aggregateDigest !== context.fence.aggregateDigest || taskBundle.codeRef.head !== context.taskBundle?.codeRef.head) {
+      if (taskBundle.aggregateDigest !== context.fence.aggregateDigest) {
         throw new Error("MANCODE_SPLIT_BRAIN");
       }
-      throw new Error("MANCODE_REMOTE_FENCE_NO_CHANGE");
+      if (taskBundle.codeRef.branch !== context.taskBundle?.codeRef.branch || taskBundle.codeRef.head === context.taskBundle?.codeRef.head) {
+        throw new Error("MANCODE_REMOTE_FENCE_NO_CHANGE");
+      }
+      return prepared(
+        context,
+        buildFence(context, taskBundle, metadata.ownerActorId),
+        refreshOwnerClaimsForCodeRef(context, taskBundle, metadata),
+        context.handoffs,
+        taskBundle
+      );
     }
   }
+  const codeHeadChanged = context.taskBundle !== null && (taskBundle.codeRef.branch !== context.taskBundle.codeRef.branch || taskBundle.codeRef.head !== context.taskBundle.codeRef.head);
   const fence = buildFence(context, taskBundle, metadata.ownerActorId);
-  return prepared(context, fence, context.claims, context.handoffs, taskBundle);
+  return prepared(
+    context,
+    fence,
+    codeHeadChanged ? refreshOwnerClaimsForCodeRef(context, taskBundle, metadata) : context.claims,
+    context.handoffs,
+    taskBundle
+  );
+}
+function refreshOwnerClaimsForCodeRef(context, taskBundle, metadata) {
+  return context.claims.map((claim) => {
+    if (claim.state !== "active" || claim.ownerActorId !== context.input.actorId || Date.parse(claim.expiresAt) <= context.now.getTime() || claim.ownershipEpochAtAcquire !== taskBundle.ownershipEpoch || claim.implementationScopeDigest !== metadata.implementationScope.digest) {
+      return claim;
+    }
+    const next = bindClaim(context, {
+      ...claim,
+      revision: claim.revision + 1,
+      lastValidatedTaskRevision: taskBundle.taskRevision,
+      lastValidatedCodeRef: taskBundle.codeRef
+    });
+    assertClaimTransition(claim, next);
+    return next;
+  });
 }
 function prepareClaimAcquire(context, proposal, confirmScopeWarning) {
   const { fence, taskBundle, metadata } = requireTaskContext(context);
@@ -30512,6 +30818,7 @@ function prepared(context, ownershipFence, claims, handoffs, taskBundle) {
     claims: claims.map(parseClaim).sort(compareClaims2),
     handoffs: handoffs.map(parseHandoff).sort(compareHandoffs2),
     taskBundle,
+    expectedTaskBundleDigest: context.taskBundle?.bundleDigest ?? null,
     forwardRepair: null
   };
 }
@@ -31664,7 +31971,7 @@ function handoffSuccessorClaimId(operationId, predecessorClaimId, createdAt) {
 }
 
 // src/team/git-ref-operation.ts
-var execFile8 = promisify7(execFileCallback5);
+var execFile9 = promisify8(execFileCallback6);
 async function syncGitRefTask(input) {
   const taskRef = requireSharedTask(input.taskRef);
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -31686,6 +31993,10 @@ async function syncGitRefTask(input) {
     );
     const snapshot = await transport.pull();
     const bundle = await bundleFromContext(context, now);
+    const remoteBase = await readGitRefTaskRemoteBase(
+      context.projectRoot,
+      taskRef
+    );
     const remoteTaskPublished = snapshot.manifest?.ownershipFences.some(
       (fence) => sameTaskRef(fence.taskRef, taskRef)
     ) === true && snapshot.manifest.taskBundles.some(
@@ -31701,6 +32012,7 @@ async function syncGitRefTask(input) {
       transport,
       snapshot,
       bundle,
+      remoteBase?.bundle ?? null,
       operationId,
       now
     );
@@ -31710,6 +32022,12 @@ async function syncGitRefTask(input) {
       context.project.config,
       refreshed
     );
+    const refreshedManifest = requireRemoteManifest(refreshed);
+    await recordGitRefTaskRemoteBase(
+      context.projectRoot,
+      refreshedManifest.revision,
+      requireRemoteBundle(refreshedManifest, taskRef)
+    );
     return { bundle, ...result2 };
   } finally {
     await context.release();
@@ -31741,6 +32059,10 @@ async function acquireGitRefClaim(input) {
     );
     let snapshot = await transport.pull();
     const bundle = await bundleFromContext(context, now);
+    const remoteBase = await readGitRefTaskRemoteBase(
+      context.projectRoot,
+      taskRef
+    );
     if (!remoteBundleMatches(snapshot, bundle)) {
       await assertCleanGitWorktree(context.projectRoot);
       const bootstrapOperationId = createUlid(now.getTime());
@@ -31749,6 +32071,7 @@ async function acquireGitRefClaim(input) {
         transport,
         snapshot,
         bundle,
+        remoteBase?.bundle ?? null,
         bootstrapOperationId,
         now
       );
@@ -31756,6 +32079,11 @@ async function acquireGitRefClaim(input) {
     }
     const manifest = requireRemoteManifest(snapshot);
     const fence = requireRemoteFence(manifest, taskRef);
+    await recordGitRefTaskRemoteBase(
+      context.projectRoot,
+      manifest.revision,
+      requireRemoteBundle(manifest, taskRef)
+    );
     const remote = context.project.config.transport.remote;
     if (remote === null) throw new Error("MANCODE_TRANSPORT_UNAVAILABLE");
     const remoteIdentityHash = await resolveGitRefRemoteIdentityHash(
@@ -31792,6 +32120,11 @@ async function acquireGitRefClaim(input) {
       context.project.config,
       refreshed
     );
+    await recordGitRefTaskRemoteBase(
+      context.projectRoot,
+      requireRemoteManifest(refreshed).revision,
+      requireRemoteBundle(requireRemoteManifest(refreshed), taskRef)
+    );
     const claim = requireRemoteManifest(refreshed).claims.find(
       (candidate) => candidate.claimId === claimId
     );
@@ -32245,7 +32578,7 @@ async function assertCleanGitWorktree(projectRoot, materializedTaskRef) {
       `:(exclude,top).mancode/shared/workflows/${materializedTaskRef.taskId}/**`
     );
   }
-  const { stdout: stdout2 } = await execFile8("git", args, {
+  const { stdout: stdout2 } = await execFile9("git", args, {
     cwd: projectRoot,
     windowsHide: true
   });
@@ -32274,7 +32607,7 @@ function freezeDeep(value) {
   for (const child of Object.values(value)) freezeDeep(child);
   return Object.freeze(value);
 }
-async function synchronizeBundle(context, transport, snapshot, bundle, operationId, now) {
+async function synchronizeBundle(context, transport, snapshot, bundle, remoteBase, operationId, now) {
   const manifest = requireRemoteManifest(snapshot);
   const fence = manifest.ownershipFences.find(
     (candidate) => sameTaskRef(candidate.taskRef, context.taskRef)
@@ -32287,6 +32620,16 @@ async function synchronizeBundle(context, transport, snapshot, bundle, operation
       changed: false
     };
   }
+  if (fence !== void 0 && fence.ownerActorId !== context.session.actorId) {
+    throw new Error("MANCODE_TASK_OWNER_REQUIRED");
+  }
+  const remoteBundle = fence === void 0 ? null : requireRemoteBundle(manifest, context.taskRef);
+  if (remoteBundle === null !== (remoteBase === null) || remoteBundle !== null && (remoteBase === null || remoteBundle.bundleDigest !== remoteBase.bundleDigest)) {
+    throw new Error("MANCODE_TASK_BUNDLE_DIVERGED");
+  }
+  if (remoteBundle !== null) {
+    await assertCodeRefFastForward(context.projectRoot, remoteBundle, bundle);
+  }
   const mutation = prepareGitRefCoordinationMutation(manifest, {
     kind: "ownership_fence",
     operationId,
@@ -32294,6 +32637,7 @@ async function synchronizeBundle(context, transport, snapshot, bundle, operation
     taskRef: context.taskRef,
     expectedRemoteRevision: manifest.revision,
     expectedOwnershipEpoch: fence?.ownershipEpoch ?? 0,
+    expectedPredecessorBundleDigest: remoteBundle?.bundleDigest ?? null,
     taskBundle: bundle,
     now
   });
@@ -32352,6 +32696,21 @@ function remoteBundleMatches(snapshot, bundle) {
   );
   return remote !== void 0 && remote.aggregateDigest === bundle.aggregateDigest && remote.taskRevision === bundle.taskRevision && remote.ownershipEpoch === bundle.ownershipEpoch && remote.codeRef.branch === bundle.codeRef.branch && remote.codeRef.head === bundle.codeRef.head;
 }
+async function assertCodeRefFastForward(projectRoot, previous, next) {
+  if (previous.codeRef.branch !== next.codeRef.branch) {
+    throw new Error("MANCODE_TASK_BUNDLE_DIVERGED");
+  }
+  if (previous.codeRef.head === next.codeRef.head) return;
+  try {
+    await execFile9(
+      "git",
+      ["merge-base", "--is-ancestor", previous.codeRef.head, next.codeRef.head],
+      { cwd: projectRoot, windowsHide: true }
+    );
+  } catch {
+    throw new Error("MANCODE_TASK_BUNDLE_DIVERGED");
+  }
+}
 function requireRemoteManifest(snapshot) {
   if (snapshot.manifest === null) {
     throw new Error("MANCODE_TRANSPORT_ACTOR_NOT_JOINED");
@@ -32441,7 +32800,7 @@ async function recoverGitRefHandoffRepairs(projectRoot) {
 }
 async function recoverGitRefHandoffRepair(projectRoot, operationId, transportReceipt) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  const root = path56.resolve(projectRoot);
+  const root = path57.resolve(projectRoot);
   let journal = await requireJournal2(root, operationId);
   if (journal.state === "committed" || journal.state === "aborted") {
     return recoveryResult2(journal);
@@ -32519,7 +32878,7 @@ async function recoverGitRefHandoffRepair(projectRoot, operationId, transportRec
   }
 }
 async function prepareHandoffRepairWhileTaskLocked(projectRoot, rawPrepared) {
-  const root = path56.resolve(projectRoot);
+  const root = path57.resolve(projectRoot);
   const prepared2 = parsePrepared2(rawPrepared);
   const runtime = await readProjectRuntimeContext(root);
   const previousMetadata = bundleMetadata2(prepared2.predecessorBundle);
@@ -32582,7 +32941,7 @@ async function restorePredecessorMetadata2(projectRoot, journal) {
   );
 }
 async function replaceMetadataVerified(projectRoot, expected, targetMetadata, alternateExpected) {
-  const target = path56.join(
+  const target = path57.join(
     taskRootPath(projectRoot, targetMetadata.taskRef),
     "metadata.json"
   );
@@ -32708,12 +33067,12 @@ async function createJournal3(projectRoot, journal) {
   await ensureJournalDirectory2(projectRoot);
   const target = journalPath3(projectRoot, journal.operationId);
   try {
-    await writeFile38(target, serialize13(journal), {
+    await writeFile39(target, serialize13(journal), {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
-    if (!isAlreadyExists22(error)) throw error;
+    if (!isAlreadyExists23(error)) throw error;
     const existing = await requireJournal2(projectRoot, journal.operationId);
     if (digestCanonicalJson(existing) !== digestCanonicalJson(journal)) {
       throw new Error("MANCODE_HANDOFF_REPAIR_JOURNAL_CONFLICT");
@@ -32727,10 +33086,10 @@ async function replaceJournal3(projectRoot, journal) {
 async function requireJournal2(projectRoot, operationId) {
   try {
     return parseJournal3(
-      JSON.parse(await readFile37(journalPath3(projectRoot, operationId), "utf8"))
+      JSON.parse(await readFile39(journalPath3(projectRoot, operationId), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound25(error)) {
+    if (error instanceof SyntaxError || isNotFound27(error)) {
       throw new Error("MANCODE_HANDOFF_REPAIR_JOURNAL_NOT_FOUND");
     }
     throw error;
@@ -32739,9 +33098,9 @@ async function requireJournal2(projectRoot, operationId) {
 async function listJournals2(projectRoot) {
   let entries;
   try {
-    entries = await readdir17(journalDirectory2(projectRoot));
+    entries = await readdir18(journalDirectory2(projectRoot));
   } catch (error) {
-    if (isNotFound25(error)) return [];
+    if (isNotFound27(error)) return [];
     throw error;
   }
   const journals = [];
@@ -32750,8 +33109,8 @@ async function listJournals2(projectRoot) {
     journals.push(
       parseJournal3(
         JSON.parse(
-          await readFile37(
-            path56.join(journalDirectory2(projectRoot), entry),
+          await readFile39(
+            path57.join(journalDirectory2(projectRoot), entry),
             "utf8"
           )
         )
@@ -32761,43 +33120,43 @@ async function listJournals2(projectRoot) {
   return journals;
 }
 async function readSafeFile2(target) {
-  const before = await lstat19(target);
+  const before = await lstat20(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const content = await readFile37(target, "utf8");
-  const after = await lstat19(target);
+  const content = await readFile39(target, "utf8");
+  const after = await lstat20(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return content;
 }
 async function atomicWrite2(target, content) {
-  const temporary = path56.join(
-    path56.dirname(target),
-    `.${path56.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path57.join(
+    path57.dirname(target),
+    `.${path57.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile38(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile39(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory2(projectRoot) {
-  let current = path56.resolve(projectRoot);
+  let current = path57.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-handoff"]) {
-    current = path56.join(current, segment);
+    current = path57.join(current, segment);
     try {
-      await mkdir33(current);
+      await mkdir34(current);
     } catch (error) {
-      if (!isAlreadyExists22(error)) throw error;
+      if (!isAlreadyExists23(error)) throw error;
     }
-    const entry = await lstat19(current);
+    const entry = await lstat20(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 function journalDirectory2(projectRoot) {
-  return path56.join(
-    path56.resolve(projectRoot),
+  return path57.join(
+    path57.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -32806,7 +33165,7 @@ function journalDirectory2(projectRoot) {
 }
 function journalPath3(projectRoot, operationId) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  return path56.join(journalDirectory2(projectRoot), `${operationId}.json`);
+  return path57.join(journalDirectory2(projectRoot), `${operationId}.json`);
 }
 function serialize13(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -32818,10 +33177,10 @@ function parseTimestamp14(value) {
   }
   return value;
 }
-function isAlreadyExists22(error) {
+function isAlreadyExists23(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound25(error) {
+function isNotFound27(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -32905,8 +33264,8 @@ function parseReceipt(value) {
 }
 
 // src/team/policy-operation.ts
-import { lstat as lstat20, mkdir as mkdir34, readdir as readdir18, unlink as unlink3, writeFile as writeFile39 } from "fs/promises";
-import path57 from "path";
+import { lstat as lstat21, mkdir as mkdir35, readdir as readdir19, unlink as unlink3, writeFile as writeFile40 } from "fs/promises";
+import path58 from "path";
 async function updateTeamPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   const eventId = createUlid();
@@ -32917,7 +33276,7 @@ async function updateTeamPolicy(input) {
     throw new Error("MANCODE_TEAM_POLICY_INVALID");
   }
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path57.resolve(input.projectRoot);
+  const root = path58.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -32998,7 +33357,7 @@ async function applyTeamTransportSet(input, write2) {
   }
   const remote = transportRemote(input.mode, input.remote);
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path57.resolve(input.projectRoot);
+  const root = path58.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -33131,9 +33490,9 @@ async function assertTransportAuthorityEmpty(projectRoot, store) {
     listClaims(store),
     listHandoffs(store),
     directoryHasEntries(taskHeadDirectory(store)),
-    directoryHasEntries(path57.join(store.root, "transport-migrations")),
+    directoryHasEntries(path58.join(store.root, "transport-migrations")),
     directoryHasEntries(
-      path57.join(projectRoot, ".mancode", "shared", "team", "transport")
+      path58.join(projectRoot, ".mancode", "shared", "team", "transport")
     ),
     pathExists14(gitRefCachePath(projectRoot))
   ]);
@@ -33163,21 +33522,21 @@ function assertPositiveRevision5(value, label) {
   }
 }
 function teamPolicyPath(projectRoot) {
-  return path57.join(projectRoot, ".mancode", "shared", "team", "policy.json");
+  return path58.join(projectRoot, ".mancode", "shared", "team", "policy.json");
 }
 function projectConfigPath(projectRoot) {
-  return path57.join(projectRoot, ".mancode", "shared", "config.json");
+  return path58.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function writeJsonAtomic4(target, value) {
-  await mkdir34(path57.dirname(target), { recursive: true });
-  await assertPlainDirectory(path57.dirname(target));
+  await mkdir35(path58.dirname(target), { recursive: true });
+  await assertPlainDirectory(path58.dirname(target));
   await assertPlainFileOrMissing(target);
-  const temporary = path57.join(
-    path57.dirname(target),
-    `.${path57.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  const temporary = path58.join(
+    path58.dirname(target),
+    `.${path58.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile39(temporary, `${JSON.stringify(value, null, 2)}
+    await writeFile40(temporary, `${JSON.stringify(value, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -33189,61 +33548,61 @@ async function writeJsonAtomic4(target, value) {
   }
 }
 async function assertPlainDirectory(target) {
-  const entry = await lstat20(target);
+  const entry = await lstat21(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function assertPlainFileOrMissing(target) {
   try {
-    const entry = await lstat20(target);
+    const entry = await lstat21(target);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   } catch (error) {
-    if (isNotFound26(error)) return;
+    if (isNotFound28(error)) return;
     throw error;
   }
 }
 async function directoryHasEntries(target) {
   try {
-    const entry = await lstat20(target);
+    const entry = await lstat21(target);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    return (await readdir18(target)).length > 0;
+    return (await readdir19(target)).length > 0;
   } catch (error) {
-    if (isNotFound26(error)) return false;
+    if (isNotFound28(error)) return false;
     throw error;
   }
 }
 async function pathExists14(target) {
   try {
-    await lstat20(target);
+    await lstat21(target);
     return true;
   } catch (error) {
-    if (isNotFound26(error)) return false;
+    if (isNotFound28(error)) return false;
     throw error;
   }
 }
 async function releaseLocks3(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
-function isNotFound26(error) {
+function isNotFound28(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/transport-migration-adapters.ts
 import {
-  lstat as lstat21,
-  mkdir as mkdir35,
-  readFile as readFile38,
-  readdir as readdir19,
+  lstat as lstat22,
+  mkdir as mkdir36,
+  readFile as readFile40,
+  readdir as readdir20,
   rename as rename10,
   unlink as unlink4,
-  writeFile as writeFile40
+  writeFile as writeFile41
 } from "fs/promises";
-import path58 from "path";
+import path59 from "path";
 
 // src/team/transport-migration.ts
 var DIGEST_PATTERN7 = /^sha256:[a-f0-9]{64}$/;
@@ -34315,7 +34674,7 @@ function compareUtf812(left, right) {
 var STAGE_DIRECTORY = "transport-migrations";
 var COLLECTIONS = ["claims", "handoffs", "task-heads"];
 async function createTransportMigrationFileAdapters(input) {
-  const projectRoot = path58.resolve(input.projectRoot);
+  const projectRoot = path59.resolve(input.projectRoot);
   assertUlid(input.actorId, "transport migration adapter actorId");
   if (input.operationId !== void 0) {
     assertUlid(input.operationId, "transport migration adapter operationId");
@@ -34367,7 +34726,7 @@ async function createTransportMigrationFileAdapters(input) {
 var FileSystemTransportMigrationConfigAdapter = class {
   constructor(projectRoot, coordinationStore) {
     this.coordinationStore = coordinationStore;
-    this.projectRoot = path58.resolve(projectRoot);
+    this.projectRoot = path59.resolve(projectRoot);
   }
   coordinationStore;
   projectRoot;
@@ -35230,27 +35589,27 @@ async function publishMigrationActorProfiles(projectRoot, profiles) {
   }
 }
 async function archiveLocalCoordinationCollections(store, operationId) {
-  const archiveRoot = path58.join(
+  const archiveRoot = path59.join(
     store.root,
     STAGE_DIRECTORY,
     "archive",
     operationId
   );
-  await mkdir35(archiveRoot, { recursive: true });
+  await mkdir36(archiveRoot, { recursive: true });
   const directories = {
     claims: claimDirectory(store),
     handoffs: handoffDirectory(store),
     "task-heads": taskHeadDirectory(store)
   };
   for (const name of COLLECTIONS) {
-    const archived = path58.join(archiveRoot, name);
-    const absent = path58.join(archiveRoot, `${name}.absent`);
+    const archived = path59.join(archiveRoot, name);
+    const absent = path59.join(archiveRoot, `${name}.absent`);
     if (await pathKind(archived) === "directory" || await pathKind(absent) === "file") {
       continue;
     }
     const sourceKind = await pathKind(directories[name]);
     if (sourceKind === null) {
-      await writeFile40(absent, "\n", { encoding: "utf8", flag: "wx" });
+      await writeFile41(absent, "\n", { encoding: "utf8", flag: "wx" });
       continue;
     }
     if (sourceKind !== "directory") {
@@ -35263,9 +35622,9 @@ async function listActorProfiles(projectRoot) {
   const directory = sharedActorProfileDirectory(projectRoot);
   let entries;
   try {
-    entries = await readdir19(directory);
+    entries = await readdir20(directory);
   } catch (error) {
-    if (isNotFound27(error)) return [];
+    if (isNotFound29(error)) return [];
     throw error;
   }
   const profiles = [];
@@ -35282,18 +35641,18 @@ async function listActorProfiles(projectRoot) {
   return profiles;
 }
 async function listSharedTaskRefs(projectRoot) {
-  const directory = path58.join(projectRoot, ".mancode", "shared", "workflows");
+  const directory = path59.join(projectRoot, ".mancode", "shared", "workflows");
   let entries;
   try {
-    entries = await readdir19(directory);
+    entries = await readdir20(directory);
   } catch (error) {
-    if (isNotFound27(error)) return [];
+    if (isNotFound29(error)) return [];
     throw error;
   }
   const refs = [];
   for (const taskId of entries.sort(compareUtf813)) {
     assertUlid(taskId, "shared workflow directory");
-    const stat4 = await lstat21(path58.join(directory, taskId));
+    const stat4 = await lstat22(path59.join(directory, taskId));
     if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
       throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
     }
@@ -35305,7 +35664,7 @@ async function readTaskSnapshotOrNull(projectRoot, taskRef) {
   try {
     return await new V3ContextStore(projectRoot).readTaskSnapshot(taskRef);
   } catch (error) {
-    if (error instanceof Error && (error.message === "MANCODE_TASK_NOT_FOUND" || isNotFound27(error))) {
+    if (error instanceof Error && (error.message === "MANCODE_TASK_NOT_FOUND" || isNotFound29(error))) {
       return null;
     }
     throw error;
@@ -35367,7 +35726,7 @@ async function readStagedRecord(store, operationId) {
   );
 }
 function stagedPath(store, operationId) {
-  return path58.join(
+  return path59.join(
     store.root,
     STAGE_DIRECTORY,
     "staged",
@@ -35375,7 +35734,7 @@ function stagedPath(store, operationId) {
   );
 }
 function establishedPath(store, operationId) {
-  return path58.join(
+  return path59.join(
     store.root,
     STAGE_DIRECTORY,
     "established",
@@ -35383,12 +35742,12 @@ function establishedPath(store, operationId) {
   );
 }
 function projectConfigPath2(projectRoot) {
-  return path58.join(projectRoot, ".mancode", "shared", "config.json");
+  return path59.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function readProjectConfigFile(projectRoot) {
   try {
     return parseProjectConfig(
-      JSON.parse(await readFile38(projectConfigPath2(projectRoot), "utf8"))
+      JSON.parse(await readFile40(projectConfigPath2(projectRoot), "utf8"))
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -35398,14 +35757,14 @@ async function readProjectConfigFile(projectRoot) {
   }
 }
 async function writeJsonAtomic5(target, value) {
-  await mkdir35(path58.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path58.dirname(target));
-  const temporary = path58.join(
-    path58.dirname(target),
-    `.${path58.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  await mkdir36(path59.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path59.dirname(target));
+  const temporary = path59.join(
+    path59.dirname(target),
+    `.${path59.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile40(temporary, serialize14(value), {
+    await writeFile41(temporary, serialize14(value), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -35416,12 +35775,12 @@ async function writeJsonAtomic5(target, value) {
   }
 }
 async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
-  await mkdir35(path58.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path58.dirname(target));
+  await mkdir36(path59.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path59.dirname(target));
   try {
-    await writeFile40(target, serialize14(value), { encoding: "utf8", flag: "wx" });
+    await writeFile41(target, serialize14(value), { encoding: "utf8", flag: "wx" });
   } catch (error) {
-    if (!isAlreadyExists23(error)) throw error;
+    if (!isAlreadyExists24(error)) throw error;
     const existing = await readJsonOrNull5(target, parser, conflictCode);
     if (existing !== null && digestCanonicalJson(existing) === digestCanonicalJson(value)) {
       return;
@@ -35431,18 +35790,18 @@ async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
 }
 async function readJsonOrNull5(target, parser, corruptCode) {
   try {
-    const before = await lstat21(target);
+    const before = await lstat22(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
-    const parsed = parser(JSON.parse(await readFile38(target, "utf8")));
-    const after = await lstat21(target);
+    const parsed = parser(JSON.parse(await readFile40(target, "utf8")));
+    const after = await lstat22(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
     return parsed;
   } catch (error) {
-    if (isNotFound27(error)) return null;
+    if (isNotFound29(error)) return null;
     if (error instanceof SyntaxError) throw new Error(corruptCode);
     throw error;
   }
@@ -35494,18 +35853,18 @@ function requireRemote(value) {
 }
 async function pathKind(target) {
   try {
-    const stat4 = await lstat21(target);
+    const stat4 = await lstat22(target);
     if (stat4.isSymbolicLink()) return "other";
     if (stat4.isFile()) return "file";
     if (stat4.isDirectory()) return "directory";
     return "other";
   } catch (error) {
-    if (isNotFound27(error)) return null;
+    if (isNotFound29(error)) return null;
     throw error;
   }
 }
 async function assertPlainDirectory2(target) {
-  const stat4 = await lstat21(target);
+  const stat4 = await lstat22(target);
   if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
     throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
   }
@@ -35514,7 +35873,7 @@ async function unlinkIfExists2(target) {
   try {
     await unlink4(target);
   } catch (error) {
-    if (!isNotFound27(error)) throw error;
+    if (!isNotFound29(error)) throw error;
   }
 }
 function serialize14(value) {
@@ -35524,10 +35883,10 @@ function serialize14(value) {
 function compareUtf813(left, right) {
   return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
 }
-function isAlreadyExists23(error) {
+function isAlreadyExists24(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound27(error) {
+function isNotFound29(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -36967,16 +37326,16 @@ function parsePositiveInteger5(value) {
 }
 
 // src/commands/uninstall.ts
-import { access as access5, readFile as readFile39, rm as rm17, writeFile as writeFile41 } from "fs/promises";
-import path59 from "path";
+import { access as access5, readFile as readFile41, rm as rm17, writeFile as writeFile42 } from "fs/promises";
+import path60 from "path";
 import process11 from "process";
 var EXIT_OK9 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
 var EXIT_V3_AUTHORITY_PROTECTED = 3;
 async function uninstall(rootDir = process11.cwd(), platform, options = {}) {
-  const stateFile = path59.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path59.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path60.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path60.join(rootDir, ".mancode", "schema.json");
   if (await pathExists15(v3SchemaFile)) {
     return uninstallV3(rootDir, platform, options);
   }
@@ -37067,7 +37426,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm17(path59.join(rootDir, ".mancode"), {
+  await rm17(path60.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -37077,10 +37436,10 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path59.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path60.join(rootDir, ".claude", "settings.json");
   let content;
   try {
-    content = await readFile39(settingsPath, "utf-8");
+    content = await readFile41(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -37106,7 +37465,7 @@ async function cleanClaudeSettings(rootDir) {
     );
     settings.skills = Object.keys(retainedSkills).length > 0 ? retainedSkills : void 0;
   }
-  await writeFile41(
+  await writeFile42(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -37155,12 +37514,12 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path59.join(rootDir, "AGENTS.md");
+  const agentsPath = path60.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile39(agentsPath, "utf-8");
+    const content = await readFile41(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile41(agentsPath, `${cleaned}
+      await writeFile42(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm17(agentsPath, { force: true });
@@ -37170,16 +37529,16 @@ async function uninstallCodex(rootDir) {
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path59.join(
+  const instructionsPath = path60.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
   );
   try {
-    const content = await readFile39(instructionsPath, "utf-8");
+    const content = await readFile41(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile41(instructionsPath, `${cleaned}
+      await writeFile42(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm17(instructionsPath, { force: true });
@@ -37189,16 +37548,16 @@ async function uninstallCopilot(rootDir) {
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path59.join(rootDir, "AGENTS.md");
+  const agentsPath = path60.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile39(agentsPath, "utf-8");
+    const content = await readFile41(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile41(agentsPath, `${cleaned}
+      await writeFile42(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm17(agentsPath, { force: true });
@@ -37208,9 +37567,9 @@ async function uninstallZcode(rootDir) {
   await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path59.join(rootDir, ".mancode", "config.json");
+  const configPath = path60.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await readFile39(configPath, "utf-8");
+    const raw = await readFile41(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
@@ -37222,7 +37581,7 @@ async function removeFromConfig(rootDir, platform) {
         );
         config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
       }
-      await writeFile41(
+      await writeFile42(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -37255,8 +37614,8 @@ function version() {
 }
 
 // src/commands/workflow.ts
-import { access as access6, readFile as readFile41, rm as rm19, writeFile as writeFile43 } from "fs/promises";
-import path61 from "path";
+import { access as access6, readFile as readFile43, rm as rm19, writeFile as writeFile44 } from "fs/promises";
+import path62 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -39711,14 +40070,14 @@ function updateMetadata4(previous, verification, operationId, updatedAt) {
 
 // src/context/workflow-create.ts
 import {
-  lstat as lstat22,
-  mkdir as mkdir36,
-  readFile as readFile40,
+  lstat as lstat23,
+  mkdir as mkdir37,
+  readFile as readFile42,
   rename as rename11,
   rm as rm18,
-  writeFile as writeFile42
+  writeFile as writeFile43
 } from "fs/promises";
-import path60 from "path";
+import path61 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -39828,7 +40187,7 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path60.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path61.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();
@@ -39991,8 +40350,8 @@ async function createV3Workflow(input) {
   assertOperationRecoveryPayloadCoversJournal(operation, recoveryPayload);
   assertOperationJournalMatchesDefinition(operation);
   const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-  const targetDirectory = path60.join(taskParent, taskRef.taskId);
-  const stagingDirectory = path60.join(
+  const targetDirectory = path61.join(taskParent, taskRef.taskId);
+  const stagingDirectory = path61.join(
     taskParent,
     `.${taskRef.taskId}.${operationId}.staging`
   );
@@ -40433,10 +40792,10 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path60.join(current, segment);
+    current = path61.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
-      await mkdir36(current);
+      await mkdir37(current);
       continue;
     }
     if (!existing.isDirectory() || existing.isSymbolicLink()) {
@@ -40449,7 +40808,7 @@ async function assertDirectoryAbsent(target, code) {
   if (await lstatOrNull5(target) !== null) throw new Error(code);
 }
 async function writeStagedEntities(stagingDirectory, entities) {
-  await mkdir36(stagingDirectory);
+  await mkdir37(stagingDirectory);
   await assertDirectory(stagingDirectory);
   await Promise.all([
     writeStagedJson(stagingDirectory, "metadata.json", entities.metadata),
@@ -40469,13 +40828,13 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path60.join(stagingDirectory, fileName);
-  await writeFile42(target, `${JSON.stringify(value, null, 2)}
+  const target = path61.join(stagingDirectory, fileName);
+  await writeFile43(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  const entry = await lstat22(target);
+  const entry = await lstat23(target);
   if (!entry.isFile() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -40507,13 +40866,13 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path60.join(stagingDirectory, fileName);
-  const before = await lstat22(target);
+  const target = path61.join(stagingDirectory, fileName);
+  const before = await lstat23(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const parsed = parser(JSON.parse(await readFile40(target, "utf8")));
-  const after = await lstat22(target);
+  const parsed = parser(JSON.parse(await readFile42(target, "utf8")));
+  const after = await lstat23(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -40608,16 +40967,16 @@ async function abortPreparedCreate(store, journal, stagingDirectory, now) {
   }
 }
 async function assertDirectory(target) {
-  const entry = await lstat22(target);
+  const entry = await lstat23(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function lstatOrNull5(target) {
   try {
-    return await lstat22(target);
+    return await lstat23(target);
   } catch (error) {
-    if (isNotFound28(error)) return null;
+    if (isNotFound30(error)) return null;
     throw error;
   }
 }
@@ -40637,7 +40996,7 @@ function requireText2(value, label) {
   }
   return value.trim();
 }
-function isNotFound28(error) {
+function isNotFound30(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -41191,6 +41550,9 @@ async function publishTaskMutation(input) {
       taskRef: input.context.taskRef,
       expectedRemoteRevision: input.manifest.revision,
       expectedOwnershipEpoch: input.fence.ownershipEpoch,
+      expectedTaskBundleDigest: input.manifest.taskBundles.find(
+        (bundle) => sameTaskRef(bundle.taskRef, input.context.taskRef)
+      )?.bundleDigest ?? null,
       ownershipFence: fence,
       claims: input.claims,
       handoffs,
@@ -41579,7 +41941,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
   if (v3Activation === "v3_active") {
     return workflowV3(rootDir, subcommand, args, options);
   }
-  if (!await pathExists16(path61.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists16(path62.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -42507,8 +42869,8 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path61.isAbsolute(value) ? value : path61.resolve(projectRoot, value);
-  return readFile41(inputPath, "utf8");
+  const inputPath = path62.isAbsolute(value) ? value : path62.resolve(projectRoot, value);
+  return readFile43(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
   return JSON.parse(await readWorkflowInputFile(projectRoot, value));
@@ -42575,7 +42937,7 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile41(path61.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile43(path62.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
@@ -42620,21 +42982,21 @@ 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 = path61.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path61.join(workflowPath, "requirements.json");
-  const markdownPath = path61.join(workflowPath, "requirements.md");
-  const metadataPath3 = path61.join(workflowPath, "metadata.json");
+  const workflowPath = path62.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path62.join(workflowPath, "requirements.json");
+  const markdownPath = path62.join(workflowPath, "requirements.md");
+  const metadataPath3 = path62.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path61.isAbsolute(options.file) ? options.file : path61.resolve(rootDir, options.file);
-    const input = await readFile41(inputPath, "utf-8");
+    const inputPath = path62.isAbsolute(options.file) ? options.file : path62.resolve(rootDir, options.file);
+    const input = await readFile43(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
       readOptionalText2(jsonPath),
       readOptionalText2(markdownPath),
-      readFile41(metadataPath3, "utf-8")
+      readFile43(metadataPath3, "utf-8")
     ]);
     await writeRequirementsArtifacts(rootDir, taskId, requirements);
     await updateWorkflow(rootDir, taskId, {
@@ -42664,7 +43026,7 @@ async function workflowRequirements(rootDir, args, options) {
       const rollback = await Promise.allSettled([
         restoreOptionalText(jsonPath, originalJson),
         restoreOptionalText(markdownPath, originalMarkdown),
-        writeFile43(metadataPath3, originalMetadata, "utf-8")
+        writeFile44(metadataPath3, originalMetadata, "utf-8")
       ]);
       rollbackIncomplete = rollback.some(
         (result2) => result2.status === "rejected"
@@ -42752,7 +43114,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path61.isAbsolute(options.evidenceFile) ? options.evidenceFile : path61.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path62.isAbsolute(options.evidenceFile) ? options.evidenceFile : path62.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -42812,17 +43174,17 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path61.join(
+  const metadataPath3 = path62.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path61.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path62.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile41(metadataPath3, "utf-8"),
+    readFile43(metadataPath3, "utf-8"),
     readOptionalText2(specPath)
   ]);
   const wasVerificationBlocked = meta.status === "blocked" && meta.blockingReason?.startsWith("[verification]");
@@ -42851,7 +43213,7 @@ async function commitVerificationTransition(rootDir, meta, ledger) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile43(metadataPath3, originalMetadata, "utf-8"),
+      writeFile44(metadataPath3, originalMetadata, "utf-8"),
       restoreOptionalText(specPath, originalSpec)
     ]);
     const message = error instanceof Error ? error.message : "verification transition failed";
@@ -42983,7 +43345,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path61.join(
+  const metadataPath3 = path62.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -42992,7 +43354,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   );
   const [originalLedger, originalMetadata] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile41(metadataPath3, "utf-8")
+    readFile43(metadataPath3, "utf-8")
   ]);
   try {
     await initializeSkippedReview(rootDir, meta.taskId, reason);
@@ -43003,7 +43365,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile43(metadataPath3, originalMetadata, "utf-8")
+      writeFile44(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;
@@ -43223,18 +43585,18 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path61.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path61.join(workflowPath, "requirements.md")) || !await pathExists16(path61.join(workflowPath, "plan.md"))) {
+  const workflowPath = path62.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path62.join(workflowPath, "requirements.md")) || !await pathExists16(path62.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path61.join(rootDir, ".mancode", "state.json");
+  const statePath = path62.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile41(statePath, "utf-8");
+    originalState = await readFile43(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -43305,11 +43667,11 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path61.join(rootDir, ".mancode", "state.json");
+  const statePath = path62.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile41(statePath, "utf-8");
+    originalState = await readFile43(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -43372,18 +43734,18 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path61.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path61.join(workflowPath, "requirements.md")) || !await pathExists16(path61.join(workflowPath, "plan.md"))) {
+  const workflowPath = path62.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path62.join(workflowPath, "requirements.md")) || !await pathExists16(path62.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path61.join(rootDir, ".mancode", "state.json");
+  const statePath = path62.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile41(statePath, "utf-8");
+    originalState = await readFile43(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -43435,25 +43797,25 @@ async function workflowDecide(rootDir, taskId, options) {
   return EXIT_OK10;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path61.join(
+  const metadataPath3 = path62.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path61.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path62.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {
-    originalMetadata = await readFile41(metadataPath3, "utf-8");
+    originalMetadata = await readFile43(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 writeFile43(
+    await writeFile44(
       args.statePath,
       `${JSON.stringify(args.nextState, null, 2)}
 `,
@@ -43467,9 +43829,9 @@ async function commitPlanningTransition(args) {
     return null;
   } catch (error) {
     const rollback = await Promise.allSettled([
-      writeFile43(metadataPath3, originalMetadata, "utf-8"),
-      writeFile43(args.statePath, args.originalState, "utf-8"),
-      originalSpec === null ? rm19(specPath, { force: true }) : writeFile43(specPath, originalSpec, "utf-8")
+      writeFile44(metadataPath3, originalMetadata, "utf-8"),
+      writeFile44(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm19(specPath, { force: true }) : writeFile44(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;
@@ -43477,7 +43839,7 @@ async function commitPlanningTransition(args) {
 }
 async function readOptionalText2(filePath) {
   try {
-    return await readFile41(filePath, "utf-8");
+    return await readFile43(filePath, "utf-8");
   } catch (error) {
     if (isNodeError10(error) && error.code === "ENOENT") return null;
     throw error;
@@ -43488,7 +43850,7 @@ async function restoreOptionalText(filePath, content) {
     await rm19(filePath, { force: true });
     return;
   }
-  await writeFile43(filePath, content, "utf-8");
+  await writeFile44(filePath, content, "utf-8");
 }
 function readActiveSoloPlan(value) {
   if (!value || typeof value !== "object") return null;