mancode 0.6.5 → 0.6.6

package/dist/cli.js

@@ -37,6 +37,7 @@ import {
   assertSharedPrivacyValue,
   assertSharedTaskWriteAtRoot,
   assertSharedTextSafe,
+  assertSoloHandoffSession,
   assertTaskCompletionGate,
   assertTaskHeadFenceMatchesAggregate,
   assertTaskHeadFenceTransition,
@@ -60,6 +61,7 @@ import {
   gitRefWorkflowRepairJournalPath,
   hasProjectEvidence,
   implementationScopeIsExecutable,
+  isActiveSoloHandoff,
   isPrivacyExcluded,
   listGitRefWorkflowRepairJournalSummaries,
   listUnfinishedGitRefWorkflowRepairs,
@@ -103,6 +105,7 @@ import {
   readPrivacyAuthorityFile,
   readPrivacyPolicySnapshot,
   readPrivacyPolicyStatus,
+  redactSharedText,
   removeOperationReservation,
   replaceFileAtomically,
   requirementsAreReady,
@@ -120,7 +123,7 @@ import {
   withSharedPrivacyWrite,
   workflowMetadataDigest,
   writeProjectFacts
-} from "./chunk-E2K22WYH.js";
+} from "./chunk-D5ABGAF4.js";
 import {
   ACCEPTED_STATE_NARRATIVE_GUIDANCE,
   DEFAULT_MANCODE_END_MARKER,
@@ -149,7 +152,7 @@ import {
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses,
   writeThroughResolvedPath
-} from "./chunk-WJ6WARGG.js";
+} from "./chunk-RMHUYJXB.js";
 import {
   readPrivacyGatewayStatus,
   registerPrivacyGatewayCommands
@@ -4746,6 +4749,9 @@ async function clearSessionTaskPointer(projectRoot, sessionId, input = {}) {
     if (expected !== void 0 && (session.activeTaskRef === null || session.activeTaskRef.namespace !== expected.namespace || session.activeTaskRef.taskId !== expected.taskId)) {
       return session;
     }
+    if (input.isStillApplicable && !await input.isStillApplicable()) {
+      return session;
+    }
     const updated = {
       ...session,
       activeTaskRef: null,
@@ -7953,8 +7959,12 @@ function buildContextPack(input) {
       omissions.push(omissionFor(section, "privacy"));
       continue;
     }
-    if (containsSensitiveText(section.value) || input.privacy?.policy.enabled && containsEnhancedSensitiveText(
-      section.value,
+    const projected = projectGovernanceLocalPaths(
+      section,
+      input.privacy?.policy.enabled ? input.privacy.policy.enabledRuleIds : void 0
+    );
+    if (containsSensitiveText(projected.value) || input.privacy?.policy.enabled && containsEnhancedSensitiveText(
+      projected.value,
       input.privacy.policy.enabledRuleIds
     )) {
       omissions.push(omissionFor(section, "privacy"));
@@ -7963,7 +7973,7 @@ function buildContextPack(input) {
       }
       continue;
     }
-    included.set(pointer, section);
+    included.set(pointer, projected);
   }
   while (true) {
     const candidate = assemblePack(input, included, omissions, false, 0);
@@ -8138,6 +8148,90 @@ function containsSensitiveText(value) {
   }
   return false;
 }
+function projectGovernanceLocalPaths(section, enhancedRuleIds) {
+  if (!isRequiredSection(section) || !isRecord3(section.value)) return section;
+  const original = section.value;
+  const redactions = [];
+  const projectText = (value2, pointer, command = false) => {
+    const findings = scanSharedText(value2);
+    if (findings.length === 0 || findings.some((finding) => finding.kind !== "absolute_path")) {
+      return value2;
+    }
+    const text = redactSharedText(value2).text;
+    if (enhancedRuleIds !== void 0 && containsEnhancedSensitiveText(text, enhancedRuleIds)) {
+      return value2;
+    }
+    const target = `${section.targetJsonPointer}${pointer}`;
+    redactions.push(`${target}:absolute_path`);
+    if (command) {
+      redactions.push(`${target}:command_omitted_not_executable`);
+      return "[REDACTED:non_executable_command]";
+    }
+    return text;
+  };
+  let value;
+  if (section.targetJsonPointer === "/governance/requirements") {
+    value = { ...original };
+    if (Array.isArray(original.technicalDecisions)) {
+      value.technicalDecisions = original.technicalDecisions.map(
+        (decision, index) => isRecord3(decision) && typeof decision.statement === "string" ? {
+          ...decision,
+          statement: projectText(
+            decision.statement,
+            `/technicalDecisions/${index}/statement`
+          )
+        } : decision
+      );
+    }
+    if (isRecord3(original.functionalScope) && Array.isArray(original.functionalScope.outOfScope)) {
+      value.functionalScope = {
+        ...original.functionalScope,
+        outOfScope: original.functionalScope.outOfScope.map(
+          (entry, index) => typeof entry === "string" ? projectText(entry, `/functionalScope/outOfScope/${index}`) : entry
+        )
+      };
+    }
+  } else if (section.targetJsonPointer === "/governance/review" && isRecord3(original.delivery) && typeof original.delivery.correctness === "string") {
+    value = {
+      ...original,
+      delivery: {
+        ...original.delivery,
+        correctness: projectText(
+          original.delivery.correctness,
+          "/delivery/correctness"
+        )
+      }
+    };
+  } else if (section.targetJsonPointer === "/governance/verification" && Array.isArray(original.checks)) {
+    value = {
+      ...original,
+      checks: original.checks.map(
+        (check, index) => isRecord3(check) && isRecord3(check.automated) && typeof check.automated.command === "string" ? {
+          ...check,
+          automated: {
+            ...check.automated,
+            command: projectText(
+              check.automated.command,
+              `/checks/${index}/automated/command`,
+              true
+            )
+          }
+        } : check
+      )
+    };
+  } else {
+    return section;
+  }
+  if (redactions.length === 0) return section;
+  return {
+    ...section,
+    value,
+    provenance: section.provenance.map((entry) => ({
+      ...entry,
+      redactions: [.../* @__PURE__ */ new Set([...entry.redactions, ...redactions])].sort()
+    }))
+  };
+}
 function assertBuildInput(input) {
   assertTimestamp(input.generatedAt, "context pack generatedAt");
   assertContextLevel(input.level);
@@ -10759,7 +10853,7 @@ async function activateLegacyMigration(input) {
     if (session === null || session.status !== "active") {
       throw new Error("MANCODE_SESSION_NOT_FOUND");
     }
-    const store = new (await import("./store-GSLSLZ7D.js")).V3ContextStore(root);
+    const store = new (await import("./store-LLXL7QYG.js")).V3ContextStore(root);
     const project = await store.readProjectSnapshot();
     const stage = await readMigrationStage(root, input.stageId);
     if (stage.state !== "staged" || stage.revision !== input.expectedStageRevision) {
@@ -11033,7 +11127,7 @@ async function activateLegacyMigration(input) {
       for (const action of payload.actions.filter(
         (action2) => action2.kind === "v3_adapter_file"
       )) {
-        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-T3IKK3LU.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-KA2NOVI5.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -14711,7 +14805,7 @@ async function inspectOperationProjectionState(projectRoot, operationId) {
   });
   for (const intent of intents) {
     const key = projectionStateKey(intent.target.kind);
-    const availability = intent.state === "superseded" ? "not_applicable" : await inspectProjection(projectRoot, intent.target);
+    const availability = intent.state === "superseded" || intent.state === "completed" && intent.target.kind === "session_pointer" ? "not_applicable" : await inspectProjection(projectRoot, intent.target);
     state[key] = mergeProjectionAvailability(state[key], availability);
   }
   return state;
@@ -15009,12 +15103,20 @@ async function inspectSessionProjection(projectRoot, target) {
   if (task.metadata.revision < target.taskRevision) return "conflict";
   const clearsPointer = workflowRequiresClearedSession(task.metadata);
   if (target.action === "clear") {
-    if (!clearsPointer) return "conflict";
+    if (!clearsPointer) {
+      return task.metadata.revision > target.taskRevision ? "not_applicable" : "conflict";
+    }
     if (session.activeTaskRef === null) return "present";
+    if (task.metadata.status === "planned" && task.metadata.governance.planDecision === "plan_only" && sameTaskRef(session.activeTaskRef, target.taskRef) && session.lastSeenRevision !== null && session.lastSeenRevision >= target.taskRevision) {
+      return "not_applicable";
+    }
     return sameTaskRef(session.activeTaskRef, target.taskRef) ? "missing" : "not_applicable";
   }
   if (clearsPointer) {
     if (session.activeTaskRef === null) return "not_applicable";
+    if (task.metadata.status === "planned" && task.metadata.governance.planDecision === "plan_only" && sameTaskRef(session.activeTaskRef, target.taskRef) && session.lastSeenRevision !== null && session.lastSeenRevision >= task.metadata.revision) {
+      return "not_applicable";
+    }
     return sameTaskRef(session.activeTaskRef, target.taskRef) ? "missing" : "not_applicable";
   }
   if (session.activeTaskRef !== null && sameTaskRef(session.activeTaskRef, target.taskRef)) {
@@ -15035,6 +15137,10 @@ async function applySessionProjection(projectRoot, target, now) {
   if (target.action === "clear" || workflowRequiresClearedSession(task.metadata)) {
     await clearSessionTaskPointer(projectRoot, target.sessionId, {
       expectedTaskRef: target.taskRef,
+      isStillApplicable: async () => {
+        const current = await readProjectionTask(projectRoot, target.taskRef);
+        return current !== null && workflowRequiresClearedSession(current.metadata) && await inspectSessionProjection(projectRoot, target) === "missing";
+      },
       now
     });
     return;
@@ -16636,7 +16742,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-T3IKK3LU.js").then(
+  const actualVersions = await import("./v3-adapter-KA2NOVI5.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -23443,10 +23549,11 @@ function compareUtf89(left, right) {
 
 // src/context/task-head-reconcile.ts
 import { execFile as execFileCallback3 } from "child_process";
-import path39 from "path";
+import path40 from "path";
 import { promisify as promisify3 } from "util";
 
 // src/team/conflicts.ts
+import path39 from "path";
 function deriveClaimValidity(claim, context) {
   assertClaimValidationContext(context);
   if (claim.state !== "active") return "inactive";
@@ -23570,6 +23677,8 @@ function hasPotentialPathIntersection(left, right) {
 }
 function isPathSubsetOf(candidate, boundary) {
   if (candidate === boundary) return true;
+  if (containsComplexGlob(candidate) || containsComplexGlob(boundary))
+    return false;
   const candidatePrefix = staticPathPrefix(candidate);
   const boundaryPrefix = staticPathPrefix(boundary);
   if (!candidatePrefix.startsWith(boundaryPrefix)) return false;
@@ -23578,17 +23687,29 @@ function isPathSubsetOf(candidate, boundary) {
 }
 function globPatternsMayOverlap(left, right) {
   if (left === right) return true;
+  const leftIsGlob = containsGlob(left);
+  const rightIsGlob = containsGlob(right);
+  if (!leftIsGlob && !rightIsGlob) return false;
+  if (!leftIsGlob && !containsComplexGlob(right)) {
+    return path39.posix.matchesGlob(left, right);
+  }
+  if (!rightIsGlob && !containsComplexGlob(left)) {
+    return path39.posix.matchesGlob(right, left);
+  }
   const leftPrefix = staticPathPrefix(left);
   const rightPrefix = staticPathPrefix(right);
   return leftPrefix.startsWith(rightPrefix) || rightPrefix.startsWith(leftPrefix);
 }
 function staticPathPrefix(value) {
-  const wildcard = value.search(/[*!?\[]/);
+  const wildcard = value.search(/[*!?\[\]{}()]/);
   const prefix = wildcard === -1 ? value : value.slice(0, wildcard);
   return prefix.endsWith("/") ? prefix : prefix.slice(0, prefix.lastIndexOf("/") + 1);
 }
 function containsGlob(value) {
-  return /[*!?\[]/.test(value);
+  return /[*!?\[\]{}()]/.test(value);
+}
+function containsComplexGlob(value) {
+  return /[!\[\]{}()]/.test(value);
 }
 function hasIntersection(left, right) {
   return left.some((value) => right.includes(value));
@@ -23871,8 +23992,8 @@ function injectAfterReconcileStep(stepId) {
   throwIfOperationCrashInjected("task_head_reconcile", stepId);
 }
 async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
-  const relativeTaskRoot = path39.relative(projectRoot, taskRoot2);
-  if (!relativeTaskRoot || path39.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path39.sep).some((part) => part === "..")) {
+  const relativeTaskRoot = path40.relative(projectRoot, taskRoot2);
+  if (!relativeTaskRoot || path40.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path40.sep).some((part) => part === "..")) {
     throw new Error("MANCODE_TASK_UNAVAILABLE");
   }
   const authorityFiles = [
@@ -23880,7 +24001,7 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
     "requirements.json",
     "review-ledger.json",
     "verification-ledger.json"
-  ].map((file) => path39.join(relativeTaskRoot, file));
+  ].map((file) => path40.join(relativeTaskRoot, file));
   try {
     await execFile3("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
       cwd: projectRoot,
@@ -24106,11 +24227,11 @@ var BETA_PLATFORMS = [
 
 // src/runtime/retention.ts
 import { lstat as lstat14, readFile as readFile28, readdir as readdir13, rm as rm17 } from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 var TERMINAL_JOURNAL_RETENTION_DAYS = 30;
 var RETAINED_NON_MILESTONE_CHECKPOINTS = 10;
 async function planContextCompaction(input) {
-  const root = path40.resolve(input.projectRoot);
+  const root = path41.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const store = new V3ContextStore(root);
   const [project, runtime] = await Promise.all([
@@ -24170,7 +24291,7 @@ async function planContextCompaction(input) {
 }
 async function planLocalCacheRetention(root, localCacheDays, now) {
   const threshold = now.getTime() - localCacheDays * 864e5;
-  const directory = path40.join(root, ".mancode", "local", "cache");
+  const directory = path41.join(root, ".mancode", "local", "cache");
   const candidates = [];
   for (const target of await listRegularFilesRecursively(directory)) {
     const metadata = await regularFileMetadataOrNull(target);
@@ -24233,7 +24354,7 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
       }
       candidates.push({
         kind: "checkpoint",
-        target: path40.join(
+        target: path41.join(
           task.location.taskRoot,
           "checkpoints",
           `${checkpoint.checkpointId}.json`
@@ -24247,13 +24368,13 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
   return { candidates, skippedReferencedCheckpoints };
 }
 async function planCompletedSessionRetention(root, completedSessionDays, now, protectedSessionIds) {
-  const directory = path40.join(root, ".mancode", "local", "sessions");
+  const directory = path41.join(root, ".mancode", "local", "sessions");
   const entries = await readDirectoryOrEmpty(directory);
   const threshold = now.getTime() - completedSessionDays * 864e5;
   const candidates = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const target = path40.join(directory, entry);
+    const target = path41.join(directory, entry);
     const session = parseSessionState(
       JSON.parse(await readRegularFile(target))
     );
@@ -24280,7 +24401,7 @@ async function planOperationRetention(stores, now) {
     let recoveryEntries = null;
     for (const entry of entries) {
       if (!entry.endsWith(".json")) continue;
-      const target = path40.join(directory, entry);
+      const target = path41.join(directory, entry);
       const journal = parseOperationJournal(
         JSON.parse(await readRegularFile(target))
       );
@@ -24349,7 +24470,7 @@ function operationRecoveryTargetsForRetention(store, journal, recoveryEntries) {
   const discoveredVersions = recoveryEntries.filter((entry) => {
     if (!entry.startsWith(versionPrefix)) return false;
     return /^[a-f0-9]{64}\.json$/.test(entry.slice(versionPrefix.length));
-  }).map((entry) => path40.join(directory, entry));
+  }).map((entry) => path41.join(directory, entry));
   return [
     .../* @__PURE__ */ new Set([
       operationRecoveryPayloadPath(store, journal.operationId),
@@ -24384,7 +24505,7 @@ function taskRefKeyFromEntityKey(entityKey) {
 async function listTaskRefs(root) {
   const refs = [];
   for (const namespace of ["local", "shared"]) {
-    const directory = path40.join(root, ".mancode", namespace, "workflows");
+    const directory = path41.join(root, ".mancode", namespace, "workflows");
     for (const entry of await readDirectoryOrEmpty(directory)) {
       if (!/^[0-9A-HJKMNP-TV-Z]{26}$/.test(entry)) continue;
       refs.push({ namespace, taskId: entry });
@@ -24397,12 +24518,12 @@ async function listTaskRefs(root) {
   );
 }
 async function listTaskCheckpoints(taskRoot2, taskRef) {
-  const directory = path40.join(taskRoot2, "checkpoints");
+  const directory = path41.join(taskRoot2, "checkpoints");
   const checkpoints = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
     if (!entry.endsWith(".json")) continue;
     const checkpoint = parseCheckpoint(
-      JSON.parse(await readRegularFile(path40.join(directory, entry)))
+      JSON.parse(await readRegularFile(path41.join(directory, entry)))
     );
     if (!sameTaskRef(checkpoint.taskRef, taskRef) || entry !== `${checkpoint.checkpointId}.json`) {
       throw new Error("MANCODE_RETENTION_CHECKPOINT_CORRUPT");
@@ -24441,7 +24562,7 @@ async function readDirectoryOrEmpty(directory) {
 async function listRegularFilesRecursively(directory) {
   const files = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
-    const target = path40.join(directory, entry);
+    const target = path41.join(directory, entry);
     const metadata = await lstatOrNull3(target);
     if (metadata === null) continue;
     if (metadata.isSymbolicLink()) {
@@ -24506,7 +24627,7 @@ function isNotFound19(error) {
 
 // src/team/git-ref-cache.ts
 import { lstat as lstat15, mkdir as mkdir26, readFile as readFile29, writeFile as writeFile34 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 var DEFAULT_GIT_REF_FRESHNESS_TTL_MS = 5 * 60 * 1e3;
 async function writeGitRefTeamCache(projectRoot, config, snapshot) {
   const remote = gitRefRemote(config);
@@ -24524,7 +24645,7 @@ async function writeGitRefTeamCache(projectRoot, config, snapshot) {
     await assertCachePrivacyAuthority(projectRoot, cache.manifest);
   const directory = await ensureSafeCacheDirectory(projectRoot);
   const target = gitRefCachePath(projectRoot);
-  const temporary = path41.join(
+  const temporary = path42.join(
     directory,
     `.snapshot.${process.pid}.${Date.now()}.tmp`
   );
@@ -24656,11 +24777,11 @@ function parseGitRefTeamCache(value) {
   };
 }
 function gitRefCachePath(projectRoot) {
-  return path41.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
+  return path42.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
 }
 function gitRefCacheDirectory(projectRoot) {
-  return path41.join(
-    path41.resolve(projectRoot),
+  return path42.join(
+    path42.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -24706,10 +24827,10 @@ function parseReceiptOrNull(value) {
   return value;
 }
 async function ensureSafeCacheDirectory(projectRoot) {
-  const root = path41.resolve(projectRoot);
+  const root = path42.resolve(projectRoot);
   let current = root;
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path41.join(current, segment);
+    current = path42.join(current, segment);
     try {
       await mkdir26(current);
     } catch (error) {
@@ -24720,9 +24841,9 @@ async function ensureSafeCacheDirectory(projectRoot) {
   return current;
 }
 async function assertSafeCacheDirectory(projectRoot) {
-  let current = path41.resolve(projectRoot);
+  let current = path42.resolve(projectRoot);
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path41.join(current, segment);
+    current = path42.join(current, segment);
     await assertDirectoryNotLinked(current);
   }
 }
@@ -24741,7 +24862,7 @@ function isAlreadyExists14(error) {
 
 // src/team/git-ref-workflow-repair.ts
 import { lstat as lstat19, mkdir as mkdir30, readFile as readFile33, readdir as readdir16, writeFile as writeFile38 } from "fs/promises";
-import path45 from "path";
+import path46 from "path";
 
 // src/team/git-ref-materialization.ts
 import {
@@ -24752,12 +24873,12 @@ import {
   unlink as unlink2,
   writeFile as writeFile37
 } from "fs/promises";
-import path44 from "path";
+import path45 from "path";
 
 // src/team/git-ref-bundle.ts
 import { execFile as execFileCallback4 } from "child_process";
 import { lstat as lstat16, mkdir as mkdir27, readFile as readFile30, readdir as readdir14, writeFile as writeFile35 } from "fs/promises";
-import path42 from "path";
+import path43 from "path";
 import { promisify as promisify4 } from "util";
 var execFile4 = promisify4(execFileCallback4);
 function createGitRefTaskBundle(input) {
@@ -24820,7 +24941,7 @@ async function assertGitRefBundleCodeReachable(projectRoot, bundle) {
       "git",
       ["cat-file", "-e", `${parsed.codeRef.head}^{commit}`],
       {
-        cwd: path42.resolve(projectRoot),
+        cwd: path43.resolve(projectRoot),
         windowsHide: true
       }
     );
@@ -24833,8 +24954,8 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsed = parseGitRefTaskBundle(bundle);
-  const directory = path42.join(
-    path42.resolve(projectRoot),
+  const directory = path43.join(
+    path43.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -24850,7 +24971,7 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     parsed.taskRef.taskId,
     String(remoteRevision)
   ]);
-  const target = path42.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
+  const target = path43.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
   try {
     await writeFile35(target, `${JSON.stringify(parsed, null, 2)}
 `, {
@@ -24867,8 +24988,8 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsedTaskRef = parseTaskRefValue(taskRef);
-  const directory = path42.join(
-    path42.resolve(projectRoot),
+  const directory = path43.join(
+    path43.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -24894,7 +25015,7 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
   const matches = [];
   for (const entry of entries.sort()) {
     if (!/^[a-f0-9]{64}\.json$/.test(entry)) continue;
-    const target = path42.join(directory, entry);
+    const target = path43.join(directory, entry);
     const before = await lstat16(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -24931,9 +25052,9 @@ function parseCodeRef(value) {
   return { branch: value.branch, head: value.head };
 }
 async function ensureFixedDirectory(projectRoot, segments) {
-  let current = path42.resolve(projectRoot);
+  let current = path43.resolve(projectRoot);
   for (const segment of segments) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     try {
       await mkdir27(current);
     } catch (error) {
@@ -24946,9 +25067,9 @@ async function ensureFixedDirectory(projectRoot, segments) {
   }
 }
 async function assertFixedDirectory(projectRoot, segments) {
-  let current = path42.resolve(projectRoot);
+  let current = path43.resolve(projectRoot);
   for (const segment of segments) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     const entry = await lstat16(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -24964,7 +25085,7 @@ function isNotFound21(error) {
 
 // src/team/git-ref-task-base.ts
 import { lstat as lstat17, mkdir as mkdir28, readFile as readFile31, writeFile as writeFile36 } from "fs/promises";
-import path43 from "path";
+import path44 from "path";
 async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
   const parsedTaskRef = parseTaskRefValue(taskRef);
   const runtime = await readProjectRuntimeContext(projectRoot);
@@ -25007,7 +25128,7 @@ async function recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle) {
   });
   const directory = await ensureRemoteBaseDirectory(projectRoot);
   const target = remoteBasePath(projectRoot, parsedBundle.taskRef);
-  const temporary = path43.join(
+  const temporary = path44.join(
     directory,
     `.${parsedBundle.taskRef.taskId}.${process.pid}.${Date.now()}.tmp`
   );
@@ -25044,7 +25165,7 @@ function parseGitRefTaskRemoteBase(value) {
   };
 }
 async function ensureRemoteBaseDirectory(projectRoot) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -25052,7 +25173,7 @@ async function ensureRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path43.join(current, segment);
+    current = path44.join(current, segment);
     try {
       await mkdir28(current);
     } catch (error) {
@@ -25066,7 +25187,7 @@ async function ensureRemoteBaseDirectory(projectRoot) {
   return current;
 }
 async function assertRemoteBaseDirectory(projectRoot) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -25074,7 +25195,7 @@ async function assertRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path43.join(current, segment);
+    current = path44.join(current, segment);
     const entry = await lstat17(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -25083,8 +25204,8 @@ async function assertRemoteBaseDirectory(projectRoot) {
 }
 function remoteBasePath(projectRoot, taskRef) {
   const parsed = parseTaskRefValue(taskRef);
-  return path43.join(
-    path43.resolve(projectRoot),
+  return path44.join(
+    path44.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -25108,7 +25229,7 @@ function isNotFound22(error) {
 
 // src/team/git-ref-materialization.ts
 async function materializeGitRefTaskBundle(input) {
-  const projectRoot = path44.resolve(input.projectRoot);
+  const projectRoot = path45.resolve(input.projectRoot);
   const remoteRevision = positiveInteger3(
     input.remoteRevision,
     "git-ref materialization remoteRevision"
@@ -25435,7 +25556,7 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   const target = safeTaskPath(taskRoot2, relativePath2);
   await ensureSafeDirectory(
     taskRoot2,
-    path44.dirname(relativePath2).split(path44.sep)
+    path45.dirname(relativePath2).split(path45.sep)
   );
   const current = await readSafeFileOrNull(target);
   if (contentMatches(relativePath2, current, targetContent)) return;
@@ -25445,9 +25566,9 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath2 !== "summary.md") {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
-  const temporary = path44.join(
-    path44.dirname(target),
-    `.${path44.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path45.join(
+    path45.dirname(target),
+    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile37(temporary, targetContent, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
@@ -25515,13 +25636,13 @@ async function readSafeFileOrNull(target) {
   }
 }
 async function ensureSafeDirectory(root, segments) {
-  let current = path44.resolve(root);
+  let current = path45.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 = path44.join(current, segment);
+    current = path45.join(current, segment);
     try {
       await mkdir29(current);
     } catch (error) {
@@ -25534,9 +25655,9 @@ async function ensureSafeDirectory(root, segments) {
   }
 }
 function safeTaskPath(taskRoot2, relativePath2) {
-  const target = path44.resolve(taskRoot2, relativePath2);
-  const relative = path44.relative(taskRoot2, target);
-  if (!relative || relative.startsWith("..") || path44.isAbsolute(relative)) {
+  const target = path45.resolve(taskRoot2, relativePath2);
+  const relative = path45.relative(taskRoot2, target);
+  if (!relative || relative.startsWith("..") || path45.isAbsolute(relative)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return target;
@@ -25559,8 +25680,8 @@ async function createJournal(projectRoot, journal) {
 }
 async function replaceJournal(projectRoot, journal) {
   const target = journalPath(projectRoot, journal.operationId);
-  const temporary = path44.join(
-    path44.dirname(target),
+  const temporary = path45.join(
+    path45.dirname(target),
     `.${journal.operationId}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile37(temporary, serialize9(journal), {
@@ -25592,7 +25713,7 @@ async function listJournals(projectRoot) {
   const journals = [];
   for (const entry of entries.sort()) {
     if (!entry.endsWith(".json")) continue;
-    journals.push(await readJournal(path44.join(directory, entry)));
+    journals.push(await readJournal(path45.join(directory, entry)));
   }
   return journals;
 }
@@ -25658,8 +25779,8 @@ function result(status2, bundle, localJournalPath, taskHeadFence) {
   };
 }
 function journalDirectory(projectRoot) {
-  return path44.join(
-    path44.resolve(projectRoot),
+  return path45.join(
+    path45.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -25668,7 +25789,7 @@ function journalDirectory(projectRoot) {
 }
 function journalPath(projectRoot, operationId) {
   assertUlid(operationId, "git-ref materialization operationId");
-  return path44.join(journalDirectory(projectRoot), `${operationId}.json`);
+  return path45.join(journalDirectory(projectRoot), `${operationId}.json`);
 }
 function serialize9(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -25704,7 +25825,7 @@ function isNotFound23(error) {
 
 // src/team/git-ref-workflow-repair.ts
 async function prepareGitRefWorkflowRepair(input) {
-  const root = path45.resolve(input.projectRoot);
+  const root = path46.resolve(input.projectRoot);
   const prepared2 = parsePrepared(input.prepared);
   const pendingMetadata = parseWorkflowMetadata(input.pendingMetadata);
   assertPendingMetadata2(prepared2, pendingMetadata);
@@ -25739,7 +25860,7 @@ async function prepareGitRefWorkflowRepair(input) {
 }
 async function recoverGitRefWorkflowRepair(projectRoot, operationId, transportReceipt = null, options = {}) {
   assertUlid(operationId, "git-ref workflow repair operationId");
-  const root = path45.resolve(projectRoot);
+  const root = path46.resolve(projectRoot);
   let journal = await requireJournal(root, operationId);
   await assertRecoveryAuthorized(root, journal, options);
   if (journal.state === "committed" || journal.state === "aborted") {
@@ -26147,7 +26268,7 @@ function metadataFromBundle(bundle) {
   return parseWorkflowMetadata(artifact2.content);
 }
 function metadataPath2(projectRoot, taskRef) {
-  return path45.join(taskRootPath(projectRoot, taskRef), "metadata.json");
+  return path46.join(taskRootPath(projectRoot, taskRef), "metadata.json");
 }
 async function readSafeFile(target) {
   const before = await lstat19(target);
@@ -26162,17 +26283,17 @@ async function readSafeFile(target) {
   return content;
 }
 async function atomicWrite(target, content) {
-  const temporary = path45.join(
-    path45.dirname(target),
-    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path46.join(
+    path46.dirname(target),
+    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile38(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory(projectRoot) {
-  let current = path45.resolve(projectRoot);
+  let current = path46.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-workflow"]) {
-    current = path45.join(current, segment);
+    current = path46.join(current, segment);
     try {
       await mkdir30(current);
     } catch (error) {
@@ -27017,7 +27138,7 @@ function parseExpectedRevision2(value) {
 
 // src/commands/design.ts
 import { readFile as readFile35, stat as stat4 } from "fs/promises";
-import path47 from "path";
+import path48 from "path";
 import process2 from "process";
 
 // src/context/design-policy.ts
@@ -27029,7 +27150,7 @@ import {
   rm as rm18,
   writeFile as writeFile39
 } from "fs/promises";
-import path46 from "path";
+import path47 from "path";
 var DEFAULT_DESIGN_POLICY = {
   schemaVersion: 1,
   revision: 0,
@@ -27043,8 +27164,8 @@ var DEFAULT_DESIGN_POLICY = {
   updatedAt: "1970-01-01T00:00:00.000Z"
 };
 function designPolicyPath(projectRoot) {
-  return path46.join(
-    path46.resolve(projectRoot),
+  return path47.join(
+    path47.resolve(projectRoot),
     ".mancode",
     "shared",
     "context",
@@ -27132,7 +27253,7 @@ async function configureDesignPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   assertUlid(operationId, "design policy operationId");
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path46.resolve(input.projectRoot);
+  const root = path47.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -27188,10 +27309,10 @@ function isDesignBrowserValidation(value) {
 }
 async function writeDesignPolicy(projectRoot, policy) {
   const target = designPolicyPath(projectRoot);
-  await mkdir31(path46.dirname(target), { recursive: true });
-  const temporary = path46.join(
-    path46.dirname(target),
-    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  await mkdir31(path47.dirname(target), { recursive: true });
+  const temporary = path47.join(
+    path47.dirname(target),
+    `.${path47.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile39(temporary, `${JSON.stringify(policy, null, 2)}
 `, {
@@ -27205,13 +27326,13 @@ async function writeDesignPolicy(projectRoot, policy) {
   }
 }
 async function assertDesignPolicyPathSafe(projectRoot) {
-  const root = path46.resolve(projectRoot);
+  const root = path47.resolve(projectRoot);
   const policyPath = designPolicyPath(root);
-  const contextDir = path46.dirname(policyPath);
+  const contextDir = path47.dirname(policyPath);
   try {
     for (const directory of [
-      path46.join(root, ".mancode"),
-      path46.join(root, ".mancode", "shared"),
+      path47.join(root, ".mancode"),
+      path47.join(root, ".mancode", "shared"),
       contextDir
     ]) {
       const info = await lstat20(directory);
@@ -27223,8 +27344,8 @@ async function assertDesignPolicyPathSafe(projectRoot) {
       realpath2(root),
       realpath2(contextDir)
     ]);
-    const relative = path46.relative(resolvedRoot, resolvedContextDir);
-    if (path46.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path46.sep}`)) {
+    const relative = path47.relative(resolvedRoot, resolvedContextDir);
+    if (path47.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path47.sep}`)) {
       throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
     }
     try {
@@ -27479,7 +27600,7 @@ async function readProfile(rootDir, kind) {
   try {
     return JSON.parse(
       await readFile35(
-        path47.join(rootDir, ".mancode", "project-profile.json"),
+        path48.join(rootDir, ".mancode", "project-profile.json"),
         "utf8"
       )
     );
@@ -27488,7 +27609,7 @@ async function readProfile(rootDir, kind) {
   }
 }
 async function readStyleSummary(rootDir, kind) {
-  const cachePath = kind === "continuity" ? path47.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path47.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
+  const cachePath = kind === "continuity" ? path48.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path48.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
   try {
     const raw = JSON.parse(await readFile35(cachePath, "utf8"));
     return sanitizeStyleSummary(rootDir, raw);
@@ -27529,7 +27650,7 @@ async function styleFreshness(rootDir, scopeRoot, lastScanned, sourceFiles) {
   const scannedAt = Date.parse(lastScanned);
   for (const file of sourceFiles) {
     try {
-      const info = await stat4(path47.resolve(rootDir, scopeRoot, file));
+      const info = await stat4(path48.resolve(rootDir, scopeRoot, file));
       if (info.mtimeMs > scannedAt) return "stale";
     } catch {
       return "stale";
@@ -27606,10 +27727,10 @@ function emptyStyleSummary() {
   };
 }
 async function initializedKind(rootDir) {
-  if (await exists(path47.join(rootDir, ".mancode", "schema.json"))) {
+  if (await exists(path48.join(rootDir, ".mancode", "schema.json"))) {
     return "continuity";
   }
-  if (await exists(path47.join(rootDir, ".mancode", "state.json")))
+  if (await exists(path48.join(rootDir, ".mancode", "state.json")))
     return "legacy";
   return null;
 }
@@ -27674,7 +27795,7 @@ function safeShortText(value) {
   return typeof value === "string" && value.length <= 100 && /^[A-Za-z0-9@/_. -]+$/.test(value) ? value : null;
 }
 function isSafeRelativeFile(value) {
-  return value.length <= 240 && !path47.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
+  return value.length <= 240 && !path48.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
 }
 function parseNonNegativeInteger2(value) {
   if (value === void 0 || !/^\d+$/.test(value)) return null;
@@ -27682,7 +27803,7 @@ function parseNonNegativeInteger2(value) {
   return Number.isSafeInteger(parsed) ? parsed : null;
 }
 function relativePath(rootDir, target) {
-  return path47.relative(path47.resolve(rootDir), target).split(path47.sep).join("/");
+  return path48.relative(path48.resolve(rootDir), target).split(path48.sep).join("/");
 }
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -27715,12 +27836,12 @@ function errorCode3(error, fallback) {
 import { randomUUID } from "crypto";
 import { promises as fs4 } from "fs";
 import os from "os";
-import path53 from "path";
+import path54 from "path";
 import process6 from "process";
 
 // src/installers/platform-status.ts
 import { promises as fs } from "fs";
-import path48 from "path";
+import path49 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -27737,13 +27858,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path48.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path49.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path48.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path48.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path49.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path49.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -27759,7 +27880,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path48.join(rootDir, ".cursor", "rules", file)
+        (file) => path49.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -27774,13 +27895,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path48.join(rootDir, ".cursor", "rules", file)
+          (file) => path49.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path48.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path49.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -27793,7 +27914,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path48.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path49.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -27810,9 +27931,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -27824,7 +27945,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -27844,9 +27965,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -27858,7 +27979,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "kimi-code") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       KIMI_MANCODE_START_MARKER,
       KIMI_MANCODE_END_MARKER
     );
@@ -27878,9 +27999,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -27892,7 +28013,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "qoder") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       QODER_MANCODE_START_MARKER,
       QODER_MANCODE_END_MARKER
     );
@@ -27912,9 +28033,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const commandsDir = path48.join(rootDir, ".qoder", "commands");
+    const commandsDir = path49.join(rootDir, ".qoder", "commands");
     const hasCommands = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(commandsDir, `${mode}.md`)),
+      MODE_NAMES.map((mode) => path49.join(commandsDir, `${mode}.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -27926,7 +28047,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "dsh") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       DSH_MANCODE_START_MARKER,
       DSH_MANCODE_END_MARKER
     );
@@ -27946,9 +28067,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".dsh", "skills");
+    const skillsDir = path49.join(rootDir, ".dsh", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_DSH_SKILL_MARKERS
     );
     return {
@@ -27959,7 +28080,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path48.join(rootDir, ".github", "copilot-instructions.md")
+    path49.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -27970,9 +28091,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path48.join(rootDir, ".github", "prompts");
+    const promptsDir = path49.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path49.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -28005,13 +28126,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path48.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path49.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path48.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path49.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -28039,7 +28160,7 @@ async function fileHasAnyMarker(filePath, needles) {
 async function isPlatformMinimal(rootDir, platform) {
   try {
     const raw = await fs.readFile(
-      path48.join(rootDir, ".mancode", "config.json"),
+      path49.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -28061,7 +28182,7 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs.readFile(
-      path48.join(rootDir, ".claude", "settings.json"),
+      path49.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -28104,7 +28225,7 @@ function isRecord7(value) {
 // src/system/detect-team.ts
 import { execFile as execFile5 } from "child_process";
 import { access as access2 } from "fs/promises";
-import path49 from "path";
+import path50 from "path";
 import process3 from "process";
 import { promisify as promisify5 } from "util";
 var execFileAsync = promisify5(execFile5);
@@ -28214,7 +28335,7 @@ async function anyPathExists(projectRoot, candidates) {
   const results = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access2(path49.join(projectRoot, candidate));
+        await access2(path50.join(projectRoot, candidate));
         return true;
       } catch {
         return false;
@@ -28255,7 +28376,7 @@ async function detectSystemDeps(env = process4.env) {
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
 import { promises as fs2 } from "fs";
-import path50 from "path";
+import path51 from "path";
 import process5 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -28361,7 +28482,7 @@ async function detectPlatformHints(rootDir, environment = process5.env) {
   if (environment.DSH_SHELL === "1") hints.add("dsh");
   const exists2 = async (relative) => {
     try {
-      await fs2.access(path50.join(rootDir, relative));
+      await fs2.access(path51.join(rootDir, relative));
       return true;
     } catch {
       return false;
@@ -28511,7 +28632,7 @@ function createTerminalPrompter() {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs3 } from "fs";
-import path51 from "path";
+import path52 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
@@ -28547,7 +28668,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists5(path51.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists5(path52.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -28573,7 +28694,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path51.join(projectRoot, name);
+    const absPath = path52.join(projectRoot, name);
     if (await pathExists5(absPath)) {
       return { absPath, relPath: name };
     }
@@ -28800,7 +28921,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path51.join(projectRoot, relRoot);
+    const absRoot = path52.join(projectRoot, relRoot);
     if (!await pathExists5(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -28820,7 +28941,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path51.join(dir, entry);
+    const abs = path52.join(dir, entry);
     let info;
     try {
       info = await fs3.lstat(abs);
@@ -28841,7 +28962,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path51.basename(dir);
+      base = path52.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -28863,7 +28984,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path51.join(projectRoot, relPath);
+    const absPath = path52.join(projectRoot, relPath);
     if (!await pathExists5(absPath)) continue;
     const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -28909,7 +29030,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs3.readFile(
-      path51.join(projectRoot, "package.json"),
+      path52.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -28941,8 +29062,8 @@ import {
   rm as rm19,
   writeFile as writeFile40
 } from "fs/promises";
-import path52 from "path";
-var JOURNAL_RELATIVE_DIRECTORY = path52.join(
+import path53 from "path";
+var JOURNAL_RELATIVE_DIRECTORY = path53.join(
   "local",
   "runtime",
   "initialization"
@@ -28997,7 +29118,7 @@ async function stageGreenfieldInitialization(input) {
     operationId: normalized.operationId,
     workspaceId: normalized.workspaceId,
     state: "staged",
-    stagingDirectoryName: path52.basename(stagingRoot),
+    stagingDirectoryName: path53.basename(stagingRoot),
     targetDirectoryName: ".mancode",
     manifestDigest: digestCanonicalJson(manifest),
     configDigest: digestCanonicalJson(config),
@@ -29030,7 +29151,7 @@ async function stageGreenfieldInitialization(input) {
   return journal;
 }
 async function publishGreenfieldInitialization(input) {
-  const root = path52.resolve(input.projectRoot);
+  const root = path53.resolve(input.projectRoot);
   assertUlid(input.operationId, "greenfield operationId");
   const stagingRoot = greenfieldStagingPath(root, input.operationId);
   const targetRoot = greenfieldTargetPath(root);
@@ -29065,10 +29186,10 @@ async function initializeGreenfield(input, publication) {
 }
 function greenfieldStagingPath(projectRoot, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path52.join(path52.resolve(projectRoot), `.mancode.init-${operationId}`);
+  return path53.join(path53.resolve(projectRoot), `.mancode.init-${operationId}`);
 }
 function greenfieldTargetPath(projectRoot) {
-  return path52.join(path52.resolve(projectRoot), ".mancode");
+  return path53.join(path53.resolve(projectRoot), ".mancode");
 }
 function parseGreenfieldInitializationJournal(value) {
   assertRecord(value, "greenfield initialization journal");
@@ -29211,7 +29332,7 @@ async function finishPublishedInitialization(input, stagedJournal) {
     activatedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
   };
   assertSchemaManifestTransition(manifest, activeManifest);
-  await writeJson(path52.join(targetRoot, "schema.json"), activeManifest);
+  await writeJson(path53.join(targetRoot, "schema.json"), activeManifest);
   throwIfOperationCrashInjected(
     "greenfield_initialize",
     "activate-v3-manifest"
@@ -29227,55 +29348,55 @@ async function finishPublishedInitialization(input, stagedJournal) {
 }
 async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, projectFacts, journal, privacy) {
   await Promise.all([
-    mkdir32(path52.join(stagingRoot, "shared", "context"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, "shared", "memory", "decisions"), {
+    mkdir32(path53.join(stagingRoot, "shared", "context"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, "shared", "memory", "decisions"), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "shared", "team", "actors"), {
+    mkdir32(path53.join(stagingRoot, "shared", "team", "actors"), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "shared", "team", "handoffs"), {
+    mkdir32(path53.join(stagingRoot, "shared", "team", "handoffs"), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "shared", "team", "events"), {
+    mkdir32(path53.join(stagingRoot, "shared", "team", "events"), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "shared", "team", "transport"), {
+    mkdir32(path53.join(stagingRoot, "shared", "team", "transport"), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "local", "sessions"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
+    mkdir32(path53.join(stagingRoot, "local", "sessions"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
       recursive: true
     }),
-    mkdir32(path52.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, "local", "quarantine"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, "local", "publish"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, "local", "cache"), { recursive: true }),
-    mkdir32(path52.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
+    mkdir32(path53.join(stagingRoot, "local", "workflows"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, "local", "quarantine"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, "local", "publish"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, "local", "cache"), { recursive: true }),
+    mkdir32(path53.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
       recursive: true
     })
   ]);
   await Promise.all([
-    writeJson(path52.join(stagingRoot, "schema.json"), manifest),
-    writeJson(path52.join(stagingRoot, "shared", "config.json"), config),
-    writeJson(path52.join(stagingRoot, "shared", "team", "policy.json"), policy),
+    writeJson(path53.join(stagingRoot, "schema.json"), manifest),
+    writeJson(path53.join(stagingRoot, "shared", "config.json"), config),
+    writeJson(path53.join(stagingRoot, "shared", "team", "policy.json"), policy),
     writeJson(
-      path52.join(stagingRoot, "shared", "context", "project.json"),
+      path53.join(stagingRoot, "shared", "context", "project.json"),
       projectFacts
     ),
     writeJson(journalPath2(stagingRoot, journal.operationId), journal),
     ...privacy === null ? [] : [
       writeJson(
-        path52.join(stagingRoot, PRIVACY_POLICY_FILE),
+        path53.join(stagingRoot, PRIVACY_POLICY_FILE),
         privacy.policy
       ),
       writeJson(
-        path52.join(stagingRoot, PRIVACY_EXCLUSIONS_FILE),
+        path53.join(stagingRoot, PRIVACY_EXCLUSIONS_FILE),
         privacy.exclusions
       )
     ],
     writeFile40(
-      path52.join(stagingRoot, ".gitignore"),
+      path53.join(stagingRoot, ".gitignore"),
       `${V3_IGNORE.join("\n")}
 `,
       { encoding: "utf8", flag: "wx" }
@@ -29300,7 +29421,7 @@ async function readGreenfieldJournal(root, operationId) {
 async function readManifest(root) {
   try {
     return parseSchemaManifest(
-      JSON.parse(await readFile36(path52.join(root, "schema.json"), "utf8"))
+      JSON.parse(await readFile36(path53.join(root, "schema.json"), "utf8"))
     );
   } catch (error) {
     if (error instanceof SyntaxError || isNotFound26(error)) {
@@ -29332,11 +29453,11 @@ async function assertPrivacyMatchesJournal(root, manifest, journal) {
   if (manifest.manifestVersion !== 3)
     throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
   const policy = parsePrivacyPolicy(
-    JSON.parse(await readFile36(path52.join(root, PRIVACY_POLICY_FILE), "utf8"))
+    JSON.parse(await readFile36(path53.join(root, PRIVACY_POLICY_FILE), "utf8"))
   );
   const exclusions = parsePrivacyExclusions(
     JSON.parse(
-      await readFile36(path52.join(root, PRIVACY_EXCLUSIONS_FILE), "utf8")
+      await readFile36(path53.join(root, PRIVACY_EXCLUSIONS_FILE), "utf8")
     )
   );
   if (digestCanonicalJson(policy) !== journal.privacyPolicyDigest || manifest.privacyPolicy.digest !== journal.privacyPolicyDigest || manifest.privacyPolicy.revision !== policy.revision || policy.workspaceId !== journal.workspaceId || exclusions.workspaceId !== journal.workspaceId || policy.exclusions.revision !== exclusions.revision || policy.exclusions.digest !== digestCanonicalJson(exclusions))
@@ -29358,7 +29479,7 @@ async function readConfig(root) {
   try {
     config = parseProjectConfig(
       JSON.parse(
-        await readFile36(path52.join(root, "shared", "config.json"), "utf8")
+        await readFile36(path53.join(root, "shared", "config.json"), "utf8")
       )
     );
   } catch (error) {
@@ -29375,7 +29496,7 @@ async function readPolicy(root) {
     policy = parseTeamPolicy(
       JSON.parse(
         await readFile36(
-          path52.join(root, "shared", "team", "policy.json"),
+          path53.join(root, "shared", "team", "policy.json"),
           "utf8"
         )
       )
@@ -29393,7 +29514,7 @@ async function readProjectFactsAt(root) {
     return parseProjectFacts(
       JSON.parse(
         await readFile36(
-          path52.join(root, "shared", "context", "project.json"),
+          path53.join(root, "shared", "context", "project.json"),
           "utf8"
         )
       )
@@ -29436,7 +29557,7 @@ function normalizeInput(input) {
   parseSchemaManifest(manifest);
   return {
     ...input,
-    projectRoot: path52.resolve(input.projectRoot),
+    projectRoot: path53.resolve(input.projectRoot),
     projectConfig: config,
     teamPolicy: policy,
     projectFacts: input.projectFacts === void 0 ? void 0 : parseProjectFacts(input.projectFacts)
@@ -29518,7 +29639,7 @@ function isAdapterRelativePathArray(value) {
     (item) => typeof item === "string"
   );
   return paths.length === value.length && new Set(paths).size === paths.length && paths.every(
-    (item) => item.trim() === item && item.length > 0 && !item.includes("\0") && !path52.isAbsolute(item) && !/^[A-Za-z]:[\\/]/u.test(item) && !item.split(/[\\/]/u).some((segment) => segment === ".." || !segment)
+    (item) => item.trim() === item && item.length > 0 && !item.includes("\0") && !path53.isAbsolute(item) && !/^[A-Za-z]:[\\/]/u.test(item) && !item.split(/[\\/]/u).some((segment) => segment === ".." || !segment)
   );
 }
 function isAdapterLinkIdentityArray(value) {
@@ -29576,14 +29697,14 @@ function initializationProjectFacts(input, now) {
 }
 function journalPath2(root, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path52.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
+  return path53.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
 }
 async function writeJson(target, value) {
-  const directory = path52.dirname(target);
+  const directory = path53.dirname(target);
   await mkdir32(directory, { recursive: true });
-  const temporary = path52.join(
+  const temporary = path53.join(
     directory,
-    `.${path52.basename(target)}.${process.pid}.${Date.now()}.tmp`
+    `.${path53.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile40(temporary, `${JSON.stringify(value, null, 2)}
 `, {
@@ -29704,9 +29825,9 @@ async function init(rootDir = process6.cwd(), options = {}) {
     return EXIT_INIT_FAILED;
   }
   const authority = resolveInitAuthority(options);
-  const mancodeDir = path53.join(rootDir, ".mancode");
-  const stateFile = path53.join(mancodeDir, "state.json");
-  const v3SchemaFile = path53.join(mancodeDir, "schema.json");
+  const mancodeDir = path54.join(rootDir, ".mancode");
+  const stateFile = path54.join(mancodeDir, "state.json");
+  const v3SchemaFile = path54.join(mancodeDir, "schema.json");
   const wasInitialized = await pathExists6(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
@@ -29785,7 +29906,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
     printNotProjectDirectory(rootDir, locale, "unsafe");
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  const isGitRepo = await pathExists6(path53.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
   const hasEvidence = await hasProjectEvidence(rootDir);
   let isGenericProject = false;
   if (!isGitRepo && !hasEvidence) {
@@ -29902,8 +30023,8 @@ async function init(rootDir = process6.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path53.join(mancodeDir, "workflows"),
-      path53.join(mancodeDir, "preseason-reports")
+      path54.join(mancodeDir, "workflows"),
+      path54.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
     const platformMinimal = Object.fromEntries(
@@ -29964,7 +30085,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
 `;
     await fs4.writeFile(stateFile, stateContent, "utf-8");
     await fs4.writeFile(
-      path53.join(mancodeDir, "project-profile.json"),
+      path54.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -30001,7 +30122,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path53.join(
+      const tokensPath = path54.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -30165,7 +30286,7 @@ async function initializeV3(rootDir, options) {
     );
     return EXIT_INIT_FAILED;
   }
-  const schemaPath = path53.join(rootDir, ".mancode", "schema.json");
+  const schemaPath = path54.join(rootDir, ".mancode", "schema.json");
   let existingV3 = false;
   let registeredAdapters = /* @__PURE__ */ new Set();
   if (await pathExists6(schemaPath)) {
@@ -30309,7 +30430,7 @@ async function initializeV3(rootDir, options) {
   } catch (error) {
     if (scratchBackup !== null) {
       console.error(
-        `   Previous .mancode scratch was preserved at ${path53.relative(rootDir, scratchBackup)}.`
+        `   Previous .mancode scratch was preserved at ${path54.relative(rootDir, scratchBackup)}.`
       );
     }
     printV3InitError(error);
@@ -30335,7 +30456,7 @@ async function resolveUnsafeInitAdapterPaths(rootDir, options, selectedPlatforms
   if (fixable.length === 0) return null;
   const writeThroughAvailable = found.length > 0 && (await Promise.all(
     found.map(
-      (entry) => writeThroughResolvedPath(path53.resolve(rootDir), entry.target)
+      (entry) => writeThroughResolvedPath(path54.resolve(rootDir), entry.target)
     )
   )).every((resolved) => resolved !== null);
   const choice = await prompter.resolveUnsafeAdapterPaths({
@@ -30364,7 +30485,7 @@ async function resolveScratchMancodeTarget(rootDir, options) {
   if (!inspection.v3ScratchOnly) {
     return { exit: null, backupPath: null };
   }
-  const mancodeRoot = path53.join(rootDir, ".mancode");
+  const mancodeRoot = path54.join(rootDir, ".mancode");
   if (inspection.v3TargetEntries.length === 0) {
     await fs4.rmdir(mancodeRoot);
     console.log(
@@ -30387,39 +30508,39 @@ async function resolveScratchMancodeTarget(rootDir, options) {
     );
     return { exit: EXIT_USER_CANCEL, backupPath: null };
   }
-  const backupPath = path53.join(
+  const backupPath = path54.join(
     rootDir,
     `${SCRATCH_BACKUP_PREFIX}${randomUUID()}`
   );
   await fs4.rename(mancodeRoot, backupPath);
   console.log(
-    `\u2139\uFE0F  Moved non-Continuity .mancode scratch aside: ${path53.relative(rootDir, backupPath)}`
+    `\u2139\uFE0F  Moved non-Continuity .mancode scratch aside: ${path54.relative(rootDir, backupPath)}`
   );
   return { exit: null, backupPath };
 }
 async function restoreScratchBackup(rootDir, backupPath) {
-  const localTarget = path53.join(rootDir, ".mancode", "local");
-  const leftover = path53.relative(rootDir, backupPath);
+  const localTarget = path54.join(rootDir, ".mancode", "local");
+  const leftover = path54.relative(rootDir, backupPath);
   try {
     await fs4.mkdir(localTarget, { recursive: true });
     const entries = await fs4.readdir(backupPath, { withFileTypes: true });
     for (const entry of entries) {
-      const source = path53.join(backupPath, entry.name);
+      const source = path54.join(backupPath, entry.name);
       if (entry.isDirectory() && entry.name === "local") {
         for (const child of await fs4.readdir(source)) {
-          const destination = path53.join(localTarget, child);
+          const destination = path54.join(localTarget, child);
           if (await pathExists6(destination)) continue;
-          await fs4.rename(path53.join(source, child), destination);
+          await fs4.rename(path54.join(source, child), destination);
         }
       } else {
-        const preinitScratch = path53.join(localTarget, "preinit-scratch");
+        const preinitScratch = path54.join(localTarget, "preinit-scratch");
         await fs4.mkdir(preinitScratch, { recursive: true });
-        const destination = path53.join(preinitScratch, entry.name);
+        const destination = path54.join(preinitScratch, entry.name);
         if (await pathExists6(destination)) continue;
         await fs4.rename(source, destination);
       }
     }
-    await fs4.rmdir(path53.join(backupPath, "local")).catch(() => void 0);
+    await fs4.rmdir(path54.join(backupPath, "local")).catch(() => void 0);
     await fs4.rmdir(backupPath).catch(() => void 0);
     if (await pathExists6(backupPath)) {
       console.warn(
@@ -30460,7 +30581,7 @@ function printV3InitError(error) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path53.join(mancodeDir, "config.json");
+  const configPath = path54.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
@@ -30493,7 +30614,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs4.readFile(path53.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path54.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {
       platforms: Array.isArray(config.platforms) ? config.platforms.filter(
@@ -30558,8 +30679,8 @@ async function selectInitPlatforms(input) {
   return [DEFAULT_INIT_PLATFORM];
 }
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path53.resolve(rootDir);
-  if (resolved === path53.parse(resolved).root || resolved === path53.resolve(os.homedir())) {
+  const resolved = path54.resolve(rootDir);
+  if (resolved === path54.parse(resolved).root || resolved === path54.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
@@ -30578,7 +30699,7 @@ async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInit
     printNotProjectDirectory(rootDir, locale, "unsafe");
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  const isGitRepo = await pathExists6(path53.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
   const hasEvidence = await hasProjectEvidence(rootDir);
   if (isGitRepo || hasEvidence) return null;
   const inspection = await inspectMancodeLayout(rootDir);
@@ -30724,7 +30845,7 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path53.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path54.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
@@ -30743,10 +30864,10 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path53.dirname(filePath);
-    while (current !== path53.dirname(current)) {
+    let current = path54.dirname(filePath);
+    while (current !== path54.dirname(current)) {
       directories.add(current);
-      current = path53.dirname(current);
+      current = path54.dirname(current);
     }
   }
   return Promise.all(
@@ -30762,7 +30883,7 @@ async function restoreFiles(snapshots) {
       await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs4.mkdir(path53.dirname(snapshot.filePath), { recursive: true });
+    await fs4.mkdir(path54.dirname(snapshot.filePath), { recursive: true });
     await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
@@ -30846,15 +30967,15 @@ async function pathExists6(p) {
 
 // src/commands/install.ts
 import { promises as fs5 } from "fs";
-import path54 from "path";
+import path55 from "path";
 import process7 from "process";
 var EXIT_OK3 = 0;
 var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
 async function install(rootDir = process7.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path54.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path54.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path55.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path55.join(rootDir, ".mancode", "schema.json");
   if (await pathExists7(v3SchemaFile)) {
     return installV3(rootDir, platform, options);
   }
@@ -31015,7 +31136,7 @@ function printUnsupportedPlatform(platform) {
   }
 }
 async function readConfig2(rootDir) {
-  const configPath = path54.join(rootDir, ".mancode", "config.json");
+  const configPath = path55.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
@@ -31030,7 +31151,7 @@ function isNodeError8(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path54.join(rootDir, ".mancode", "config.json");
+  const configPath = path55.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs5.writeFile(configPath, content, "utf-8");
@@ -31066,7 +31187,7 @@ function readConfiguredMinimal(value, platform) {
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path54.join(rootDir, ".mancode", "state.json"),
+      path55.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -31089,11 +31210,11 @@ function isRecord9(value) {
 
 // src/commands/list-platforms.ts
 import { promises as fs6 } from "fs";
-import path55 from "path";
+import path56 from "path";
 import process8 from "process";
 var EXIT_OK4 = 0;
 async function listPlatforms(rootDir = process8.cwd()) {
-  if (await pathExists8(path55.join(rootDir, ".mancode", "schema.json"))) {
+  if (await pathExists8(path56.join(rootDir, ".mancode", "schema.json"))) {
     return listV3Platforms(rootDir);
   }
   const installed = new Set(await readInstalledPlatforms(rootDir));
@@ -31129,7 +31250,7 @@ async function listV3Platforms(rootDir) {
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path55.join(rootDir, ".mancode", "config.json"),
+      path56.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -31162,7 +31283,7 @@ function describePlatform(platform) {
 
 // src/commands/manps.ts
 import { access as access4, readFile as readFile38 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
@@ -31178,7 +31299,7 @@ import {
   rename as rename10,
   writeFile as writeFile41
 } from "fs/promises";
-import path56 from "path";
+import path57 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -31258,10 +31379,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 ?? path56.join(projectRoot, ".mancode");
-  const reportDir = path56.join(storageRoot, "preseason-reports");
+  const storageRoot = options.storageRoot ?? path57.join(projectRoot, ".mancode");
+  const reportDir = path57.join(storageRoot, "preseason-reports");
   await mkdir33(reportDir, { recursive: true });
-  const issueDbPath = path56.join(storageRoot, "preseason-issues.json");
+  const issueDbPath = path57.join(storageRoot, "preseason-issues.json");
   const reportPath = await allocateReportPath(
     reportDir,
     `${generatedAt.replace(/[:.]/g, "-")}-${normalizedArea}`
@@ -31277,7 +31398,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   const database = await buildIssueDatabase(projectRoot, report);
   await writeFile41(reportPath, renderPreseasonReport(report), "utf-8");
   await writeFile41(
-    path56.join(storageRoot, "preseason-report.md"),
+    path57.join(storageRoot, "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -31285,7 +31406,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = options.issueDbPath ?? path56.join(projectRoot, ".mancode", "preseason-issues.json");
+  const issueDbPath = options.issueDbPath ?? path57.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(
@@ -31395,7 +31516,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 = path56.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path57.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -31444,8 +31565,8 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path56.join(current, entry);
-    const rel = path56.relative(root, abs);
+    const abs = path57.join(current, entry);
+    const rel = path57.relative(root, abs);
     let info;
     try {
       info = await lstat22(abs);
@@ -31455,7 +31576,7 @@ async function walk(root, current, results, depth) {
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path56.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path57.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -31463,7 +31584,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile37(path56.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile37(path57.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -31556,7 +31677,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path56.join(projectRoot, file);
+    const abs = path57.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -31597,7 +31718,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 = path56.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path57.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -31606,13 +31727,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path56.basename(file)}.`,
+    detail: `No matching test file was found for ${path57.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(path56.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path57.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -31623,7 +31744,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path56.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path57.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -31642,7 +31763,7 @@ function scanAestheticDrift(projectRoot, files, pkg) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path56.join(projectRoot, file));
+      content = readFileSyncSafe(path57.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -31693,7 +31814,7 @@ function detectedIconSystems(pkg) {
   return systems.filter(([, pattern]) => packages.some((name) => pattern.test(name))).map(([name]) => name);
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path56.join(
+  const localBinary = path57.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -31741,7 +31862,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists9(path56.join(projectRoot, file)))
+    files.map((file) => pathExists9(path57.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -31847,9 +31968,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path56.relative(projectRoot, report.reportPath);
+  const reportRef = path57.relative(projectRoot, report.reportPath);
   const run = {
-    id: path56.basename(report.reportPath, ".md"),
+    id: path57.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -31955,7 +32076,7 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path56.join(projectRoot, ".gitignore");
+    const gitignorePath = path57.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
@@ -31964,7 +32085,7 @@ async function applySafeRemediation(projectRoot, issue) {
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path56.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path57.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
@@ -32004,7 +32125,7 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path56.join(projectRoot, "package.json");
+  const packagePath = path57.join(projectRoot, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile37(packagePath, "utf-8"));
@@ -32117,7 +32238,7 @@ var EXIT_NOT_INITIALIZED3 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  const v3SchemaPath = path57.join(rootDir, ".mancode", "schema.json");
+  const v3SchemaPath = path58.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}`;
@@ -32130,7 +32251,7 @@ async function manps(rootDir, area = "all", options = {}) {
     return EXIT_SCAN_FAILED;
   }
   const v3Initialized = v3Activation === "v3_active";
-  const initialized = v3Initialized || await pathExists10(path57.join(rootDir, ".mancode", "state.json"));
+  const initialized = v3Initialized || await pathExists10(path58.join(rootDir, ".mancode", "state.json"));
   if (!initialized) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
@@ -32143,7 +32264,7 @@ async function manps(rootDir, area = "all", options = {}) {
   let report;
   try {
     report = await runPreseasonScan(rootDir, area, {
-      storageRoot: v3Initialized ? path57.join(rootDir, ".mancode", "local") : void 0
+      storageRoot: v3Initialized ? path58.join(rootDir, ".mancode", "local") : void 0
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -32212,8 +32333,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path57.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path57.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path58.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path58.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -32229,7 +32350,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path57.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path58.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK5;
@@ -32300,7 +32421,7 @@ async function readV3ActivationState(schemaPath) {
 
 // src/commands/migrate.ts
 import { readFile as readFile39 } from "fs/promises";
-import path58 from "path";
+import path59 from "path";
 var EXIT_OK6 = 0;
 var EXIT_INVALID_ARG2 = 2;
 var EXIT_MIGRATION_BLOCKED = 3;
@@ -32453,9 +32574,9 @@ async function readScopeFile(rootDir, file) {
   if (!file.trim() || file.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
-  const resolved = path58.resolve(rootDir, file);
-  const relative = path58.relative(path58.resolve(rootDir), resolved);
-  if (relative === ".." || relative.startsWith(`..${path58.sep}`) || path58.isAbsolute(relative)) {
+  const resolved = path59.resolve(rootDir, file);
+  const relative = path59.relative(path59.resolve(rootDir), resolved);
+  if (relative === ".." || relative.startsWith(`..${path59.sep}`) || path59.isAbsolute(relative)) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
   try {
@@ -32574,7 +32695,7 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
 // src/commands/privacy.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { constants, promises as fs7 } from "fs";
-import path61 from "path";
+import path62 from "path";
 
 // src/privacy/redact.ts
 function mergeSensitiveSpans(findings) {
@@ -32623,11 +32744,11 @@ function redactSensitiveText(value, ruleIds) {
 
 // src/commands/privacy-policy.ts
 import { lstat as lstat24, readFile as readFile40 } from "fs/promises";
-import path60 from "path";
+import path61 from "path";
 
 // src/context/privacy-policy-operation.ts
 import { lstat as lstat23, rm as rm20, writeFile as writeFile42 } from "fs/promises";
-import path59 from "path";
+import path60 from "path";
 var OPERATION = "privacy_policy_update";
 async function readPrivacyPolicyOperationTarget(root, operationId) {
   const runtime = await readProjectRuntimeContext(root);
@@ -32690,7 +32811,7 @@ async function previewPrivacyPolicyUpdate(input) {
   };
 }
 async function updatePrivacyPolicy(input) {
-  const root = path59.resolve(input.projectRoot);
+  const root = path60.resolve(input.projectRoot);
   const candidate = parsePrivacyPolicyCandidate(input.candidate);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId ?? createUlid(now.getTime());
@@ -33030,15 +33151,15 @@ async function optionalContent(root, file) {
   }
 }
 async function writeAuthority(root, relative, content, operationId) {
-  const directory = path59.join(root, ".mancode", path59.dirname(relative));
-  const target = path59.join(root, ".mancode", relative);
+  const directory = path60.join(root, ".mancode", path60.dirname(relative));
+  const target = path60.join(root, ".mancode", relative);
   await optionalContent(root, relative);
   const parent = await lstat23(directory);
   if (!parent.isDirectory() || parent.isSymbolicLink())
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
-  const temporary = path59.join(
+  const temporary = path60.join(
     directory,
-    `.${path59.basename(relative)}.${operationId}.tmp`
+    `.${path60.basename(relative)}.${operationId}.tmp`
   );
   await writeFile42(temporary, content, { encoding: "utf8", flag: "wx" });
   try {
@@ -33109,7 +33230,7 @@ async function privacyPolicyCommand(root, options, enabled) {
     if (enabled === void 0) {
       if (options.file === void 0)
         throw new Error("MANCODE_PRIVACY_CANDIDATE_REQUIRED");
-      const file = path60.resolve(options.file);
+      const file = path61.resolve(options.file);
       const stat5 = await lstat24(file);
       if (!stat5.isFile() || stat5.isSymbolicLink() || stat5.size > 64 * 1024)
         throw new Error("MANCODE_PRIVACY_CANDIDATE_INVALID");
@@ -33210,7 +33331,7 @@ async function readInput(rootDir, file, stdin2) {
     let handle;
     try {
       handle = await fs7.open(
-        path61.resolve(rootDir, file),
+        path62.resolve(rootDir, file),
         constants.O_RDONLY | constants.O_NONBLOCK
       );
       const stat5 = await handle.stat();
@@ -33309,9 +33430,9 @@ async function privacyPreview(rootDir, options = {}, stdin2 = process.stdin) {
       printReport(result2.scan, options);
       return 2;
     }
-    const destination = path61.resolve(rootDir, options.output);
-    const temporary = path61.join(
-      path61.dirname(destination),
+    const destination = path62.resolve(rootDir, options.output);
+    const temporary = path62.join(
+      path62.dirname(destination),
       `.mancode-preview-${randomUUID2()}.tmp`
     );
     let handle;
@@ -33388,11 +33509,11 @@ function registerPrivacyCommands(program) {
 
 // src/context/project-policy-upgrade.ts
 import { lstat as lstat25, mkdir as mkdir34, readFile as readFile41, rm as rm21, writeFile as writeFile43 } from "fs/promises";
-import path62 from "path";
+import path63 from "path";
 var UPGRADE_OPERATION = "project_policy_upgrade";
 async function dryRunProjectPolicyUpgrade(input) {
   assertPolicyVersion(input.policyVersion);
-  const root = path62.resolve(input.projectRoot);
+  const root = path63.resolve(input.projectRoot);
   const project = await new V3ContextStore(root).readProjectSnapshot();
   const beforeDigest = digestManifest(project.manifest);
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -33436,7 +33557,7 @@ async function dryRunProjectPolicyUpgrade(input) {
 async function upgradeProjectPolicy(input) {
   assertPolicyVersion(input.policyVersion);
   assertUlid(input.sessionId, "project policy upgrade sessionId");
-  const root = path62.resolve(input.projectRoot);
+  const root = path63.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId;
   if (operationId === void 0) {
@@ -33695,16 +33816,16 @@ function needsPlanningUpgrade(manifest) {
   return !hasPlanningPolicy2(manifest);
 }
 async function readSchemaContent(root) {
-  return readFile41(path62.join(root, ".mancode", "schema.json"), "utf8");
+  return readFile41(path63.join(root, ".mancode", "schema.json"), "utf8");
 }
 async function writeSchemaContent(root, operationId, content) {
-  const directory = path62.join(root, ".mancode");
-  const target = path62.join(directory, "schema.json");
+  const directory = path63.join(root, ".mancode");
+  const target = path63.join(directory, "schema.json");
   const stat5 = await lstat25(target);
   if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const temporary = path62.join(
+  const temporary = path63.join(
     directory,
     `.schema.json.${operationId}.${process.pid}.tmp`
   );
@@ -33780,13 +33901,13 @@ async function releaseLocks3(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
 function projectUpgradePreviewRoot(root, operationId) {
-  return path62.join(root, ".mancode", "staging", "project-upgrade", operationId);
+  return path63.join(root, ".mancode", "staging", "project-upgrade", operationId);
 }
 async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
   const directory = projectUpgradePreviewRoot(root, receipt.operationId);
-  const receiptPath = path62.join(directory, "preview.json");
-  const manifestPath = path62.join(directory, "schema.json");
-  await mkdir34(path62.dirname(directory), { recursive: true });
+  const receiptPath = path63.join(directory, "preview.json");
+  const manifestPath = path63.join(directory, "schema.json");
+  await mkdir34(path63.dirname(directory), { recursive: true });
   try {
     await mkdir34(directory);
   } catch (error) {
@@ -33813,8 +33934,8 @@ async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
 async function assertProjectPolicyUpgradePreview(root, operationId, project) {
   const directory = projectUpgradePreviewRoot(root, operationId);
   const [receiptContent, manifestContent] = await Promise.all([
-    readSafePreviewFile(path62.join(directory, "preview.json")),
-    readSafePreviewFile(path62.join(directory, "schema.json"))
+    readSafePreviewFile(path63.join(directory, "preview.json")),
+    readSafePreviewFile(path63.join(directory, "schema.json"))
   ]);
   let receipt;
   try {
@@ -33930,16 +34051,16 @@ async function projectUpgrade(rootDir, options) {
 // src/commands/refresh-project.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { promises as fs8 } from "fs";
-import path63 from "path";
+import path64 from "path";
 import process9 from "process";
 var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED4 = 1;
 var EXIT_CORRUPT_STATE = 2;
 var EXIT_REFRESH_FAILED = 3;
 async function refreshProject(rootDir = process9.cwd()) {
-  const mancodeDir = path63.join(rootDir, ".mancode");
-  const statePath = path63.join(mancodeDir, "state.json");
-  if (await pathExists11(path63.join(mancodeDir, "schema.json"))) {
+  const mancodeDir = path64.join(rootDir, ".mancode");
+  const statePath = path64.join(mancodeDir, "state.json");
+  if (await pathExists11(path64.join(mancodeDir, "schema.json"))) {
     return refreshV3Project(rootDir);
   }
   if (!await pathExists11(statePath)) {
@@ -33958,12 +34079,12 @@ async function refreshProject(rootDir = process9.cwd()) {
     const [profile, team, hasGit, hasEvidence] = await Promise.all([
       detectProjectProfile(rootDir),
       detectTeamStatus(rootDir),
-      pathExists11(path63.join(rootDir, ".git")),
+      pathExists11(path64.join(rootDir, ".git")),
       hasProjectEvidence(rootDir)
     ]);
     const uiLibrary = primaryUiLibrary(profile);
     const stack = [...profile.languages, ...profile.frameworks];
-    const config = await readJson2(path63.join(mancodeDir, "config.json"));
+    const config = await readJson2(path64.join(mancodeDir, "config.json"));
     const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
     const nextState = {
       ...state,
@@ -33975,7 +34096,7 @@ async function refreshProject(rootDir = process9.cwd()) {
     };
     await writeProjectFacts2(
       statePath,
-      path63.join(mancodeDir, "project-profile.json"),
+      path64.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(nextState, null, 2)}
 `,
       `${JSON.stringify(profile, null, 2)}
@@ -34102,9 +34223,9 @@ async function readOptionalText(filePath) {
   }
 }
 function temporaryPath(filePath) {
-  return path63.join(
-    path63.dirname(filePath),
-    `.${path63.basename(filePath)}.${process9.pid}.${randomUUID3()}.tmp`
+  return path64.join(
+    path64.dirname(filePath),
+    `.${path64.basename(filePath)}.${process9.pid}.${randomUUID3()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -34174,7 +34295,7 @@ async function pathExists11(filePath) {
 
 // src/commands/refresh-style.ts
 import { promises as fs9 } from "fs";
-import path64 from "path";
+import path65 from "path";
 import process10 from "process";
 var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
@@ -34185,8 +34306,8 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     console.error("\u2717  style scan root must stay inside the project root.");
     return EXIT_V3_REFRESH_FAILED;
   }
-  const stateFile = path64.join(rootDir, ".mancode", "state.json");
-  if (await pathExists12(path64.join(rootDir, ".mancode", "schema.json"))) {
+  const stateFile = path65.join(rootDir, ".mancode", "state.json");
+  if (await pathExists12(path65.join(rootDir, ".mancode", "schema.json"))) {
     return refreshV3Style(rootDir, scanTarget.root, scanTarget.scopeRoot);
   }
   if (!await pathExists12(stateFile)) {
@@ -34196,7 +34317,7 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
   }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path64.join(rootDir, ".mancode", "project-profile.json");
+  const profilePath = path65.join(rootDir, ".mancode", "project-profile.json");
   await fs9.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
@@ -34223,13 +34344,13 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     uiLibraryHint,
     scanTarget.scopeRoot
   );
-  const tokensPath = path64.join(
+  const tokensPath = path65.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs9.mkdir(path64.dirname(tokensPath), { recursive: true });
+  await fs9.mkdir(path65.dirname(tokensPath), { recursive: true });
   await fs9.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -34302,7 +34423,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     console.log(
       `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
     );
-    const tokensPath = path64.join(
+    const tokensPath = path65.join(
       rootDir,
       ".mancode",
       "local",
@@ -34319,7 +34440,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     }
     console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
     const tokens = await scanAesthetics(scanRoot, uiLibraryHint, scopeRoot);
-    await fs9.mkdir(path64.dirname(tokensPath), { recursive: true });
+    await fs9.mkdir(path65.dirname(tokensPath), { recursive: true });
     await fs9.writeFile(
       tokensPath,
       `${JSON.stringify(tokens, null, 2)}
@@ -34353,7 +34474,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path64.join(rootDir, ".mancode", "state.json");
+  const statePath = path65.join(rootDir, ".mancode", "state.json");
   try {
     const state = JSON.parse(await fs9.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
@@ -34377,7 +34498,7 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path64.join(rootDir, ".mancode", "config.json"),
+      path65.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -34397,30 +34518,30 @@ async function pathExists12(p) {
   }
 }
 async function resolveScanTarget(rootDir, requestedRoot) {
-  const projectRoot = await fs9.realpath(path64.resolve(rootDir)).catch(() => null);
+  const projectRoot = await fs9.realpath(path65.resolve(rootDir)).catch(() => null);
   if (projectRoot === null) return null;
   if (requestedRoot === void 0 || requestedRoot === ".") {
     return { root: projectRoot, scopeRoot: "." };
   }
-  if (path64.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (path65.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
     return null;
   }
-  const candidate = await fs9.realpath(path64.resolve(projectRoot, requestedRoot)).catch(() => null);
+  const candidate = await fs9.realpath(path65.resolve(projectRoot, requestedRoot)).catch(() => null);
   if (candidate === null) return null;
-  const relative = path64.relative(projectRoot, candidate);
-  if (relative.startsWith(`..${path64.sep}`) || relative === ".." || path64.isAbsolute(relative)) {
+  const relative = path65.relative(projectRoot, candidate);
+  if (relative.startsWith(`..${path65.sep}`) || relative === ".." || path65.isAbsolute(relative)) {
     return null;
   }
   return {
     root: candidate,
-    scopeRoot: relative.split(path64.sep).join("/") || "."
+    scopeRoot: relative.split(path65.sep).join("/") || "."
   };
 }
 
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs10 } from "fs";
-import path65 from "path";
+import path66 from "path";
 import process11 from "process";
 
 // src/team/assessment.ts
@@ -34576,8 +34697,8 @@ var EXIT_OK9 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
 async function status(rootDir = process11.cwd(), options = {}) {
-  const stateFile = path65.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path65.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path66.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path66.join(rootDir, ".mancode", "schema.json");
   if (await pathExists13(v3SchemaFile)) {
     return statusV3(rootDir, options);
   }
@@ -34822,7 +34943,7 @@ async function readV3StatusSession(rootDir) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists13(path65.join(rootDir, ".git"));
+  const hasGit = await pathExists13(path66.join(rootDir, ".git"));
   if (hasGit) return true;
   return hasProjectEvidence(rootDir);
 }
@@ -34866,19 +34987,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs10.readFile(path65.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs10.readFile(path66.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path65.basename(rootDir);
+  return path66.basename(rootDir);
 }
 async function readConfig3(rootDir) {
   try {
     const raw = await fs10.readFile(
-      path65.join(rootDir, ".mancode", "config.json"),
+      path66.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34906,9 +35027,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists13(path65.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists13(path66.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists13(
-      path65.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path66.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -34917,7 +35038,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs10.readFile(
-      path65.join(rootDir, ".claude", "settings.json"),
+      path66.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -34946,7 +35067,7 @@ function hasHookCommand2(value, needle) {
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path65.join(
+  const hookPath = path66.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -36444,7 +36565,7 @@ function assertPositiveRevision2(value, label) {
 
 // src/team/git-ref-handoff-repair.ts
 import { lstat as lstat26, mkdir as mkdir35, readFile as readFile42, readdir as readdir18, writeFile as writeFile44 } from "fs/promises";
-import path66 from "path";
+import path67 from "path";
 
 // src/team/git-ref-operation.ts
 import { execFile as execFileCallback5 } from "child_process";
@@ -39022,7 +39143,7 @@ async function recoverGitRefHandoffRepairs(projectRoot) {
 }
 async function recoverGitRefHandoffRepair(projectRoot, operationId, transportReceipt) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  const root = path66.resolve(projectRoot);
+  const root = path67.resolve(projectRoot);
   let journal = await requireJournal2(root, operationId);
   if (journal.state === "committed" || journal.state === "aborted") {
     return recoveryResult2(journal);
@@ -39101,7 +39222,7 @@ async function recoverGitRefHandoffRepair(projectRoot, operationId, transportRec
   }
 }
 async function prepareHandoffRepairWhileTaskLocked(projectRoot, rawPrepared) {
-  const root = path66.resolve(projectRoot);
+  const root = path67.resolve(projectRoot);
   const prepared2 = parsePrepared2(rawPrepared);
   const runtime = await readProjectRuntimeContext(root);
   const previousMetadata = bundleMetadata2(prepared2.predecessorBundle);
@@ -39164,7 +39285,7 @@ async function restorePredecessorMetadata2(projectRoot, journal) {
   );
 }
 async function replaceMetadataVerified(projectRoot, expected, targetMetadata, alternateExpected) {
-  const target = path66.join(
+  const target = path67.join(
     taskRootPath(projectRoot, targetMetadata.taskRef),
     "metadata.json"
   );
@@ -39333,7 +39454,7 @@ async function listJournals2(projectRoot) {
       parseJournal3(
         JSON.parse(
           await readFile42(
-            path66.join(journalDirectory2(projectRoot), entry),
+            path67.join(journalDirectory2(projectRoot), entry),
             "utf8"
           )
         )
@@ -39355,17 +39476,17 @@ async function readSafeFile2(target) {
   return content;
 }
 async function atomicWrite2(target, content) {
-  const temporary = path66.join(
-    path66.dirname(target),
-    `.${path66.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path67.join(
+    path67.dirname(target),
+    `.${path67.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   await writeFile44(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory2(projectRoot) {
-  let current = path66.resolve(projectRoot);
+  let current = path67.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-handoff"]) {
-    current = path66.join(current, segment);
+    current = path67.join(current, segment);
     try {
       await mkdir35(current);
     } catch (error) {
@@ -39378,8 +39499,8 @@ async function ensureJournalDirectory2(projectRoot) {
   }
 }
 function journalDirectory2(projectRoot) {
-  return path66.join(
-    path66.resolve(projectRoot),
+  return path67.join(
+    path67.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -39388,7 +39509,7 @@ function journalDirectory2(projectRoot) {
 }
 function journalPath3(projectRoot, operationId) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  return path66.join(journalDirectory2(projectRoot), `${operationId}.json`);
+  return path67.join(journalDirectory2(projectRoot), `${operationId}.json`);
 }
 function serialize11(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -39488,7 +39609,7 @@ function parseReceipt(value) {
 
 // src/team/policy-operation.ts
 import { lstat as lstat27, mkdir as mkdir36, readdir as readdir19, unlink as unlink3, writeFile as writeFile45 } from "fs/promises";
-import path67 from "path";
+import path68 from "path";
 async function updateTeamPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   const eventId = createUlid();
@@ -39499,7 +39620,7 @@ async function updateTeamPolicy(input) {
     throw new Error("MANCODE_TEAM_POLICY_INVALID");
   }
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path67.resolve(input.projectRoot);
+  const root = path68.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -39580,7 +39701,7 @@ async function applyTeamTransportSet(input, write) {
   }
   const remote = transportRemote(input.mode, input.remote);
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path67.resolve(input.projectRoot);
+  const root = path68.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -39713,9 +39834,9 @@ async function assertTransportAuthorityEmpty(projectRoot, store) {
     listClaims(store),
     listHandoffs(store),
     directoryHasEntries(taskHeadDirectory(store)),
-    directoryHasEntries(path67.join(store.root, "transport-migrations")),
+    directoryHasEntries(path68.join(store.root, "transport-migrations")),
     directoryHasEntries(
-      path67.join(projectRoot, ".mancode", "shared", "team", "transport")
+      path68.join(projectRoot, ".mancode", "shared", "team", "transport")
     ),
     pathExists14(gitRefCachePath(projectRoot))
   ]);
@@ -39745,18 +39866,18 @@ function assertPositiveRevision5(value, label) {
   }
 }
 function teamPolicyPath(projectRoot) {
-  return path67.join(projectRoot, ".mancode", "shared", "team", "policy.json");
+  return path68.join(projectRoot, ".mancode", "shared", "team", "policy.json");
 }
 function projectConfigPath(projectRoot) {
-  return path67.join(projectRoot, ".mancode", "shared", "config.json");
+  return path68.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function writeJsonAtomic4(target, value) {
-  await mkdir36(path67.dirname(target), { recursive: true });
-  await assertPlainDirectory(path67.dirname(target));
+  await mkdir36(path68.dirname(target), { recursive: true });
+  await assertPlainDirectory(path68.dirname(target));
   await assertPlainFileOrMissing(target);
-  const temporary = path67.join(
-    path67.dirname(target),
-    `.${path67.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  const temporary = path68.join(
+    path68.dirname(target),
+    `.${path68.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
     await writeFile45(temporary, `${JSON.stringify(value, null, 2)}
@@ -39825,7 +39946,7 @@ import {
   unlink as unlink4,
   writeFile as writeFile46
 } from "fs/promises";
-import path68 from "path";
+import path69 from "path";
 
 // src/team/transport-migration.ts
 var DIGEST_PATTERN5 = /^sha256:[a-f0-9]{64}$/;
@@ -40904,7 +41025,7 @@ function compareUtf812(left, right) {
 var STAGE_DIRECTORY = "transport-migrations";
 var COLLECTIONS = ["claims", "handoffs", "task-heads"];
 async function createTransportMigrationFileAdapters(input) {
-  const projectRoot = path68.resolve(input.projectRoot);
+  const projectRoot = path69.resolve(input.projectRoot);
   assertUlid(input.actorId, "transport migration adapter actorId");
   if (input.operationId !== void 0) {
     assertUlid(input.operationId, "transport migration adapter operationId");
@@ -40972,7 +41093,7 @@ async function createTransportMigrationFileAdapters(input) {
 var FileSystemTransportMigrationConfigAdapter = class {
   constructor(projectRoot, coordinationStore) {
     this.coordinationStore = coordinationStore;
-    this.projectRoot = path68.resolve(projectRoot);
+    this.projectRoot = path69.resolve(projectRoot);
   }
   projectRoot;
   async read() {
@@ -41838,7 +41959,7 @@ async function publishMigrationActorProfiles(projectRoot, profiles) {
   }
 }
 async function archiveLocalCoordinationCollections(store, operationId) {
-  const archiveRoot = path68.join(
+  const archiveRoot = path69.join(
     store.root,
     STAGE_DIRECTORY,
     "archive",
@@ -41851,8 +41972,8 @@ async function archiveLocalCoordinationCollections(store, operationId) {
     "task-heads": taskHeadDirectory(store)
   };
   for (const name of COLLECTIONS) {
-    const archived = path68.join(archiveRoot, name);
-    const absent = path68.join(archiveRoot, `${name}.absent`);
+    const archived = path69.join(archiveRoot, name);
+    const absent = path69.join(archiveRoot, `${name}.absent`);
     if (await pathKind(archived) === "directory" || await pathKind(absent) === "file") {
       continue;
     }
@@ -41890,7 +42011,7 @@ async function listActorProfiles(projectRoot) {
   return profiles;
 }
 async function listSharedTaskRefs(projectRoot) {
-  const directory = path68.join(projectRoot, ".mancode", "shared", "workflows");
+  const directory = path69.join(projectRoot, ".mancode", "shared", "workflows");
   let entries;
   try {
     entries = await readdir20(directory);
@@ -41901,7 +42022,7 @@ async function listSharedTaskRefs(projectRoot) {
   const refs = [];
   for (const taskId of entries.sort(compareUtf813)) {
     assertUlid(taskId, "shared workflow directory");
-    const stat5 = await lstat28(path68.join(directory, taskId));
+    const stat5 = await lstat28(path69.join(directory, taskId));
     if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
     }
@@ -41975,7 +42096,7 @@ async function readStagedRecord(store, operationId) {
   );
 }
 function stagedPath(store, operationId) {
-  return path68.join(
+  return path69.join(
     store.root,
     STAGE_DIRECTORY,
     "staged",
@@ -41983,7 +42104,7 @@ function stagedPath(store, operationId) {
   );
 }
 function establishedPath(store, operationId) {
-  return path68.join(
+  return path69.join(
     store.root,
     STAGE_DIRECTORY,
     "established",
@@ -41991,7 +42112,7 @@ function establishedPath(store, operationId) {
   );
 }
 function projectConfigPath2(projectRoot) {
-  return path68.join(projectRoot, ".mancode", "shared", "config.json");
+  return path69.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function readProjectConfigFile(projectRoot) {
   try {
@@ -42006,11 +42127,11 @@ async function readProjectConfigFile(projectRoot) {
   }
 }
 async function writeJsonAtomic5(target, value) {
-  await mkdir37(path68.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path68.dirname(target));
-  const temporary = path68.join(
-    path68.dirname(target),
-    `.${path68.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  await mkdir37(path69.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path69.dirname(target));
+  const temporary = path69.join(
+    path69.dirname(target),
+    `.${path69.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
     await writeFile46(temporary, serialize12(value), {
@@ -42024,8 +42145,8 @@ async function writeJsonAtomic5(target, value) {
   }
 }
 async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
-  await mkdir37(path68.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path68.dirname(target));
+  await mkdir37(path69.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path69.dirname(target));
   try {
     await writeFile46(target, serialize12(value), { encoding: "utf8", flag: "wx" });
   } catch (error) {
@@ -43576,15 +43697,15 @@ function parsePositiveInteger5(value) {
 
 // src/commands/uninstall.ts
 import { access as access5, readFile as readFile44, rm as rm22, writeFile as writeFile47 } from "fs/promises";
-import path69 from "path";
+import path70 from "path";
 import process12 from "process";
 var EXIT_OK10 = 0;
 var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
 var EXIT_V3_AUTHORITY_PROTECTED = 3;
 async function uninstall(rootDir = process12.cwd(), platform, options = {}) {
-  const stateFile = path69.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path69.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path70.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path70.join(rootDir, ".mancode", "schema.json");
   if (await pathExists15(v3SchemaFile)) {
     return uninstallV3(rootDir, platform, options);
   }
@@ -43681,7 +43802,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm22(path69.join(rootDir, ".mancode"), {
+  await rm22(path70.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -43691,7 +43812,7 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path69.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path70.join(rootDir, ".claude", "settings.json");
   let content;
   try {
     content = await readFile44(settingsPath, "utf-8");
@@ -43769,7 +43890,7 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path69.join(rootDir, "AGENTS.md");
+  const agentsPath = path70.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile44(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
@@ -43784,7 +43905,7 @@ async function uninstallCodex(rootDir) {
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path69.join(
+  const instructionsPath = path70.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
@@ -43803,7 +43924,7 @@ async function uninstallCopilot(rootDir) {
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path69.join(rootDir, "AGENTS.md");
+  const agentsPath = path70.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile44(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -43822,7 +43943,7 @@ async function uninstallZcode(rootDir) {
   await removeZcodeSkills(rootDir);
 }
 async function uninstallKimiCode(rootDir) {
-  const agentsPath = path69.join(rootDir, "AGENTS.md");
+  const agentsPath = path70.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile44(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -43841,7 +43962,7 @@ async function uninstallKimiCode(rootDir) {
   await removeKimiSkills(rootDir);
 }
 async function uninstallQoder(rootDir) {
-  const agentsPath = path69.join(rootDir, "AGENTS.md");
+  const agentsPath = path70.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile44(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -43861,7 +43982,7 @@ async function uninstallQoder(rootDir) {
 }
 async function uninstallDsh(rootDir) {
   await assertDshAdapterPathsSafe(rootDir);
-  const agentsPath = path69.join(rootDir, "AGENTS.md");
+  const agentsPath = path70.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile44(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -43881,7 +44002,7 @@ async function uninstallDsh(rootDir) {
   await removeDshSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path69.join(rootDir, ".mancode", "config.json");
+  const configPath = path70.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await readFile44(configPath, "utf-8");
     const config = JSON.parse(raw);
@@ -43954,7 +44075,7 @@ var CONTINUITY_COMPATIBILITY_SUBCOMMANDS = /* @__PURE__ */ new Set(["clean"]);
 
 // src/commands/workflow.ts
 import { access as access6, readFile as readFile49, rm as rm26, writeFile as writeFile51 } from "fs/promises";
-import path75 from "path";
+import path76 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -44293,11 +44414,11 @@ import {
   rm as rm24,
   writeFile as writeFile49
 } from "fs/promises";
-import path72 from "path";
+import path73 from "path";
 import { promisify as promisify8 } from "util";
 
 // src/context/man-delivery-plan.ts
-import path70 from "path";
+import path71 from "path";
 var SOURCE_PREFIX = "<!-- mancode:delivery-plan ";
 var MARKERS = [
   "<!-- mancode:plan-baseline:start -->",
@@ -44367,7 +44488,7 @@ ${document.slice(parsed.recordEnd)}`;
   return next;
 }
 function assertManPlanPath(file) {
-  if (!file || path70.posix.isAbsolute(file) || /[\\\r\n\0<>:]/.test(file) || file.split("/").some((part) => !part || part === "." || part === "..") || /^(?:\.git|\.mancode|架构|项目接口)(?:\/|$)/.test(file) || !file.endsWith(".md") || !file.includes("/"))
+  if (!file || path71.posix.isAbsolute(file) || /[\\\r\n\0<>:]/.test(file) || file.split("/").some((part) => !part || part === "." || part === "..") || /^(?:\.git|\.mancode|架构|项目接口)(?:\/|$)/.test(file) || !file.endsWith(".md") || !file.includes("/"))
     throw new Error("MANCODE_MAN_PLAN_PATH_INVALID");
 }
 function parseSource(value) {
@@ -44399,7 +44520,7 @@ function parseManDeliveryPlan(plan) {
 // src/context/man-progress.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { lstat as lstat29, readFile as readFile45, realpath as realpath3, rm as rm23, writeFile as writeFile48 } from "fs/promises";
-import path71 from "path";
+import path72 from "path";
 var START = '<script type="application/json" id="mancode-progress-data">';
 var END = "</script>";
 function updateManProgressHtml(html, taskId, status2, reason) {
@@ -44431,7 +44552,7 @@ ${JSON.stringify(data).replaceAll("<", "\\u003c")}
 ${html.slice(end)}`;
 }
 async function syncManProgressPage(root, taskId, status2, reason, allowed) {
-  const target = path71.join(root, "\u9879\u76EE\u8FDB\u5EA6.html");
+  const target = path72.join(root, "\u9879\u76EE\u8FDB\u5EA6.html");
   let temporary;
   try {
     const stat5 = await lstat29(target);
@@ -44440,7 +44561,7 @@ async function syncManProgressPage(root, taskId, status2, reason, allowed) {
         status: "manual_sync",
         reason: "progress page is outside the approved write scope"
       };
-    if (!stat5.isFile() || await realpath3(target) !== path71.join(await realpath3(root), "\u9879\u76EE\u8FDB\u5EA6.html"))
+    if (!stat5.isFile() || await realpath3(target) !== path72.join(await realpath3(root), "\u9879\u76EE\u8FDB\u5EA6.html"))
       return {
         status: "manual_sync",
         reason: "progress page must be a regular project file"
@@ -44471,7 +44592,7 @@ async function syncManProgressPage(root, taskId, status2, reason, allowed) {
 var execFile9 = promisify8(execFileCallback6);
 var MAN_DELIVERY_POLICY = 3;
 function isManDelivery(metadata) {
-  return metadata.workflowMode === "man" && metadata.governance.policyVersions.planning === MAN_DELIVERY_POLICY && metadata.governance.planDecision !== "solo_handoff";
+  return metadata.workflowMode === "man" && metadata.governance.policyVersions.planning === MAN_DELIVERY_POLICY;
 }
 async function manGit(root, args) {
   return (await execFile9("git", args, {
@@ -44494,8 +44615,8 @@ async function hasGitWorktree(root) {
 async function readManPlanFile(root, file) {
   assertManPlanPath(file);
   const resolvedRoot = await realpath4(root);
-  const resolved = await realpath4(path72.join(root, file));
-  const relative = path72.relative(resolvedRoot, resolved).split(path72.sep).join("/");
+  const resolved = await realpath4(path73.join(root, file));
+  const relative = path73.relative(resolvedRoot, resolved).split(path73.sep).join("/");
   assertManPlanPath(relative);
   if (relative !== file) throw new Error("MANCODE_MAN_PLAN_USE_REAL_PATH");
   if (!(await lstat30(resolved)).isFile())
@@ -44551,7 +44672,7 @@ async function captureManSubject(root, task) {
   const hashes = [];
   for (const file of files) {
     if (file.startsWith(".mancode/") || file === "\u9879\u76EE\u8FDB\u5EA6.html") continue;
-    const absolute = path72.join(root, file);
+    const absolute = path73.join(root, file);
     let contents;
     let kind = "deleted";
     try {
@@ -44559,11 +44680,11 @@ async function captureManSubject(root, task) {
       kind = `file:${stat5.mode & 73}`;
       if (stat5.isSymbolicLink()) {
         kind = "symlink";
-        const target = path72.relative(
+        const target = path73.relative(
           await realpath4(root),
           await realpath4(absolute)
         );
-        if (target.startsWith(`..${path72.sep}`) || path72.isAbsolute(target))
+        if (target.startsWith(`..${path73.sep}`) || path73.isAbsolute(target))
           throw new Error("MANCODE_MAN_EXTERNAL_DEPENDENCY_UNVERIFIED");
         contents = `${await readlink3(absolute)}\0${await readFile46(absolute, "base64")}`;
       } else if (stat5.isFile()) {
@@ -44634,9 +44755,9 @@ function assertManVerificationSubjects(task, verification, subject) {
 }
 function manScopeContains(metadata, file) {
   return metadata.implementationScope.include.some(
-    (include) => path72.matchesGlob(file, include)
+    (include) => path73.matchesGlob(file, include)
   ) && !metadata.implementationScope.exclude.some(
-    (exclude) => path72.matchesGlob(file, exclude)
+    (exclude) => path73.matchesGlob(file, exclude)
   );
 }
 function assertManPlanInScope(metadata, file) {
@@ -44647,7 +44768,7 @@ function assertManPlanInScope(metadata, file) {
 }
 function manDeliveryFinalization(task, subject, recordCurrent, outsideScope, outsideScopeDirty, pendingCommit) {
   const blockers = [];
-  if (task.metadata.governance.planDecision !== "governed_execution")
+  if (task.metadata.governance.planDecision !== "governed_execution" && !isActiveSoloHandoff(task.metadata) && !(task.metadata.governance.planDecision === "solo_handoff" && task.metadata.status === "completed" && task.metadata.soloExecution?.state === "completed" && task.metadata.soloExecution.planVersion === task.metadata.governance.planVersion))
     blockers.push({
       code: "plan_execution_required",
       status: task.metadata.governance.planDecision ?? "unconfirmed",
@@ -44658,7 +44779,9 @@ function manDeliveryFinalization(task, subject, recordCurrent, outsideScope, out
     blockers.push({
       code: "review_incomplete",
       status: task.review.status === "passed" ? "stale" : task.review.status,
-      nextAction: task.review.status === "blocked" ? "Fix the recorded findings, verify the changed module, and submit the targeted review result." : "Complete one module review for the current subject and apply its review ledger."
+      nextAction: task.review.status === "blocked" ? task.review.blockers.some((finding) => finding.status === "open") ? "Fix the recorded findings, verify the changed module, and submit the targeted review result." : task.review.delivery?.coverage.some(
+        (criterion) => criterion.status === "missing"
+      ) ? "Complete the missing accepted behavior within the approved scope, verify it, and update the module review." : "Record the missing acceptance evidence when verification is available, then update the module review." : "Complete one module review for the current subject and apply its review ledger."
     });
   const verification = assessManVerification(task, subject);
   if (verification.status !== "passed")
@@ -44926,7 +45049,7 @@ function renderManDeliveryRecord(task, subject) {
 }
 async function syncManDeliveryRecord(root, task) {
   const bound = await readBoundManPlan(root, task);
-  if (task.metadata.governance.planDecision === "governed_execution" && !manScopeContains(task.metadata, bound.source.path))
+  if ((task.metadata.governance.planDecision === "governed_execution" || isActiveSoloHandoff(task.metadata)) && !manScopeContains(task.metadata, bound.source.path))
     assertManPlanInScope(task.metadata, bound.source.path);
   const subject = await hasGitWorktree(root) ? await captureManSubject(root, task) : void 0;
   const next = replaceManDeliveryRecord(
@@ -44941,7 +45064,7 @@ async function syncManDeliveryRecord(root, task) {
     throw new Error(
       "MANCODE_MAN_DOCUMENT_SENSITIVE: redact credential-like text before versioning"
     );
-  const target = await realpath4(path72.join(root, bound.source.path));
+  const target = await realpath4(path73.join(root, bound.source.path));
   if (next !== bound.document) {
     const temporary = `${target}.${randomUUID5()}.tmp`;
     try {
@@ -44971,7 +45094,7 @@ async function syncManDeliveryRecord(root, task) {
   const reason = task.metadata.status === "blocked" && unresolved.length ? unresolved.map((item) => item.statement).join("; ") : null;
   const verified = subject !== void 0 && assessManVerification(task, subject).status === "passed";
   const reviewed = task.review.status === "skipped" || task.review.status === "passed" && task.review.delivery?.subject.contentDigest === subject?.contentDigest && task.review.delivery?.subject.environment === subject?.environment;
-  const status2 = reason ? "\u963B\u585E" : verified && reviewed ? "\u5DF2\u5B8C\u6210" : verified && task.review.status !== "blocked" ? "\u5F85\u5BA1\u6838" : task.metadata.currentStep >= 5 ? "\u8FDB\u884C\u4E2D" : "\u672A\u5B8C\u6210";
+  const status2 = reason ? "\u963B\u585E" : verified && reviewed ? "\u5DF2\u5B8C\u6210" : verified && task.review.status !== "blocked" ? "\u5F85\u5BA1\u6838" : task.metadata.currentStep >= 5 || isActiveSoloHandoff(task.metadata) ? "\u8FDB\u884C\u4E2D" : "\u672A\u5B8C\u6210";
   return syncManProgressPage(
     root,
     taskId,
@@ -45700,13 +45823,19 @@ async function reviseV3Plan(input) {
       planDecisionSupplied: input.planDecision !== void 0,
       sessionActorId: context.session.actorId
     });
+    const implementationScope = submittedScope ?? context.task.metadata.implementationScope;
+    const scopeChanged = submittedScope !== null && submittedScope.digest !== context.task.metadata.implementationScope.digest;
+    const executionResumption = assertPlanOnlyExecutionResumption({
+      metadata: context.task.metadata,
+      planDecision,
+      authorityChanged: planChanged || scopeChanged,
+      sessionActorId: context.session.actorId
+    });
     assertPlanRevisionEligible(
       context.task.metadata,
       context.task.requirements,
-      executionScopeBinding
+      executionScopeBinding || executionResumption
     );
-    const implementationScope = submittedScope ?? context.task.metadata.implementationScope;
-    const scopeChanged = submittedScope !== null && submittedScope.digest !== context.task.metadata.implementationScope.digest;
     if (planDecision === "governed_execution") {
       assertExecutableImplementationScope(implementationScope);
       if (isManDelivery(context.task.metadata)) {
@@ -45766,10 +45895,10 @@ async function reviseV3Plan(input) {
       latestCheckpoint: context.task.latestCheckpoint
     });
     const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
-    if (planDecision === "plan_only") {
+    if (planDecision === "plan_only" || executionResumption) {
       await enqueueSessionPointerProjection(context.projectRoot, {
         operationId: context.operationId,
-        action: "clear",
+        action: executionResumption ? "resume" : "clear",
         sessionId: context.session.sessionId,
         expectedPreviousTaskRef: context.session.activeTaskRef,
         taskRef,
@@ -45885,7 +46014,7 @@ async function reviseV3Plan(input) {
       await replaceTaskHeadFence(context.homeStore, taskHeadFence);
     }
     const operation = await commitTaskOperation(context, journal);
-    if (planDecision === "plan_only") {
+    if (planDecision === "plan_only" || executionResumption) {
       try {
         await reconcileProjectionIntents(
           context.projectRoot,
@@ -45929,8 +46058,8 @@ function parsePlanDecision(value) {
   }
   return value;
 }
-function assertPlanRevisionEligible(metadata, requirements, executionScopeBinding) {
-  if (executionScopeBinding) {
+function assertPlanRevisionEligible(metadata, requirements, approvedAuthorityPreserved) {
+  if (approvedAuthorityPreserved) {
     assertReadyPlanRequirements(metadata, requirements);
     return;
   }
@@ -45948,6 +46077,25 @@ function assertPlanRevisionEligible(metadata, requirements, executionScopeBindin
   }
   assertReadyPlanRequirements(metadata, requirements);
 }
+function assertPlanOnlyExecutionResumption(input) {
+  const { metadata } = input;
+  if (metadata.governance.planDecision !== "plan_only" || input.planDecision !== "governed_execution") {
+    return false;
+  }
+  if (metadata.workflowMode !== "man" || metadata.taskRef.namespace !== "local" || metadata.coordination !== "single") {
+    throw new Error("MANCODE_PLAN_RESUME_LOCAL_MAN_ONLY");
+  }
+  if (!["planned", "in_progress"].includes(metadata.status) || metadata.currentStep !== 4 || metadata.governance.planVersion < 1 || metadata.soloExecution !== null) {
+    throw new Error("MANCODE_PLAN_RESUME_NOT_ELIGIBLE");
+  }
+  if (metadata.ownerActorId !== input.sessionActorId) {
+    throw new Error("MANCODE_TASK_OWNER_REQUIRED");
+  }
+  if (input.authorityChanged) {
+    throw new Error("MANCODE_PLAN_RESUME_AUTHORITY_CHANGED");
+  }
+  return true;
+}
 function assertReadyPlanRequirements(metadata, requirements) {
   if (metadata.governance.requirementsStatus !== "ready" || metadata.governance.requirementsDigest !== requirements.contentDigest || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
     throw new Error("MANCODE_PLAN_REQUIREMENTS_OR_DECISION_INVALID");
@@ -46833,6 +46981,7 @@ async function applyV3ReviewLedger(input) {
   });
   let journal = null;
   try {
+    assertSoloHandoffSession(context.task.metadata, context.session);
     const subject = isManDelivery(context.task.metadata) ? await captureManSubject(input.projectRoot, context.task) : null;
     assertManReviewCoverage(
       context.task,
@@ -47002,6 +47151,7 @@ async function applyV3ReviewLedger(input) {
   }
 }
 function assertReviewEligible(metadata, hasPlan) {
+  if (isActiveSoloHandoff(metadata) && hasPlan) return;
   if (metadata.workflowMode !== "man" && metadata.workflowMode !== "manteam") {
     throw new Error("MANCODE_REVIEW_WORKFLOW_MODE_INVALID");
   }
@@ -47202,6 +47352,7 @@ async function completeV3SoloHandoff(input) {
   let journal = null;
   try {
     assertSoloCompletionEligible(context);
+    await assertManDeliveryReady(input.projectRoot, context.task);
     const timestamp4 = context.now.toISOString();
     const completionGateMetadata = completedSoloAssignmentMetadata(
       context.task.metadata,
@@ -47452,6 +47603,9 @@ async function completeV3Task(input) {
   let journal = null;
   try {
     assertCompletionOutcome(context.task.metadata, input.outcome);
+    if (context.task.metadata.workflowMode === "manba" && context.task.metadata.ownerActorId !== context.session.actorId) {
+      throw new Error("MANCODE_TASK_OWNER_REQUIRED");
+    }
     if (taskRef.namespace === "shared" && context.project.config.transport.mode !== "local") {
       throw new Error("MANCODE_GIT_REF_TRANSPORT_NOT_IMPLEMENTED");
     }
@@ -47470,7 +47624,8 @@ async function completeV3Task(input) {
         activeChildTaskRefs: activeChildren,
         hasPendingRepairOperation: false,
         activeClaimCount: activeClaims2.length,
-        claimsWillReleaseOrTransfer: activeClaims2.length > 0
+        claimsWillReleaseOrTransfer: activeClaims2.length > 0,
+        diagnosticOutcome: input.outcome
       }
     );
     const timestamp4 = context.now.toISOString();
@@ -47778,6 +47933,7 @@ async function recordV3Verification(input) {
   });
   let journal = null;
   try {
+    assertSoloHandoffSession(context.task.metadata, context.session);
     const subject = isManDelivery(context.task.metadata) ? await captureManSubject(input.projectRoot, context.task) : null;
     assertManVerificationSubjects(
       context.task,
@@ -47903,6 +48059,7 @@ async function recordV3Verification(input) {
   }
 }
 function assertVerificationEligible(metadata, hasPlan) {
+  if (isActiveSoloHandoff(metadata) && hasPlan) return;
   if (metadata.status !== "in_progress" && metadata.status !== "blocked") {
     throw new Error("MANCODE_VERIFICATION_WORKFLOW_NOT_ACTIVE");
   }
@@ -47965,7 +48122,7 @@ import {
   rm as rm25,
   writeFile as writeFile50
 } from "fs/promises";
-import path73 from "path";
+import path74 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -48075,7 +48232,7 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path73.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path74.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();
@@ -48263,8 +48420,8 @@ async function createV3Workflow(input) {
       throw new Error("MANCODE_REVISION_CONFLICT");
     }
     const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-    const targetDirectory = path73.join(taskParent, taskRef.taskId);
-    stagingDirectory = path73.join(
+    const targetDirectory = path74.join(taskParent, taskRef.taskId);
+    stagingDirectory = path74.join(
       taskParent,
       `.${taskRef.taskId}.${operationId}.staging`
     );
@@ -48726,7 +48883,7 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path73.join(current, segment);
+    current = path74.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
       await mkdir38(current);
@@ -48762,7 +48919,7 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path73.join(stagingDirectory, fileName);
+  const target = path74.join(stagingDirectory, fileName);
   await writeFile50(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
@@ -48800,7 +48957,7 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path73.join(stagingDirectory, fileName);
+  const target = path74.join(stagingDirectory, fileName);
   const before = await lstat31(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -49257,7 +49414,8 @@ async function completeGitRefTask(input) {
         activeChildTaskRefs: activeChildren,
         hasPendingRepairOperation: false,
         activeClaimCount: activeClaims2.length,
-        claimsWillReleaseOrTransfer: activeClaims2.length > 0
+        claimsWillReleaseOrTransfer: activeClaims2.length > 0,
+        diagnosticOutcome: input.outcome
       }
     );
     const timestamp4 = now.toISOString();
@@ -49856,7 +50014,7 @@ function compareUtf816(left, right) {
 // src/commands/man-delivery.ts
 import { execFile as execFileCallback7 } from "child_process";
 import { readFile as readFile48 } from "fs/promises";
-import path74 from "path";
+import path75 from "path";
 import { promisify as promisify9 } from "util";
 var execFile10 = promisify9(execFileCallback7);
 async function manDeliveryCommand(root, args, options) {
@@ -49895,7 +50053,14 @@ async function manDeliveryCommand(root, args, options) {
     if (action === "check") {
       await assertManDeliveryReady(project.projectRoot, task);
       assertTaskCompletionGate(
-        { ...task, planDigest: task.plan?.digest ?? null },
+        {
+          ...task,
+          metadata: isActiveSoloHandoff(task.metadata) ? completedSoloAssignmentMetadata(
+            task.metadata,
+            (/* @__PURE__ */ new Date()).toISOString()
+          ) : task.metadata,
+          planDigest: task.plan?.digest ?? null
+        },
         {
           activeChildTaskRefs: await project.store.listActiveChildTaskRefs(taskRef),
           hasPendingRepairOperation: false,
@@ -49922,6 +50087,7 @@ async function manDeliveryCommand(root, args, options) {
     const actorId = context.session.actorId;
     try {
       task = context.task;
+      assertSoloHandoffSession(task.metadata, context.session);
       if (action === "sync") {
         const progress = await syncManDeliveryRecord(project.projectRoot, task);
         const synced = await project.store.readTaskSnapshot(taskRef);
@@ -49936,7 +50102,7 @@ async function manDeliveryCommand(root, args, options) {
           finalization: finalization2
         });
       }
-      if (task.metadata.governance.planDecision !== "governed_execution" || task.metadata.currentStep < 5 || task.metadata.status !== "in_progress") {
+      if (!isActiveSoloHandoff(task.metadata) && (task.metadata.governance.planDecision !== "governed_execution" || task.metadata.currentStep < 5 || task.metadata.status !== "in_progress")) {
         throw new Error("MANCODE_MAN_DELIVERY_EXECUTION_REQUIRED");
       }
     } finally {
@@ -49944,7 +50110,7 @@ async function manDeliveryCommand(root, args, options) {
     }
     if (!options.file) throw new Error("MANCODE_MAN_DELIVERY_INPUT_REQUIRED");
     const input = JSON.parse(
-      await readFile48(path74.resolve(project.projectRoot, options.file), "utf8")
+      await readFile48(path75.resolve(project.projectRoot, options.file), "utf8")
     );
     let output;
     if (action === "verify" || action === "confirm") {
@@ -50298,7 +50464,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       "Man delivery requires Continuity; legacy workflows are unchanged."
     );
   }
-  if (!await pathExists16(path75.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists16(path76.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -51383,7 +51549,7 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path75.isAbsolute(value) ? value : path75.resolve(projectRoot, value);
+  const inputPath = path76.isAbsolute(value) ? value : path76.resolve(projectRoot, value);
   return readFile49(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
@@ -51458,7 +51624,7 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile49(path75.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile49(path76.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
@@ -51503,15 +51669,15 @@ 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 = path75.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path75.join(workflowPath, "requirements.json");
-  const markdownPath = path75.join(workflowPath, "requirements.md");
-  const metadataPath3 = path75.join(workflowPath, "metadata.json");
+  const workflowPath = path76.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path76.join(workflowPath, "requirements.json");
+  const markdownPath = path76.join(workflowPath, "requirements.md");
+  const metadataPath3 = path76.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path75.isAbsolute(options.file) ? options.file : path75.resolve(rootDir, options.file);
+    const inputPath = path76.isAbsolute(options.file) ? options.file : path76.resolve(rootDir, options.file);
     const input = await readFile49(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     assertRequirementsScopeConsistent2(requirements);
@@ -51636,7 +51802,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path75.isAbsolute(options.evidenceFile) ? options.evidenceFile : path75.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path76.isAbsolute(options.evidenceFile) ? options.evidenceFile : path76.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -51696,14 +51862,14 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path75.join(
+  const metadataPath3 = path76.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path75.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path76.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
     readFile49(metadataPath3, "utf-8"),
@@ -51867,7 +52033,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path75.join(
+  const metadataPath3 = path76.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -52107,14 +52273,14 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path75.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path75.join(workflowPath, "requirements.md")) || !await pathExists16(path75.join(workflowPath, "plan.md"))) {
+  const workflowPath = path76.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path76.join(workflowPath, "requirements.md")) || !await pathExists16(path76.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path75.join(rootDir, ".mancode", "state.json");
+  const statePath = path76.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -52189,7 +52355,7 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path75.join(rootDir, ".mancode", "state.json");
+  const statePath = path76.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -52256,14 +52422,14 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path75.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path75.join(workflowPath, "requirements.md")) || !await pathExists16(path75.join(workflowPath, "plan.md"))) {
+  const workflowPath = path76.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path76.join(workflowPath, "requirements.md")) || !await pathExists16(path76.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path75.join(rootDir, ".mancode", "state.json");
+  const statePath = path76.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -52319,14 +52485,14 @@ async function workflowDecide(rootDir, taskId, options) {
   return EXIT_OK11;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path75.join(
+  const metadataPath3 = path76.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path75.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path76.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {