mancode 0.6.3 → 0.6.4

package/dist/{chunk-RDPFQODS.js → chunk-WJ6WARGG.js}

@@ -4,6 +4,7 @@ import {
   lstat,
   mkdir,
   readFile,
+  readlink,
   realpath,
   rename,
   rm,
@@ -289,17 +290,348 @@ function adapterManagedContentDigest(targetIdentity, managedContent) {
   return `sha256:${digest}`;
 }
 async function planV3AdapterFiles(projectRoot) {
+  return planPhysicalAdapterTargets(
+    path.resolve(projectRoot),
+    V3_ADAPTER_FILE_TARGETS,
+    V3_ADAPTER_PLATFORMS
+  );
+}
+async function planV3AdapterUpgradeFiles(projectRoot, platforms) {
   const root = path.resolve(projectRoot);
-  const existing = /* @__PURE__ */ new Map();
-  for (const target of V3_ADAPTER_FILE_TARGETS) {
-    existing.set(target, await readAdapterTarget(root, target));
+  const selected = normalizeUpgradePlatforms(platforms);
+  const targets = /* @__PURE__ */ new Set();
+  for (const platform of selected) {
+    targets.add(primaryFileTarget(platform));
+    for (const mode of V3_MODE_NAMES) {
+      targets.add(modeEntryFileTarget(platform, mode));
+    }
+    for (const target of legacyAdapterTargetsForPlatform(platform, true)) {
+      targets.add(target);
+    }
+  }
+  return planPhysicalAdapterTargets(root, [...targets], selected);
+}
+async function planPhysicalAdapterTargets(root, targets, platforms) {
+  const ordered = orderAdapterTargets(targets);
+  const observations = await Promise.all(
+    ordered.map((target) => observeAdapterPhysicalTarget(root, target))
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    const group = groups.get(observation.physicalKey) ?? [];
+    group.push(observation);
+    groups.set(observation.physicalKey, group);
+  }
+  const plans = [];
+  for (const group of groups.values()) {
+    const members = group.sort(
+      (left, right) => adapterTargetOrder(left.target) - adapterTargetOrder(right.target)
+    );
+    assertPhysicalGroupComposable(members);
+    const beforeContent = members[0]?.beforeContent ?? null;
+    if (members.some((member) => member.beforeContent !== beforeContent)) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    const targetContent = composePhysicalAdapterContent(
+      beforeContent,
+      members,
+      platforms
+    );
+    if (targetContent === null || targetContent === beforeContent) continue;
+    const representative = members.find((member) => member.target === "agents") ?? members[0];
+    if (representative === void 0) continue;
+    const links = uniqueLinkIdentities(
+      members.flatMap((member) => member.linkIdentities)
+    );
+    plans.push({
+      target: representative.target,
+      beforeContent,
+      targetContent,
+      ...links.length > 0 ? {
+        resolvedTarget: representative.physicalRelative,
+        linkIdentities: links
+      } : {}
+    });
+  }
+  return plans.sort(
+    (left, right) => adapterTargetOrder(left.target) - adapterTargetOrder(right.target)
+  );
+}
+function orderAdapterTargets(targets) {
+  return [...new Set(targets)].sort(
+    (left, right) => adapterTargetOrder(left) - adapterTargetOrder(right)
+  );
+}
+function adapterTargetOrder(target) {
+  const index = V3_ADAPTER_FILE_TARGETS.indexOf(target);
+  return index < 0 ? Number.MAX_SAFE_INTEGER : index;
+}
+async function observeAdapterPhysicalTarget(root, target) {
+  const logicalPath = v3AdapterTargetPath(root, target);
+  const entry = await lstatOrNullAdapter(logicalPath);
+  if (entry === null) {
+    await assertAdapterPathSafe(root, logicalPath);
+    return {
+      target,
+      logicalPath,
+      physicalRelative: relativeAdapterPath(root, logicalPath),
+      physicalKey: `path:${relativeAdapterPath(root, logicalPath)}`,
+      beforeContent: null,
+      linkIdentities: []
+    };
+  }
+  if (entry.isSymbolicLink()) {
+    const resolved2 = await resolveObservedAdapterSymlinkChain(
+      root,
+      logicalPath
+    );
+    const physicalRelative2 = normalizeAdapterRelativePath(resolved2.relative);
+    return {
+      target,
+      logicalPath,
+      physicalRelative: physicalRelative2,
+      physicalKey: physicalFileKey(resolved2.entry),
+      beforeContent: await readFile(resolved2.path, "utf8"),
+      linkIdentities: resolved2.linkIdentities
+    };
+  }
+  if (!entry.isFile()) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const resolved = await realpath(logicalPath);
+  const resolvedRelative = await relativeWithinRealRoot(root, resolved);
+  if (resolvedRelative === null) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const resolvedEntry = await lstat(resolved);
+  if (!resolvedEntry.isFile() || resolvedEntry.isSymbolicLink()) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const physicalRelative = normalizeAdapterRelativePath(resolvedRelative);
+  return {
+    target,
+    logicalPath,
+    physicalRelative,
+    physicalKey: physicalFileKey(resolvedEntry),
+    beforeContent: await readFile(resolved, "utf8"),
+    linkIdentities: []
+  };
+}
+async function resolveObservedAdapterSymlinkChain(root, logicalPath) {
+  let current = path.resolve(logicalPath);
+  const seen = /* @__PURE__ */ new Set();
+  const linkIdentities = [];
+  for (let depth = 0; depth < 40; depth += 1) {
+    if (!isPathInsideRoot(root, current) || seen.has(current)) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+    seen.add(current);
+    const entry = await lstatOrNullAdapter(current);
+    if (entry === null) throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    if (!entry.isSymbolicLink()) {
+      if (!entry.isFile()) throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+      const resolved = await realpath(current);
+      const relative = await relativeWithinRealRoot(root, resolved);
+      if (relative === null || entry.nlink > 1) {
+        throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+      }
+      return { path: resolved, relative, entry, linkIdentities };
+    }
+    const linkTarget = await readlink(current, "utf8");
+    linkIdentities.push({
+      linkPath: relativeAdapterPath(root, current),
+      linkTarget
+    });
+    current = path.resolve(path.dirname(current), linkTarget);
+  }
+  throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+}
+function physicalFileKey(entry) {
+  if (entry.nlink > 1) {
+    throw new Error("MANCODE_V3_ADAPTER_HARDLINK_UNSAFE");
+  }
+  return `inode:${entry.dev}:${entry.ino}`;
+}
+function uniqueLinkIdentities(identities) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const identity of identities) {
+    const previous = byPath.get(identity.linkPath);
+    if (previous !== void 0 && previous.linkTarget !== identity.linkTarget) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    byPath.set(identity.linkPath, identity);
+  }
+  return [...byPath.values()].sort(
+    (left, right) => compareUtf8(left.linkPath, right.linkPath)
+  );
+}
+function isPathInsideRoot(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function normalizeAdapterRelativePath(value) {
+  return value.split(path.sep).join("/");
+}
+function compareUtf8(left, right) {
+  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
+}
+async function lstatOrNullAdapter(target) {
+  try {
+    return await lstat(target);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function assertPhysicalGroupComposable(group) {
+  if (group.length <= 1) return;
+  if (group.every((member) => isComposableEmbeddedAdapterTarget(member.target))) {
+    return;
   }
+  throw new Error("MANCODE_V3_ADAPTER_SHARED_TARGET_CONFLICT");
+}
+function composePhysicalAdapterContent(beforeContent, members, platforms) {
+  const memberTargets = new Set(members.map((member) => member.target));
+  let content = beforeContent;
+  for (const platform of platforms) {
+    const primary = primaryFileTarget(platform);
+    if (!memberTargets.has(primary)) continue;
+    content = applyPrimaryBootstrapContent(content, platform);
+  }
+  for (const member of members) {
+    if (isPrimaryAdapterTarget(member.target)) continue;
+    content = desiredAdapterTargetContent(member.target, content);
+  }
+  return content;
+}
+function isPrimaryAdapterTarget(target) {
+  return target === "claude-skill" || target === "cursor-rule" || target === "agents" || target === "copilot-instructions";
+}
+function applyPrimaryBootstrapContent(current, platform) {
+  switch (platform) {
+    case "claude-code":
+      return replaceManagedV3BlockText(
+        current ?? "",
+        CONTINUITY_CLAUDE_START_MARKER,
+        CONTINUITY_CLAUDE_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "cursor":
+      return managedFilePlan(
+        "cursor-rule",
+        current,
+        renderCursorRule(renderV3Bootstrap(platform))
+      ).targetContent;
+    case "codex":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(
+          removeLegacyAgentsBlocks(current ?? ""),
+          LEGACY_V3_CODEX_MARKERS
+        ),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "zcode":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(
+          removeLegacyAgentsBlocks(current ?? ""),
+          LEGACY_V3_ZCODE_MARKERS
+        ),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "kimi-code":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(
+          removeLegacyAgentsBlocks(current ?? ""),
+          LEGACY_KIMI_MARKERS
+        ),
+        V3_KIMI_START_MARKER,
+        V3_KIMI_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "qoder":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(current ?? "", LEGACY_QODER_MARKERS),
+        V3_QODER_START_MARKER,
+        V3_QODER_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "dsh":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(current ?? "", LEGACY_DSH_MARKERS),
+        V3_DSH_START_MARKER,
+        V3_DSH_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    case "copilot":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(
+          removeManagedBlock(current ?? ""),
+          LEGACY_V3_COPILOT_MARKERS
+        ),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+  }
+}
+function isComposableEmbeddedAdapterTarget(target) {
+  return target === "claude-skill" || target === "agents" || target === "copilot-instructions";
+}
+function desiredAdapterTargetContent(target, current) {
+  switch (target) {
+    case "claude-skill":
+      return replaceManagedV3BlockText(
+        current ?? "",
+        CONTINUITY_CLAUDE_START_MARKER,
+        CONTINUITY_CLAUDE_END_MARKER,
+        renderV3Bootstrap("claude-code")
+      );
+    case "cursor-rule":
+      return managedFilePlan(
+        target,
+        current,
+        renderCursorRule(renderV3Bootstrap("cursor"))
+      ).targetContent;
+    case "agents":
+      return renderAgentsBootstrapTarget(current ?? "");
+    case "copilot-instructions":
+      return replaceManagedV3BlockText(
+        removeLegacyV3Block(
+          removeManagedBlock(current ?? ""),
+          LEGACY_V3_COPILOT_MARKERS
+        ),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER,
+        renderV3Bootstrap("copilot")
+      );
+    default: {
+      const modeTarget = parseModeEntryFileTarget(target);
+      if (modeTarget !== null) {
+        const modeFileTarget = target;
+        return managedModeEntryPlan(
+          modeFileTarget,
+          current,
+          renderModeEntryForFileTarget(modeFileTarget)
+        ).targetContent;
+      }
+      const retirement = planLegacyAdapterRetirement(
+        /* @__PURE__ */ new Map([[target, current]])
+      ).find((plan) => plan.target === target);
+      return retirement?.targetContent ?? current;
+    }
+  }
+}
+function renderAgentsBootstrapTarget(existing) {
   const agents = removeLegacyV3Block(
     removeLegacyV3Block(
       removeLegacyV3Block(
         removeLegacyV3Block(
           removeLegacyV3Block(
-            removeLegacyAgentsBlocks(existing.get("agents") ?? ""),
+            removeLegacyAgentsBlocks(existing),
             LEGACY_V3_CODEX_MARKERS
           ),
           LEGACY_V3_ZCODE_MARKERS
@@ -310,7 +642,7 @@ async function planV3AdapterFiles(projectRoot) {
     ),
     LEGACY_DSH_MARKERS
   );
-  const nextAgents = replaceManagedV3BlockText(
+  return replaceManagedV3BlockText(
     replaceManagedV3BlockText(
       replaceManagedV3BlockText(
         replaceManagedV3BlockText(
@@ -336,125 +668,6 @@ async function planV3AdapterFiles(projectRoot) {
     V3_DSH_END_MARKER,
     renderV3Bootstrap("dsh")
   );
-  const legacyAdapterPlans = planLegacyAdapterRetirement(existing);
-  const plans = [
-    {
-      target: "claude-skill",
-      beforeContent: existing.get("claude-skill") ?? null,
-      targetContent: replaceManagedV3BlockText(
-        existing.get("claude-skill") ?? "",
-        CONTINUITY_CLAUDE_START_MARKER,
-        CONTINUITY_CLAUDE_END_MARKER,
-        renderV3Bootstrap("claude-code")
-      )
-    },
-    managedFilePlan(
-      "cursor-rule",
-      existing.get("cursor-rule") ?? null,
-      renderCursorRule(renderV3Bootstrap("cursor"))
-    ),
-    {
-      target: "agents",
-      beforeContent: existing.get("agents") ?? null,
-      targetContent: nextAgents
-    },
-    {
-      target: "copilot-instructions",
-      beforeContent: existing.get("copilot-instructions") ?? null,
-      targetContent: replaceManagedV3BlockText(
-        removeLegacyV3Block(
-          removeManagedBlock(existing.get("copilot-instructions") ?? ""),
-          LEGACY_V3_COPILOT_MARKERS
-        ),
-        V3_COPILOT_START_MARKER,
-        V3_COPILOT_END_MARKER,
-        renderV3Bootstrap("copilot")
-      )
-    },
-    ...V3_MODE_ENTRY_FILE_TARGETS.map(
-      (target) => managedModeEntryPlan(
-        target,
-        existing.get(target) ?? null,
-        renderModeEntryForFileTarget(target)
-      )
-    ),
-    ...legacyAdapterPlans
-  ];
-  return annotateWriteThroughPlans(root, plans);
-}
-async function annotateWriteThroughPlans(root, plans) {
-  return Promise.all(
-    plans.map(async (plan) => {
-      const resolved = await writeThroughResolvedPath(
-        root,
-        v3AdapterTargetPath(root, plan.target)
-      );
-      if (resolved === null) return plan;
-      const relative = await relativeWithinRealRoot(root, resolved);
-      if (relative === null) return plan;
-      return { ...plan, resolvedTarget: relative };
-    })
-  );
-}
-async function effectivePrimaryTarget(root, platform) {
-  const primary = primaryFileTarget(platform);
-  const resolved = await writeThroughResolvedPath(
-    root,
-    v3AdapterTargetPath(root, primary)
-  );
-  if (resolved === null) return primary;
-  const agentsPath = v3AdapterTargetPath(root, "agents");
-  const realAgents = await resolveAdapterSymlink(agentsPath);
-  if (realAgents !== null && path.resolve(resolved) === path.resolve(realAgents)) {
-    return "agents";
-  }
-  return primary;
-}
-async function planV3AdapterUpgradeFiles(projectRoot, platforms) {
-  const root = path.resolve(projectRoot);
-  const selected = normalizeUpgradePlatforms(platforms);
-  const targetSet = /* @__PURE__ */ new Set();
-  const effectivePrimary = /* @__PURE__ */ new Map();
-  for (const platform of selected) {
-    const primary = await effectivePrimaryTarget(root, platform);
-    effectivePrimary.set(platform, primary);
-    targetSet.add(primary);
-    for (const mode of V3_MODE_NAMES) {
-      targetSet.add(modeEntryFileTarget(platform, mode));
-    }
-    for (const target of legacyAdapterTargetsForPlatform(platform, true)) {
-      targetSet.add(target);
-    }
-  }
-  const existing = /* @__PURE__ */ new Map();
-  for (const target of targetSet) {
-    existing.set(target, await readAdapterTarget(root, target));
-  }
-  const desired = new Map(existing);
-  for (const platform of selected) {
-    planPlatformBootstrapUpgrade(
-      desired,
-      platform,
-      effectivePrimary.get(platform)
-    );
-    for (const mode of V3_MODE_NAMES) {
-      const target = modeEntryFileTarget(platform, mode);
-      const current = desired.get(target) ?? null;
-      desired.set(
-        target,
-        managedModeEntryPlan(target, current, renderV3ModeEntry(mode, platform)).targetContent
-      );
-    }
-  }
-  const plans = [...desired.entries()].filter(([target, targetContent]) => existing.get(target) !== targetContent).map(([target, targetContent]) => ({
-    target,
-    beforeContent: existing.get(target) ?? null,
-    targetContent: targetContent ?? ""
-  }));
-  const legacyPlans = planLegacyAdapterRetirement(existing).filter(
-    (legacyPlan) => !plans.some((candidate) => candidate.target === legacyPlan.target)
-  );
-  return annotateWriteThroughPlans(root, [...plans, ...legacyPlans]);
 }
 async function stageV3AdapterUpgradeFiles(projectRoot, operationId, plans) {
   if (!/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/.test(operationId)) {
@@ -493,18 +706,7 @@ async function applyV3AdapterFilePlan(projectRoot, plan) {
     throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
   }
   const target = v3AdapterTargetPath(root, plan.target);
-  const writePath = plan.resolvedTarget === void 0 ? target : path.join(root, plan.resolvedTarget);
-  if (plan.resolvedTarget !== void 0) {
-    const entry = await lstat(target).catch(() => null);
-    const resolved = entry?.isSymbolicLink() === true ? await resolveAdapterSymlink(target) : null;
-    const realWrite = await resolveAdapterSymlink(writePath);
-    if (resolved === null || realWrite === null || resolved !== realWrite) {
-      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
-    }
-    await assertAdapterPathSafe(root, writePath);
-  } else {
-    await assertAdapterPathSafe(root, target);
-  }
+  const writePath = await resolvePlannedAdapterWritePath(root, target, plan);
   const retiredBootstrapPlatform = retiredBootstrapPlatformFor(plan.target);
   if (retiredBootstrapPlatform !== null) {
     for (const retired of retiredBootstrapSpecs(
@@ -514,7 +716,10 @@ async function applyV3AdapterFilePlan(projectRoot, plan) {
       await assertAdapterPathSafe(root, retired.filePath);
     }
   }
-  const current = await readAdapterTarget(root, plan.target);
+  const current = await readFile(writePath, "utf8").catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") return null;
+    throw error;
+  });
   if (current === plan.targetContent) {
     if (retiredBootstrapPlatform !== null) {
       await removeRetiredBootstrapFiles(root, retiredBootstrapPlatform);
@@ -524,12 +729,123 @@ async function applyV3AdapterFilePlan(projectRoot, plan) {
   if (current !== plan.beforeContent) {
     throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
   }
+  const verifiedWritePath = await resolvePlannedAdapterWritePath(
+    root,
+    target,
+    plan
+  );
+  if (!await sameResolvedPath(verifiedWritePath, writePath)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
   await mkdir(path.dirname(writePath), { recursive: true });
   await atomicWrite(writePath, plan.targetContent);
   if (retiredBootstrapPlatform !== null) {
     await removeRetiredBootstrapFiles(root, retiredBootstrapPlatform);
   }
 }
+async function resolvePlannedAdapterWritePath(root, logicalTarget, plan) {
+  await assertAdapterPathSafe(root, logicalTarget);
+  if (plan.resolvedTarget === void 0) {
+    if (plan.linkIdentities !== void 0 && plan.linkIdentities.length > 0) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    const entry = await lstatOrNullAdapter(logicalTarget);
+    if (entry?.isSymbolicLink()) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    if (entry !== null && (!entry.isFile() || entry.nlink > 1)) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    return logicalTarget;
+  }
+  if (plan.linkIdentities !== void 0 && plan.linkIdentities.length === 0) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
+  const resolvedTarget = safePlannedRelativePath(root, plan.resolvedTarget);
+  await assertAdapterPathSafe(root, resolvedTarget);
+  const resolvedEntry = await lstatOrNullAdapter(resolvedTarget);
+  if (resolvedEntry === null || !resolvedEntry.isFile() || resolvedEntry.isSymbolicLink() || resolvedEntry.nlink > 1) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
+  if (plan.linkIdentities === void 0) {
+    const logicalEntry2 = await lstatOrNullAdapter(logicalTarget);
+    if (!logicalEntry2?.isSymbolicLink() || !await sameResolvedPath(logicalTarget, resolvedTarget)) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    return resolvedTarget;
+  }
+  await assertLinkIdentities(root, plan.linkIdentities, resolvedTarget);
+  const logicalEntry = await lstatOrNullAdapter(logicalTarget);
+  if (logicalEntry === null)
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  if (logicalEntry.isSymbolicLink()) {
+    const logicalRelative = relativeAdapterPath(root, logicalTarget);
+    if (!plan.linkIdentities?.some(
+      (identity) => identity.linkPath === logicalRelative
+    )) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+  } else if (!logicalEntry.isFile()) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  } else if (!await sameResolvedPath(logicalTarget, resolvedTarget)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
+  return resolvedTarget;
+}
+function safePlannedRelativePath(root, relative) {
+  if (typeof relative !== "string" || !relative.trim() || path.isAbsolute(relative) || relative.split(/[\\/]/u).some((segment) => segment === ".." || !segment)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
+  const resolved = path.resolve(root, relative);
+  if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+  }
+  return resolved;
+}
+async function readV3AdapterFilePlanContent(projectRoot, plan) {
+  const root = path.resolve(projectRoot);
+  const logicalTarget = v3AdapterTargetPath(root, plan.target);
+  const readPath = await resolvePlannedAdapterWritePath(
+    root,
+    logicalTarget,
+    plan
+  );
+  try {
+    const entry = await lstat(readPath);
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.nlink > 1) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    return await readFile(readPath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function assertLinkIdentities(root, identities, resolvedTarget) {
+  for (const identity of identities) {
+    const linkPath = safePlannedRelativePath(root, identity.linkPath);
+    await assertAdapterPathSafe(root, linkPath);
+    const entry = await lstatOrNullAdapter(linkPath);
+    if (entry === null || !entry.isSymbolicLink()) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    const linkTarget = await readlink(linkPath, "utf8");
+    if (linkTarget !== identity.linkTarget) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+    const actual = await resolveAdapterSymlink(linkPath);
+    if (actual === null || !await sameResolvedPath(actual, resolvedTarget)) {
+      throw new Error("MANCODE_V3_ADAPTER_TARGET_CONFLICT");
+    }
+  }
+}
+async function sameResolvedPath(left, right) {
+  const [leftReal, rightReal] = await Promise.all([
+    realpath(left).catch(() => path.resolve(left)),
+    realpath(right).catch(() => path.resolve(right))
+  ]);
+  return path.resolve(leftReal) === path.resolve(rightReal);
+}
 async function stageV3Adapter(projectRoot, platform) {
   const root = path.resolve(projectRoot);
   await assertPlatformAdapterPathsSafe(root, platform);
@@ -1248,110 +1564,6 @@ function primaryFileTarget(platform) {
       return "copilot-instructions";
   }
 }
-function planPlatformBootstrapUpgrade(desired, platform, targetOverride) {
-  const target = targetOverride ?? primaryFileTarget(platform);
-  const current = desired.get(target) ?? null;
-  switch (platform) {
-    case "claude-code":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          current ?? "",
-          CONTINUITY_CLAUDE_START_MARKER,
-          CONTINUITY_CLAUDE_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "cursor":
-      desired.set(
-        target,
-        managedFilePlan(
-          target,
-          current,
-          renderCursorRule(renderV3Bootstrap(platform))
-        ).targetContent
-      );
-      return;
-    case "codex":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(
-            removeLegacyAgentsBlocks(current ?? ""),
-            LEGACY_V3_CODEX_MARKERS
-          ),
-          V3_CODEX_START_MARKER,
-          V3_CODEX_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "zcode":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(
-            removeLegacyAgentsBlocks(current ?? ""),
-            LEGACY_V3_ZCODE_MARKERS
-          ),
-          V3_ZCODE_START_MARKER,
-          V3_ZCODE_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "kimi-code":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(
-            removeLegacyAgentsBlocks(current ?? ""),
-            LEGACY_KIMI_MARKERS
-          ),
-          V3_KIMI_START_MARKER,
-          V3_KIMI_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "qoder":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(current ?? "", LEGACY_QODER_MARKERS),
-          V3_QODER_START_MARKER,
-          V3_QODER_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "dsh":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(current ?? "", LEGACY_DSH_MARKERS),
-          V3_DSH_START_MARKER,
-          V3_DSH_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-      return;
-    case "copilot":
-      desired.set(
-        target,
-        replaceManagedV3BlockText(
-          removeLegacyV3Block(
-            removeManagedBlock(current ?? ""),
-            LEGACY_V3_COPILOT_MARKERS
-          ),
-          V3_COPILOT_START_MARKER,
-          V3_COPILOT_END_MARKER,
-          renderV3Bootstrap(platform)
-        )
-      );
-  }
-}
 function primaryManagedTargetSpec(platform) {
   const target = targetFor(platform);
   switch (platform) {
@@ -2014,8 +2226,13 @@ async function replaceUnsafeV3AdapterSymlinks(entries) {
     if (entry.kind !== "symlink" || !entry.finalTarget || entry.resolvedTo === null) {
       continue;
     }
+    const projectRoot = entry.projectRoot;
+    if (projectRoot === void 0 || await relativeWithinRealRoot(projectRoot, entry.resolvedTo) === null) {
+      continue;
+    }
     const resolvedEntry = await lstat(entry.resolvedTo).catch(() => null);
-    if (resolvedEntry === null || !resolvedEntry.isFile()) continue;
+    if (resolvedEntry === null || !resolvedEntry.isFile() || resolvedEntry.isSymbolicLink())
+      continue;
     const content = await readFile(entry.resolvedTo);
     await rm(entry.target, { force: true });
     await writeFile(entry.target, content);
@@ -2056,7 +2273,8 @@ async function findUnsafeAdapterPathEntry(root, target) {
       relative,
       kind: "outside-root",
       finalTarget: false,
-      resolvedTo: null
+      resolvedTo: null,
+      projectRoot: root
     };
   }
   const rootEntry = await lstat(root);
@@ -2066,7 +2284,8 @@ async function findUnsafeAdapterPathEntry(root, target) {
       relative,
       kind: "root-symlink",
       finalTarget: false,
-      resolvedTo: null
+      resolvedTo: null,
+      projectRoot: root
     };
   }
   const segments = relative.split(path.sep);
@@ -2081,7 +2300,8 @@ async function findUnsafeAdapterPathEntry(root, target) {
           relative,
           kind: "symlink",
           finalTarget: index === segments.length - 1,
-          resolvedTo: await resolveAdapterSymlink(current)
+          resolvedTo: await resolveAdapterSymlinkForInspection(current),
+          projectRoot: root
         };
       }
       if (index < segments.length - 1 && !entry.isDirectory()) {
@@ -2090,7 +2310,8 @@ async function findUnsafeAdapterPathEntry(root, target) {
           relative,
           kind: "not-directory",
           finalTarget: false,
-          resolvedTo: null
+          resolvedTo: null,
+          projectRoot: root
         };
       }
     } catch (error) {
@@ -2107,6 +2328,29 @@ async function resolveAdapterSymlink(linkPath) {
     return null;
   }
 }
+async function resolveAdapterSymlinkForInspection(linkPath) {
+  let current = path.resolve(linkPath);
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 40; depth += 1) {
+    if (seen.has(current)) return null;
+    seen.add(current);
+    const entry = await lstatOrNullAdapter(current);
+    if (entry === null) return current;
+    if (!entry.isSymbolicLink()) {
+      return await realpath(current).catch(() => null) ?? current;
+    }
+    let target;
+    try {
+      target = await readlink(current, "utf8");
+    } catch {
+      return null;
+    }
+    current = path.resolve(
+      path.isAbsolute(target) ? target : path.join(path.dirname(current), target)
+    );
+  }
+  return null;
+}
 async function writeThroughResolvedPath(root, target) {
   const entry = await lstat(target).catch((error) => {
     if (isNodeError(error) && error.code === "ENOENT") return null;
@@ -2303,14 +2547,14 @@ async function delay(milliseconds) {
 }
 
 export {
-  ACCEPTED_STATE_NARRATIVE_GUIDANCE,
-  INTERFACE_EMOJI_ICON_GUIDANCE,
-  VISUAL_DIRECTION_SELECTION_GUIDANCE,
   DEFAULT_MANCODE_START_MARKER,
   DEFAULT_MANCODE_END_MARKER,
   removeManagedBlock,
   hasManagedBlock,
   replaceManagedBlock,
+  ACCEPTED_STATE_NARRATIVE_GUIDANCE,
+  INTERFACE_EMOJI_ICON_GUIDANCE,
+  VISUAL_DIRECTION_SELECTION_GUIDANCE,
   V3_ADAPTER_VERSION,
   V3_ADAPTER_MANAGED_MARKER,
   V3_MODE_ENTRY_MANAGED_MARKER,
@@ -2323,6 +2567,7 @@ export {
   planV3AdapterUpgradeFiles,
   stageV3AdapterUpgradeFiles,
   applyV3AdapterFilePlan,
+  readV3AdapterFilePlanContent,
   stageV3Adapter,
   v3AdapterTargetPath,
   assertV3AdapterTargetSafe,
@@ -2339,4 +2584,4 @@ export {
   replaceUnsafeV3AdapterSymlinks,
   writeThroughResolvedPath
 };
-//# sourceMappingURL=chunk-RDPFQODS.js.map
+//# sourceMappingURL=chunk-WJ6WARGG.js.map