mancode 0.3.10 → 0.3.12

package/dist/chunk-CFC3HBNA.js

@@ -0,0 +1,1290 @@
+// src/installers/v3-adapter.ts
+import {
+  lstat,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  rmdir,
+  writeFile
+} from "fs/promises";
+import path from "path";
+
+// src/installers/managed-block.ts
+var DEFAULT_MANCODE_START_MARKER = "<!-- mancode:start -->";
+var DEFAULT_MANCODE_END_MARKER = "<!-- mancode:end -->";
+function removeManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  if (start === null && end === null) return existing;
+  if (start === null || end === null) return existing;
+  if (end.start < start.start) return existing;
+  const before = existing.slice(0, start.start);
+  const after = existing.slice(end.end);
+  const merged = `${before}${after}`;
+  return cleanUpOrphanedNewlines(merged);
+}
+function hasManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  return start !== null && end !== null && end.start > start.start;
+}
+function cleanUpOrphanedNewlines(content) {
+  const trimmed = content.replace(/\n{3,}/gu, "\n\n").replace(/\n+$/u, "\n");
+  return trimmed || "";
+}
+function replaceManagedBlock(existing, block, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const normalizedBlock = normalizeManagedBlock(block, startMarker, endMarker);
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  if (start === null !== (end === null)) {
+    throw new Error("managed block is malformed: missing start or end marker");
+  }
+  if (start === null && end === null) {
+    const trimmedExisting = trimTrailingNewlines(existing);
+    if (!trimmedExisting) return `${normalizedBlock}
+`;
+    return `${trimmedExisting}
+
+${normalizedBlock}
+`;
+  }
+  if (!start || !end) {
+    throw new Error("managed block is malformed: missing start or end marker");
+  }
+  if (end.start < start.start) {
+    throw new Error("managed block is malformed: end marker precedes start");
+  }
+  return `${existing.slice(0, start.start)}${normalizedBlock}${existing.slice(
+    end.end
+  )}`;
+}
+function normalizeManagedBlock(block, startMarker, endMarker) {
+  const trimmedBlock = block.trim();
+  const hasStart = trimmedBlock.startsWith(startMarker);
+  const hasEnd = trimmedBlock.endsWith(endMarker);
+  if (hasStart && hasEnd) return trimmedBlock;
+  if (hasStart || hasEnd) {
+    throw new Error("managed block content includes only one marker");
+  }
+  return `${startMarker}
+${trimmedBlock}
+${endMarker}`;
+}
+function trimTrailingNewlines(value) {
+  return value.replace(/\n+$/u, "");
+}
+function findMarkerLine(content, marker) {
+  let offset = 0;
+  let inFence = null;
+  for (const lineWithBreak of content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+    const rawLine = lineWithBreak[0];
+    if (!rawLine) break;
+    const line = rawLine.replace(/\n$/u, "").replace(/\r$/u, "");
+    const fence = line.match(/^(`{3,}|~{3,})/u)?.[1];
+    if (fence) {
+      const char = fence[0];
+      if (!inFence) {
+        inFence = { char, length: fence.length };
+      } else if (inFence.char === char && fence.length >= inFence.length) {
+        inFence = null;
+      }
+    } else if (!inFence && line === marker) {
+      return {
+        start: offset,
+        end: offset + marker.length
+      };
+    }
+    offset += rawLine.length;
+  }
+  return null;
+}
+
+// src/installers/v3-adapter.ts
+var V3_ADAPTER_VERSION = "3";
+var V3_ADAPTER_MANAGED_MARKER = "<!-- Managed by mancode:v3-adapter. Do not edit this marker. -->";
+var V3_MODE_ENTRY_MANAGED_MARKER = "<!-- Managed by mancode:v3-mode-entry. Do not edit this marker. -->";
+var V3_MODE_NAMES = [
+  "manba",
+  "man",
+  "manteam",
+  "manps",
+  "mansolo"
+];
+var LEGACY_MODE_ENTRY_MANAGED_MARKERS = [
+  "<!-- Managed by mancode:claude-skill. Do not edit this marker. -->",
+  "<!-- Managed by mancode:codex-skill. Do not edit this file manually. -->",
+  "<!-- Managed by mancode:zcode-skill. Do not edit this file manually. -->",
+  "<!-- Managed by mancode:mode-file. Do not edit this file manually. -->"
+];
+var GENERATED_CLAUDE_HOOK_COMMANDS = /* @__PURE__ */ new Set([
+  'node ".mancode/hooks/session-start.mjs"',
+  'node ".mancode/hooks/user-prompt-submit.mjs"',
+  "bash .mancode/hooks/session-start.sh",
+  "bash .mancode/hooks/user-prompt-submit.sh"
+]);
+var LEGACY_CLAUDE_SKILL_PATHS = /* @__PURE__ */ new Set([
+  ".claude/skills/mancode-solo.md",
+  ".claude/skills/mancode-man8.md",
+  ".claude/skills/mancode-man.md",
+  ".claude/skills/mancode-mansolo.md"
+]);
+var LEGACY_CLAUDE_SETTINGS_RAW_HINTS = [
+  ".mancode/hooks/session-start.",
+  ".mancode/hooks/user-prompt-submit.",
+  ...LEGACY_CLAUDE_SKILL_PATHS
+];
+var V3_CODEX_START_MARKER = "<!-- mancode:v3:codex:start -->";
+var V3_CODEX_END_MARKER = "<!-- mancode:v3:codex:end -->";
+var V3_ZCODE_START_MARKER = "<!-- mancode:v3:zcode:start -->";
+var V3_ZCODE_END_MARKER = "<!-- mancode:v3:zcode:end -->";
+var V3_COPILOT_START_MARKER = "<!-- mancode:v3:copilot:start -->";
+var V3_COPILOT_END_MARKER = "<!-- mancode:v3:copilot:end -->";
+var LEGACY_CODEX_START_MARKER = "<!-- mancode:start -->";
+var LEGACY_CODEX_END_MARKER = "<!-- mancode:end -->";
+var LEGACY_ZCODE_START_MARKER = "<!-- mancode:zcode:start -->";
+var LEGACY_ZCODE_END_MARKER = "<!-- mancode:zcode:end -->";
+var RETRIABLE_ADAPTER_READ_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+var ADAPTER_READ_MAX_ATTEMPTS = 4;
+var ADAPTER_READ_RETRY_DELAY_MS = 25;
+var V3_MODE_ENTRY_FILE_TARGETS = V3_MODE_NAMES.flatMap((mode) => [
+  `claude-mode-${mode}`,
+  `agents-mode-${mode}`,
+  `cursor-mode-${mode}`,
+  `copilot-mode-${mode}`
+]);
+var V3_LEGACY_ADAPTER_FILE_TARGETS = [
+  "claude-settings",
+  "claude-legacy-solo",
+  "cursor-legacy-context",
+  "cursor-legacy-practice",
+  "cursor-legacy-solo",
+  "cursor-legacy-manba",
+  "cursor-legacy-man",
+  "cursor-legacy-manteam",
+  "cursor-legacy-manps",
+  "cursor-legacy-mamba",
+  "cursor-legacy-man8",
+  ...["mamba", "man8"].flatMap((mode) => [
+    `claude-alias-${mode}`,
+    `agents-alias-${mode}`,
+    `cursor-alias-${mode}`,
+    `copilot-alias-${mode}`
+  ])
+];
+var V3_ADAPTER_FILE_TARGETS = [
+  "claude-skill",
+  "cursor-rule",
+  "agents",
+  "copilot-instructions",
+  ...V3_MODE_ENTRY_FILE_TARGETS,
+  ...V3_LEGACY_ADAPTER_FILE_TARGETS
+];
+async function planV3AdapterFiles(projectRoot) {
+  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 agents = removeLegacyAgentsBlocks(existing.get("agents") ?? "");
+  const nextAgents = replaceManagedV3BlockText(
+    replaceManagedV3BlockText(
+      agents,
+      V3_CODEX_START_MARKER,
+      V3_CODEX_END_MARKER,
+      renderV3Bootstrap("codex")
+    ),
+    V3_ZCODE_START_MARKER,
+    V3_ZCODE_END_MARKER,
+    renderV3Bootstrap("zcode")
+  );
+  const legacyAdapterPlans = planLegacyAdapterRetirement(existing);
+  const plans = [
+    managedFilePlan(
+      "claude-skill",
+      existing.get("claude-skill") ?? null,
+      renderClaudeSkill(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(
+        removeManagedBlock(existing.get("copilot-instructions") ?? ""),
+        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 plans;
+}
+async function applyV3AdapterFilePlan(projectRoot, plan) {
+  const root = path.resolve(projectRoot);
+  if (!V3_ADAPTER_FILE_TARGETS.includes(plan.target)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
+  }
+  if (typeof plan.targetContent !== "string" || !plan.targetContent.trim()) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
+  }
+  const target = v3AdapterTargetPath(root, plan.target);
+  await assertAdapterPathSafe(root, target);
+  await mkdir(path.dirname(target), { recursive: true });
+  await atomicWrite(target, plan.targetContent);
+}
+async function stageV3Adapter(projectRoot, platform) {
+  const root = path.resolve(projectRoot);
+  await assertPlatformAdapterPathsSafe(root, platform);
+  const target = targetFor(platform);
+  const content = await renderV3AdapterCandidate(root, platform);
+  const stagingTarget = path.join(
+    ".mancode",
+    "staging",
+    "adapters",
+    "v3",
+    platform,
+    target
+  );
+  const destination = path.join(root, stagingTarget);
+  await assertAdapterPathSafe(root, destination);
+  await mkdir(path.dirname(destination), { recursive: true });
+  await atomicWrite(destination, content);
+  const modeEntries = [];
+  for (const mode of V3_MODE_NAMES) {
+    const modeTarget = path.relative(
+      root,
+      v3ModeEntryPath(root, platform, mode)
+    );
+    const modeStagingTarget = path.join(
+      ".mancode",
+      "staging",
+      "adapters",
+      "v3",
+      platform,
+      modeTarget
+    );
+    const modeDestination = path.join(root, modeStagingTarget);
+    await assertAdapterPathSafe(root, modeDestination);
+    await mkdir(path.dirname(modeDestination), { recursive: true });
+    await atomicWrite(modeDestination, renderV3ModeEntry(mode, platform));
+    modeEntries.push({
+      mode,
+      target: modeTarget,
+      stagingTarget: modeStagingTarget
+    });
+  }
+  return { platform, target, stagingTarget, modeEntries };
+}
+function v3AdapterTargetPath(projectRoot, target) {
+  const root = path.resolve(projectRoot);
+  const modeTarget = parseModeEntryFileTarget(target);
+  if (modeTarget !== null) {
+    return v3ModeEntryPath(root, modeTarget.platform, modeTarget.mode);
+  }
+  const legacyTarget = legacyAdapterRelativePath(target);
+  if (legacyTarget !== null) return path.join(root, legacyTarget);
+  switch (target) {
+    case "claude-skill":
+      return path.join(root, ".claude", "skills", "mancode-v3", "SKILL.md");
+    case "cursor-rule":
+      return path.join(root, ".cursor", "rules", "mancode-v3.mdc");
+    case "agents":
+      return path.join(root, "AGENTS.md");
+    case "copilot-instructions":
+      return path.join(root, ".github", "copilot-instructions.md");
+  }
+  throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
+}
+async function assertV3AdapterTargetSafe(projectRoot, target) {
+  const root = path.resolve(projectRoot);
+  await assertAdapterPathSafe(root, v3AdapterTargetPath(root, target));
+}
+function v3ModeEntryPath(projectRoot, platform, mode) {
+  const root = path.resolve(projectRoot);
+  switch (platform) {
+    case "claude-code":
+      return path.join(root, ".claude", "skills", mode, "SKILL.md");
+    case "codex":
+    case "zcode":
+      return path.join(root, ".agents", "skills", mode, "SKILL.md");
+    case "cursor":
+      return path.join(root, ".cursor", "commands", `${mode}.md`);
+    case "copilot":
+      return path.join(root, ".github", "prompts", `${mode}.prompt.md`);
+  }
+}
+async function installV3Adapter(projectRoot, platform) {
+  const root = path.resolve(projectRoot);
+  await assertV3AdapterInstallable(root, platform);
+  const content = renderV3Bootstrap(platform);
+  switch (platform) {
+    case "claude-code":
+      await writeManagedFile(
+        path.join(root, ".claude", "skills", "mancode-v3", "SKILL.md"),
+        renderClaudeSkill(content)
+      );
+      break;
+    case "cursor":
+      await writeManagedFile(
+        path.join(root, ".cursor", "rules", "mancode-v3.mdc"),
+        renderCursorRule(content)
+      );
+      break;
+    case "codex":
+      await replaceManagedV3Block(
+        path.join(root, "AGENTS.md"),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER,
+        content,
+        [
+          [LEGACY_CODEX_START_MARKER, LEGACY_CODEX_END_MARKER],
+          [LEGACY_ZCODE_START_MARKER, LEGACY_ZCODE_END_MARKER]
+        ]
+      );
+      break;
+    case "copilot":
+      await replaceManagedV3Block(
+        path.join(root, ".github", "copilot-instructions.md"),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER,
+        content,
+        [[LEGACY_CODEX_START_MARKER, LEGACY_CODEX_END_MARKER]]
+      );
+      break;
+    case "zcode":
+      await replaceManagedV3Block(
+        path.join(root, "AGENTS.md"),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER,
+        content,
+        [
+          [LEGACY_CODEX_START_MARKER, LEGACY_CODEX_END_MARKER],
+          [LEGACY_ZCODE_START_MARKER, LEGACY_ZCODE_END_MARKER]
+        ]
+      );
+      break;
+  }
+  await retireLegacyPlatformFiles(root, platform);
+  for (const mode of V3_MODE_NAMES) {
+    await writeV3ModeEntry(
+      v3ModeEntryPath(root, platform, mode),
+      renderV3ModeEntry(mode, platform)
+    );
+  }
+  return inspectV3Adapter(root, platform);
+}
+async function assertV3AdapterInstallable(projectRoot, platform) {
+  const root = path.resolve(projectRoot);
+  await assertPlatformAdapterPathsSafe(root, platform);
+  await assertV3ModeEntriesWritable(root, platform);
+  await renderV3AdapterCandidate(root, platform);
+  const existing = /* @__PURE__ */ new Map();
+  for (const target of legacyAdapterTargetsForPlatform(platform, true)) {
+    existing.set(target, await readAdapterTarget(root, target));
+  }
+  planLegacyAdapterRetirement(existing);
+}
+async function inspectV3Adapter(projectRoot, platform) {
+  const root = path.resolve(projectRoot);
+  await assertPlatformAdapterPathsSafe(root, platform);
+  const target = targetFor(platform);
+  const bootstrapInstalled = await adapterTargetPresent(root, platform);
+  const modeEntriesInstalled = (await Promise.all(
+    V3_MODE_NAMES.map(
+      (mode) => v3ModeEntryPresent(v3ModeEntryPath(root, platform, mode))
+    )
+  )).every(Boolean);
+  const installed = bootstrapInstalled && modeEntriesInstalled;
+  return {
+    version: V3_ADAPTER_VERSION,
+    installed,
+    ready: installed,
+    target,
+    detail: installed ? "V3 bootstrap and original mode entries are present; session identity is explicit-required." : "V3 bootstrap or one of its original mode entries is not installed.",
+    capabilities: capabilitiesFor(platform)
+  };
+}
+async function inspectV3AdapterVersions(projectRoot) {
+  const platforms = [
+    "claude-code",
+    "codex",
+    "cursor",
+    "copilot",
+    "zcode"
+  ];
+  const entries = await Promise.all(
+    platforms.map(async (platform) => {
+      const status = await inspectV3Adapter(projectRoot, platform);
+      return [platform, status.ready ? status.version : "missing"];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+async function removeV3Adapter(projectRoot, platform) {
+  const root = path.resolve(projectRoot);
+  await assertPlatformAdapterPathsSafe(root, platform);
+  let preserveSharedModeEntries = false;
+  switch (platform) {
+    case "claude-code":
+      await removeManagedFile(
+        path.join(root, ".claude", "skills", "mancode-v3", "SKILL.md")
+      );
+      break;
+    case "cursor":
+      await removeManagedFile(
+        path.join(root, ".cursor", "rules", "mancode-v3.mdc")
+      );
+      break;
+    case "codex":
+      await removeManagedV3Block(
+        path.join(root, "AGENTS.md"),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER
+      );
+      preserveSharedModeEntries = await managedBlockPresent(
+        path.join(root, "AGENTS.md"),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER
+      );
+      break;
+    case "copilot":
+      await removeManagedV3Block(
+        path.join(root, ".github", "copilot-instructions.md"),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER
+      );
+      break;
+    case "zcode":
+      await removeManagedV3Block(
+        path.join(root, "AGENTS.md"),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER
+      );
+      preserveSharedModeEntries = await managedBlockPresent(
+        path.join(root, "AGENTS.md"),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER
+      );
+      break;
+  }
+  if (!preserveSharedModeEntries) {
+    for (const mode of V3_MODE_NAMES) {
+      await removeV3ModeEntry(v3ModeEntryPath(root, platform, mode));
+    }
+  }
+  await removeRetiredLegacyPlatformFiles(root, platform);
+}
+function renderV3Bootstrap(platform) {
+  const platformLabel = platformLabelFor(platform);
+  const sessionCreationGuidance = platform === "codex" || platform === "zcode" ? "When status has no `currentSession`, first reuse any explicit session ID already returned in this conversation. Only when neither exists, create one once with `mancode context session new --client codex` in Codex or `mancode context session new --client zcode` in ZCode." : `When status has no \`currentSession\`, first reuse any explicit session ID already returned in this conversation. Only when neither exists, create one once with \`mancode context session new --client ${platform}\`.`;
+  const spikePlatform = platform === "codex" || platform === "zcode" ? "the active Codex or ZCode host" : platform;
+  const modeEntry = capabilitiesFor(platform).nativeModeEntry ? "Use the platform mode entry only as a shortcut; resolve a Context Pack first." : "This platform has no native V3 mode entry; use the CLI commands explicitly.";
+  return [
+    "# mancode V3 bootstrap",
+    "",
+    V3_ADAPTER_MANAGED_MARKER,
+    "",
+    `- Platform: ${platformLabel}. This file is a non-authoritative bootstrap.`,
+    "- Locate the project root before running mancode commands.",
+    "- First run `mancode status --json` from the project root.",
+    "- An explicitly invoked original `man`, `manba`, `manteam`, `manps`, or `mansolo` entry supplies its authorized action. Its mode-specific steps override conflicting generic no-task or mutation guidance below.",
+    "- In particular, `manps` may run local health scans without an actor, session, or TaskRef. `mansolo` needs them only for an explicit governed handoff.",
+    '- If status has no `localIdentity.actorId`, ask for a display name and run `mancode team identity create --name "<display name>"` before creating a session.',
+    "- If status reports `currentSession`, reuse it. `currentTask: null` and `MANCODE_TASK_REQUIRED` do not make a session stale.",
+    `- ${sessionCreationGuidance} Pass its returned \`sessionId\` as \`--session <id>\` to later commands; an \`export\` inside one command tool does not persist to later command tools.`,
+    '- Outside an invoked original mode entry, if no current task and no task is explicitly supplied, report "no task bound" and stop. Do not probe workflow subcommands to work around `MANCODE_TASK_REQUIRED`.',
+    "- Bootstrap discovery is read-only: before the operator explicitly requests task work, do not run `mancode init`, `mancode migrate`, `mancode workflow`, or inspect mancode installed package/source.",
+    "- With an existing or supplied task, read its Context Pack with `mancode context show --purpose orient --session <id>`; for anonymous diagnosis, include an explicit `--task <namespace:id>`.",
+    "- After an operator explicitly requests task work, perform mutations only through `mancode workflow`, `mancode team`, and `mancode context` commands with their required revision and session arguments.",
+    "- For a mode entry, request the matching Context Pack purpose: `plan`, `implement`, `review`, `verify`, or `handoff`.",
+    "- Do not persist task, mode, or session state in this adapter file or any legacy state file.",
+    `- ${modeEntry}`,
+    `- No approved session or prompt hook is assumed. After a real-host spike is recorded for ${spikePlatform}, a verified host may provide MANCODE_HOST_SESSION_KEY; otherwise mutations require an explicit \`--session\`.`
+  ].join("\n");
+}
+function renderV3ModeEntry(mode, platform) {
+  const definition = V3_MODE_DEFINITIONS[mode];
+  const sessionCreationGuidance = platform === "codex" || platform === "zcode" ? "If status has no current session, reuse an explicit session ID already retained in this conversation. Only if neither exists, run `mancode context session new --client codex` in Codex or `mancode context session new --client zcode` in ZCode exactly once, then retain the returned session ID." : `If status has no current session, reuse an explicit session ID already retained in this conversation. Only if neither exists, run \`mancode context session new --client ${platform}\` exactly once and retain the returned session ID.`;
+  const authoritySteps = mode === "manps" ? [
+    "1. Run `mancode status --json` from the project root and require active V3 authority.",
+    "2. Run the health action below directly. A local scan needs no TaskRef, actor identity, or explicit session.",
+    "3. Never read or write legacy mode authority before or after the scan."
+  ] : mode === "mansolo" ? [
+    "1. Run `mancode status --json` from the project root. Never read or write legacy mode authority.",
+    "2. If no governed task is being handed off, continue with focused solo work without creating a persistent mode, actor, session, or TaskRef.",
+    "3. For an explicit governed handoff, ensure `localIdentity.actorId`, reuse or create the current session, and bind the existing TaskRef before running the handoff action below.",
+    "4. For that governed task only, read `mancode context show --purpose implement --session <id>` using the bound or explicit TaskRef."
+  ] : [
+    "1. Run `mancode status --json` from the project root. Never read or write the legacy authority file.",
+    '2. If `localIdentity.actorId` is absent, ask for a display name and run `mancode team identity create --name "<display name>"`.',
+    `3. Reuse \`currentSession.sessionId\` when present. ${sessionCreationGuidance}`,
+    "4. Reuse the current TaskRef. To bind a supplied existing task, run `mancode context resume <namespace:ULID> --session <id>`.",
+    `5. For an existing task, read only the needed Context Pack with \`mancode context show --purpose ${definition.contextPurpose} --session <id>\`; include \`--task <namespace:ULID>\` when it is not yet bound. For a new task, create it through the mode action first, then read the returned TaskRef's Context Pack.`
+  ];
+  const frontmatter = [
+    "---",
+    ...platform === "claude-code" || platform === "codex" || platform === "zcode" ? [`name: ${mode}`] : [],
+    ...platform === "copilot" ? ["agent: 'agent'"] : [],
+    `description: ${JSON.stringify(definition.description)}`,
+    "---"
+  ];
+  const mutationGuidance = mode === "manps" ? "The local scan and an explicitly requested remediation do not require a TaskRef, workflow revision, actor, or session. Never turn their report files into workflow authority." : mode === "mansolo" ? "Only an explicit governed handoff mutation requires the bound TaskRef, explicit session, and latest expected revision. Ordinary focused solo work persists no mode state." : "For every mutation, use the TaskRef, explicit session, and latest expected revision reported by V3. Do not emulate the legacy `--step` protocol or persist mode state in an adapter file.";
+  return [
+    ...frontmatter,
+    "",
+    V3_MODE_ENTRY_MANAGED_MARKER,
+    "",
+    `# mancode V3 mode: ${mode}`,
+    "",
+    `Purpose: ${definition.purpose}.`,
+    "",
+    "## Enter through V3 authority",
+    "",
+    ...authoritySteps,
+    "",
+    "## Mode action",
+    "",
+    ...definition.actions,
+    "",
+    mutationGuidance,
+    ""
+  ].join("\n");
+}
+var V3_MODE_DEFINITIONS = {
+  man: {
+    description: "Plan and execute governed work through mancode V3.",
+    purpose: "clarify, plan, implement, verify, and review governed work",
+    contextPurpose: "plan",
+    actions: [
+      '- For a new task, run `mancode workflow create man "<task>" --session <id>`.',
+      "- Finalize requirements with `mancode workflow requirements <namespace:ULID> finalize --file <requirements.json> --expected-revision <n> --session <id>`.",
+      "- Revise or confirm the plan with `mancode workflow plan <namespace:ULID> revise|confirm --expected-revision <n> ... --session <id>`.",
+      "- Apply verification and review ledgers with their V3 `apply --file` commands, then use `mancode workflow complete <namespace:ULID> --expected-revision <n> --session <id>`."
+    ]
+  },
+  manba: {
+    description: "Diagnose and verify a bug through mancode V3.",
+    purpose: "reproduce, diagnose, fix, and verify a regression",
+    contextPurpose: "implement",
+    actions: [
+      '- For a new diagnostic task, run `mancode workflow create manba "<task>" --session <id>`.',
+      "- When this is a child investigation, add `--parent <namespace:ULID>`; report and merge the typed outcome through the V3 child commands.",
+      "- Change lifecycle only with `mancode workflow update <namespace:ULID> --status <status> --expected-revision <n> --session <id>` and finish with `workflow complete` plus the typed `--outcome`."
+    ]
+  },
+  manteam: {
+    description: "Coordinate shared governed work through mancode V3.",
+    purpose: "plan and execute work with explicit team ownership and handoff",
+    contextPurpose: "plan",
+    actions: [
+      "- Confirm team membership with `mancode team status`; join invited participants before assigning shared work.",
+      '- For a new shared task, run `mancode workflow create manteam "<task>" --visibility shared --coordination team --confirm-shared --session <id>`.',
+      "- Use claims, checkpoints, sync, and handoffs through `mancode team`; never infer ownership from an adapter prompt.",
+      "- Use the same V3 requirements, plan, verification, review, and completion commands as `man`, adding `--sync` whenever the active transport requires it."
+    ]
+  },
+  manps: {
+    description: "Inspect project health through the existing manps command.",
+    purpose: "scan project health and review bounded remediation",
+    contextPurpose: "review",
+    actions: [
+      "- Run `mancode manps [area]` through the same public command entry (`all`, `deps`, `security`, `dead-code`, or `config`).",
+      "- Add `--remediate` only when the operator explicitly requests an interactive remediation review."
+    ]
+  },
+  mansolo: {
+    description: "Return to focused solo execution under V3 authority.",
+    purpose: "perform a small focused task or accept an explicit solo handoff",
+    contextPurpose: "implement",
+    actions: [
+      "- Do not create or persist a legacy solo mode. Ordinary focused work needs no TaskRef; if the operator expects a governed task, use its bound TaskRef or report that none is bound.",
+      "- For a governed-to-solo transition, use `mancode workflow handoff <namespace:ULID> --to solo --expected-revision <n> --session <id>`."
+    ]
+  }
+};
+async function renderV3AdapterCandidate(root, platform) {
+  switch (platform) {
+    case "claude-code": {
+      const existing = await readAdapterTarget(root, "claude-skill");
+      return managedFilePlan(
+        "claude-skill",
+        existing,
+        renderClaudeSkill(renderV3Bootstrap(platform))
+      ).targetContent;
+    }
+    case "cursor": {
+      const existing = await readAdapterTarget(root, "cursor-rule");
+      return managedFilePlan(
+        "cursor-rule",
+        existing,
+        renderCursorRule(renderV3Bootstrap(platform))
+      ).targetContent;
+    }
+    case "codex": {
+      const existing = await readAdapterTarget(root, "agents") ?? "";
+      return replaceManagedV3BlockText(
+        removeLegacyAgentsBlocks(existing),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    }
+    case "copilot": {
+      const existing = await readAdapterTarget(root, "copilot-instructions") ?? "";
+      return replaceManagedV3BlockText(
+        removeManagedBlock(existing),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    }
+    case "zcode": {
+      const existing = await readAdapterTarget(root, "agents") ?? "";
+      return replaceManagedV3BlockText(
+        removeLegacyAgentsBlocks(existing),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER,
+        renderV3Bootstrap(platform)
+      );
+    }
+  }
+}
+function renderClaudeSkill(content) {
+  return [
+    "---",
+    "name: mancode-v3",
+    'description: "Internal bootstrap for original mancode mode entries under V3 authority."',
+    "user-invocable: false",
+    "---",
+    "",
+    content,
+    ""
+  ].join("\n");
+}
+function renderCursorRule(content) {
+  return [
+    "---",
+    'description: "Stable bootstrap for mancode V3 context and workflow commands."',
+    "alwaysApply: true",
+    'globs: "**/*"',
+    "---",
+    "",
+    content,
+    ""
+  ].join("\n");
+}
+async function adapterTargetPresent(root, platform) {
+  switch (platform) {
+    case "claude-code":
+      return managedFilePresent(
+        path.join(root, ".claude", "skills", "mancode-v3", "SKILL.md")
+      );
+    case "cursor":
+      return managedFilePresent(
+        path.join(root, ".cursor", "rules", "mancode-v3.mdc")
+      );
+    case "codex":
+      return managedBlockPresent(
+        path.join(root, "AGENTS.md"),
+        V3_CODEX_START_MARKER,
+        V3_CODEX_END_MARKER
+      );
+    case "copilot":
+      return managedBlockPresent(
+        path.join(root, ".github", "copilot-instructions.md"),
+        V3_COPILOT_START_MARKER,
+        V3_COPILOT_END_MARKER
+      );
+    case "zcode":
+      return managedBlockPresent(
+        path.join(root, "AGENTS.md"),
+        V3_ZCODE_START_MARKER,
+        V3_ZCODE_END_MARKER
+      );
+  }
+}
+async function writeManagedFile(filePath, content) {
+  const existing = await readTextIfExists(filePath);
+  if (existing !== null && !existing.includes(V3_ADAPTER_MANAGED_MARKER)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_USER_AUTHORED");
+  }
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWrite(filePath, content);
+}
+async function writeV3ModeEntry(filePath, content) {
+  const existing = await readTextIfExists(filePath);
+  const managed = existing === null || existing.includes(V3_MODE_ENTRY_MANAGED_MARKER) || LEGACY_MODE_ENTRY_MANAGED_MARKERS.some(
+    (marker) => existing.includes(marker)
+  );
+  if (!managed) {
+    throw new Error("MANCODE_V3_MODE_ENTRY_USER_AUTHORED");
+  }
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWrite(filePath, content);
+}
+async function assertV3ModeEntriesWritable(root, platform) {
+  for (const mode of V3_MODE_NAMES) {
+    const existing = await readTextIfExists(
+      v3ModeEntryPath(root, platform, mode)
+    );
+    if (existing !== null && !existing.includes(V3_MODE_ENTRY_MANAGED_MARKER) && !LEGACY_MODE_ENTRY_MANAGED_MARKERS.some(
+      (marker) => existing.includes(marker)
+    )) {
+      throw new Error("MANCODE_V3_MODE_ENTRY_USER_AUTHORED");
+    }
+  }
+}
+async function removeV3ModeEntry(filePath) {
+  const existing = await readTextIfExists(filePath);
+  if (existing?.includes(V3_MODE_ENTRY_MANAGED_MARKER)) {
+    await rm(filePath, { force: true });
+    await removeDirectoryIfEmpty(path.dirname(filePath));
+  }
+}
+async function v3ModeEntryPresent(filePath) {
+  const existing = await readTextIfExists(filePath);
+  return existing?.includes(V3_MODE_ENTRY_MANAGED_MARKER) ?? false;
+}
+async function removeDirectoryIfEmpty(directory) {
+  try {
+    await rmdir(directory);
+  } catch (error) {
+    if (isNodeError(error) && (error.code === "ENOENT" || error.code === "ENOTEMPTY" || error.code === "EEXIST")) {
+      return;
+    }
+    throw error;
+  }
+}
+async function removeManagedFile(filePath) {
+  const existing = await readTextIfExists(filePath);
+  if (existing?.includes(V3_ADAPTER_MANAGED_MARKER)) {
+    await rm(filePath, { force: true });
+  }
+}
+async function replaceManagedV3Block(filePath, startMarker, endMarker, content, legacyMarkers) {
+  const current = await readTextIfExists(filePath) ?? "";
+  const existing = (legacyMarkers ?? []).reduce(
+    (contentWithoutLegacy, [legacyStart, legacyEnd]) => removeManagedBlock(contentWithoutLegacy, legacyStart, legacyEnd),
+    current
+  );
+  const block = [startMarker, content, endMarker].join("\n");
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWrite(
+    filePath,
+    replaceManagedBlock(existing, block, startMarker, endMarker)
+  );
+}
+function removeLegacyAgentsBlocks(existing) {
+  return removeManagedBlock(
+    removeManagedBlock(
+      existing,
+      LEGACY_CODEX_START_MARKER,
+      LEGACY_CODEX_END_MARKER
+    ),
+    LEGACY_ZCODE_START_MARKER,
+    LEGACY_ZCODE_END_MARKER
+  );
+}
+function replaceManagedV3BlockText(existing, startMarker, endMarker, content) {
+  return replaceManagedBlock(
+    existing,
+    [startMarker, content, endMarker].join("\n"),
+    startMarker,
+    endMarker
+  );
+}
+function managedFilePlan(target, beforeContent, targetContent) {
+  if (beforeContent !== null && !beforeContent.includes(V3_ADAPTER_MANAGED_MARKER)) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_USER_AUTHORED");
+  }
+  return { target, beforeContent, targetContent };
+}
+function managedModeEntryPlan(target, beforeContent, targetContent) {
+  if (beforeContent !== null && !beforeContent.includes(V3_MODE_ENTRY_MANAGED_MARKER) && !LEGACY_MODE_ENTRY_MANAGED_MARKERS.some(
+    (marker) => beforeContent.includes(marker)
+  )) {
+    throw new Error("MANCODE_V3_MODE_ENTRY_USER_AUTHORED");
+  }
+  return { target, beforeContent, targetContent };
+}
+function planLegacyAdapterRetirement(existing) {
+  const plans = [];
+  const settings = existing.get("claude-settings") ?? null;
+  if (settings !== null) {
+    const cleaned = removeLegacyClaudeSettings(settings);
+    if (cleaned !== settings) {
+      plans.push({
+        target: "claude-settings",
+        beforeContent: settings,
+        targetContent: cleaned
+      });
+    }
+  }
+  const legacySolo = existing.get("claude-legacy-solo") ?? null;
+  if (legacySolo?.includes(
+    "<!-- Managed by mancode:claude-skill. Do not edit this marker. -->"
+  )) {
+    plans.push({
+      target: "claude-legacy-solo",
+      beforeContent: legacySolo,
+      targetContent: renderRetiredClaudeSoloEntry()
+    });
+  }
+  for (const target of V3_LEGACY_ADAPTER_FILE_TARGETS) {
+    if (!target.startsWith("cursor-legacy-")) continue;
+    const beforeContent = existing.get(target) ?? null;
+    if (beforeContent?.includes(
+      "<!-- Managed by mancode:cursor-rule. Do not edit this marker. -->"
+    )) {
+      plans.push({
+        target,
+        beforeContent,
+        targetContent: renderRetiredCursorRule(target)
+      });
+    }
+  }
+  for (const target of V3_LEGACY_ADAPTER_FILE_TARGETS) {
+    const alias = parseLegacyModeAliasTarget(target);
+    if (alias === null) continue;
+    const beforeContent = existing.get(target) ?? null;
+    if (beforeContent !== null && isGeneratedLegacyModeAlias(beforeContent, alias.alias)) {
+      plans.push({
+        target,
+        beforeContent,
+        targetContent: renderRetiredModeAlias(target)
+      });
+    }
+  }
+  return plans;
+}
+async function retireLegacyPlatformFiles(root, platform) {
+  const targets = legacyAdapterTargetsForPlatform(platform, true);
+  if (targets.length === 0) return;
+  const existing = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    existing.set(target, await readAdapterTarget(root, target));
+  }
+  for (const plan of planLegacyAdapterRetirement(existing)) {
+    await applyV3AdapterFilePlan(root, plan);
+  }
+}
+async function removeRetiredLegacyPlatformFiles(root, platform) {
+  const targets = legacyAdapterTargetsForPlatform(platform, false);
+  for (const target of targets) {
+    const filePath = v3AdapterTargetPath(root, target);
+    const content = await readTextIfExists(filePath);
+    const retiredModeEntry = target === "claude-legacy-solo" || parseLegacyModeAliasTarget(target) !== null;
+    const retired = content?.includes(
+      retiredModeEntry ? V3_MODE_ENTRY_MANAGED_MARKER : V3_ADAPTER_MANAGED_MARKER
+    );
+    if (retired) {
+      await rm(filePath, { force: true });
+      if (target === "claude-legacy-solo" || target.startsWith("claude-alias-") || target.startsWith("agents-alias-")) {
+        await removeDirectoryIfEmpty(path.dirname(filePath));
+      }
+    }
+  }
+}
+function legacyAdapterTargetsForPlatform(platform, includeSettings) {
+  if (platform === "claude-code") {
+    return [
+      ...includeSettings ? ["claude-settings"] : [],
+      "claude-legacy-solo",
+      ...V3_LEGACY_ADAPTER_FILE_TARGETS.filter(
+        (target) => target.startsWith("claude-alias-")
+      )
+    ];
+  }
+  if (platform === "cursor") {
+    return V3_LEGACY_ADAPTER_FILE_TARGETS.filter(
+      (target) => /^(cursor-legacy|cursor-alias)-/u.test(target)
+    );
+  }
+  if (platform === "codex" || platform === "zcode") {
+    return V3_LEGACY_ADAPTER_FILE_TARGETS.filter(
+      (target) => target.startsWith("agents-alias-")
+    );
+  }
+  return V3_LEGACY_ADAPTER_FILE_TARGETS.filter(
+    (target) => target.startsWith("copilot-alias-")
+  );
+}
+function removeLegacyClaudeSettings(content) {
+  const hasKnownLegacyReference = LEGACY_CLAUDE_SETTINGS_RAW_HINTS.some(
+    (value) => content.includes(value)
+  );
+  if (!hasKnownLegacyReference) return content;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error("MANCODE_V3_CLAUDE_SETTINGS_INVALID");
+  }
+  if (!isRecord(parsed)) {
+    throw new Error("MANCODE_V3_CLAUDE_SETTINGS_INVALID");
+  }
+  const hasGeneratedHook = containsGeneratedClaudeHookValue(parsed.hooks);
+  const hasGeneratedSkill = isRecord(parsed.skills) && Object.values(parsed.skills).some(
+    (value) => typeof value === "string" && LEGACY_CLAUDE_SKILL_PATHS.has(value)
+  );
+  if (!hasGeneratedHook && !hasGeneratedSkill) return content;
+  const settings = { ...parsed };
+  if ("hooks" in settings) {
+    const hooks = removeGeneratedClaudeHookValue(settings.hooks);
+    if (hooks === void 0) settings.hooks = void 0;
+    else settings.hooks = hooks;
+  }
+  if (isRecord(settings.skills)) {
+    const skills = Object.fromEntries(
+      Object.entries(settings.skills).filter(
+        ([, value]) => typeof value !== "string" || !LEGACY_CLAUDE_SKILL_PATHS.has(value)
+      )
+    );
+    if (Object.keys(skills).length === 0) settings.skills = void 0;
+    else settings.skills = skills;
+  }
+  return `${JSON.stringify(settings, null, 2)}
+`;
+}
+function containsGeneratedClaudeHookValue(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsGeneratedClaudeHookValue);
+  }
+  if (!isRecord(value)) return false;
+  if (typeof value.command === "string" && isGeneratedClaudeHookCommand(value.command)) {
+    return true;
+  }
+  return Object.values(value).some(containsGeneratedClaudeHookValue);
+}
+function removeGeneratedClaudeHookValue(value) {
+  if (Array.isArray(value)) {
+    const cleaned2 = value.map(removeGeneratedClaudeHookValue).filter((entry) => entry !== void 0);
+    return cleaned2.length > 0 ? cleaned2 : void 0;
+  }
+  if (!isRecord(value)) return value;
+  if (typeof value.command === "string" && isGeneratedClaudeHookCommand(value.command)) {
+    return void 0;
+  }
+  if (Array.isArray(value.hooks)) {
+    const hooks = value.hooks.map(removeGeneratedClaudeHookValue).filter((entry) => entry !== void 0);
+    return hooks.length > 0 ? { ...value, hooks } : void 0;
+  }
+  const cleaned = Object.entries(value).flatMap(([key, entry]) => {
+    const next = removeGeneratedClaudeHookValue(entry);
+    return next === void 0 ? [] : [[key, next]];
+  });
+  return cleaned.length > 0 ? Object.fromEntries(cleaned) : void 0;
+}
+function isGeneratedClaudeHookCommand(command) {
+  return GENERATED_CLAUDE_HOOK_COMMANDS.has(command.trim());
+}
+function renderRetiredClaudeSoloEntry() {
+  return [
+    "---",
+    "name: solo",
+    'description: "Compatibility alias for the mancode V3 mansolo entry."',
+    "user-invocable: false",
+    "---",
+    "",
+    V3_MODE_ENTRY_MANAGED_MARKER,
+    "",
+    "# mancode V3 mode compatibility alias",
+    "",
+    "Use the `mansolo` mode entry. Resolve V3 status, identity, session, TaskRef, and Context Pack there; do not use legacy mode persistence.",
+    ""
+  ].join("\n");
+}
+function renderRetiredCursorRule(target) {
+  const legacyName = target.replace("cursor-legacy-", "");
+  const mode = legacyName === "solo" ? "mansolo" : legacyName === "mamba" ? "manba" : legacyName === "man8" ? "man" : legacyName;
+  const guidance = mode === "context" || mode === "practice" ? "Run `mancode status --json`, then use the matching V3 mode command." : `Use the \`/${mode}\` V3 mode command.`;
+  return [
+    "---",
+    'description: "Retired legacy mancode rule; V3 mode entries are authoritative."',
+    "alwaysApply: false",
+    'globs: "__mancode_v3_retired_rule__"',
+    "---",
+    "",
+    V3_ADAPTER_MANAGED_MARKER,
+    "",
+    "# mancode V3 compatibility redirect",
+    "",
+    guidance,
+    "Do not use legacy mode persistence or legacy workflow paths.",
+    ""
+  ].join("\n");
+}
+function renderRetiredModeAlias(target) {
+  const parsed = parseLegacyModeAliasTarget(target);
+  if (parsed === null) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
+  }
+  const publicMode = parsed.alias === "mamba" ? "manba" : "man";
+  const frontmatter = [
+    "---",
+    ...parsed.family === "claude" || parsed.family === "agents" ? [`name: ${parsed.alias}`] : [],
+    ...parsed.family === "copilot" ? ["agent: 'agent'"] : [],
+    ...parsed.family === "claude" ? ["user-invocable: false"] : [],
+    `description: ${JSON.stringify(`Compatibility alias for the mancode V3 ${publicMode} entry.`)}`,
+    "---"
+  ];
+  return [
+    ...frontmatter,
+    "",
+    V3_MODE_ENTRY_MANAGED_MARKER,
+    "",
+    "# mancode V3 mode compatibility alias",
+    "",
+    `The legacy name \`${parsed.alias}\` maps to the public V3 mode \`${publicMode}\`. Use that original V3 mode entry instead.`,
+    "",
+    "Resolve status, identity, session, TaskRef, and Context Pack through V3 authority there. Do not use legacy mode persistence or the legacy workflow protocol.",
+    ""
+  ].join("\n");
+}
+function isGeneratedLegacyModeAlias(content, alias) {
+  if (content.includes(V3_MODE_ENTRY_MANAGED_MARKER) || LEGACY_MODE_ENTRY_MANAGED_MARKERS.some((marker) => content.includes(marker))) {
+    return true;
+  }
+  if (alias !== "man8") return false;
+  return content.includes("# mancode \xB7 /man8 (4 AM Warmup)") || content.includes("# mancode man8 \u2014 Investigate and Plan") && content.includes("## Mode Persistence");
+}
+function legacyAdapterRelativePath(target) {
+  if (target === "claude-settings")
+    return path.join(".claude", "settings.json");
+  if (target === "claude-legacy-solo") {
+    return path.join(".claude", "skills", "solo", "SKILL.md");
+  }
+  if (target.startsWith("cursor-legacy-")) {
+    const name = target.slice("cursor-legacy-".length);
+    return path.join(".cursor", "rules", `mancode-${name}.mdc`);
+  }
+  const alias = parseLegacyModeAliasTarget(target);
+  if (alias === null) return null;
+  switch (alias.family) {
+    case "claude":
+      return path.join(".claude", "skills", alias.alias, "SKILL.md");
+    case "agents":
+      return path.join(".agents", "skills", alias.alias, "SKILL.md");
+    case "cursor":
+      return path.join(".cursor", "commands", `${alias.alias}.md`);
+    case "copilot":
+      return path.join(".github", "prompts", `${alias.alias}.prompt.md`);
+  }
+}
+function parseLegacyModeAliasTarget(target) {
+  const match = /^(claude|agents|cursor|copilot)-alias-(mamba|man8)$/u.exec(
+    target
+  );
+  if (!match) return null;
+  return {
+    family: match[1],
+    alias: match[2]
+  };
+}
+function renderModeEntryForFileTarget(target) {
+  const parsed = parseModeEntryFileTarget(target);
+  if (parsed === null) {
+    throw new Error("MANCODE_V3_ADAPTER_TARGET_INVALID");
+  }
+  return renderV3ModeEntry(parsed.mode, parsed.platform);
+}
+function parseModeEntryFileTarget(target) {
+  const match = /^(claude|agents|cursor|copilot)-mode-(manba|man|manteam|manps|mansolo)$/u.exec(
+    target
+  );
+  if (!match) return null;
+  const family = match[1];
+  const mode = match[2];
+  const platform = family === "claude" ? "claude-code" : family === "agents" ? "codex" : family === "cursor" ? "cursor" : "copilot";
+  return { platform, mode };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readAdapterTarget(root, target) {
+  const filePath = v3AdapterTargetPath(root, target);
+  await assertAdapterPathSafe(root, filePath);
+  try {
+    const entry = await lstat(filePath);
+    if (!entry.isFile() || entry.isSymbolicLink()) {
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+  return readFile(filePath, "utf8");
+}
+async function assertPlatformAdapterPathsSafe(root, platform) {
+  const targets = /* @__PURE__ */ new Set([
+    path.join(root, targetFor(platform)),
+    ...V3_MODE_NAMES.map((mode) => v3ModeEntryPath(root, platform, mode)),
+    ...legacyAdapterTargetsForPlatform(platform, true).map(
+      (target) => v3AdapterTargetPath(root, target)
+    )
+  ]);
+  for (const target of targets) {
+    await assertAdapterPathSafe(root, target);
+  }
+}
+async function assertAdapterPathSafe(root, target) {
+  const relative = path.relative(root, target);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const rootEntry = await lstat(root);
+  if (!rootEntry.isDirectory() || rootEntry.isSymbolicLink()) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const segments = relative.split(path.sep);
+  let current = root;
+  for (let index = 0; index < segments.length; index += 1) {
+    current = path.join(current, segments[index] ?? "");
+    try {
+      const entry = await lstat(current);
+      if (entry.isSymbolicLink() || index < segments.length - 1 && !entry.isDirectory()) {
+        throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+      }
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+}
+async function removeManagedV3Block(filePath, startMarker, endMarker) {
+  const existing = await readTextIfExists(filePath);
+  if (existing === null || !hasManagedBlock(existing, startMarker, endMarker)) {
+    return;
+  }
+  const cleaned = removeManagedBlock(existing, startMarker, endMarker);
+  if (cleaned.trim()) {
+    await atomicWrite(filePath, `${cleaned.trimEnd()}
+`);
+  } else {
+    await rm(filePath, { force: true });
+  }
+}
+async function managedFilePresent(filePath) {
+  const content = await readTextIfExists(filePath);
+  return content?.includes(V3_ADAPTER_MANAGED_MARKER) ?? false;
+}
+async function managedBlockPresent(filePath, startMarker, endMarker) {
+  const content = await readTextIfExists(filePath);
+  return content !== null && hasManagedBlock(content, startMarker, endMarker);
+}
+async function readTextIfExists(filePath) {
+  for (let attempt = 1; attempt <= ADAPTER_READ_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      return await readFile(filePath, "utf8");
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return null;
+      if (!isRetriableAdapterReadError(error) || attempt === ADAPTER_READ_MAX_ATTEMPTS) {
+        throw error;
+      }
+      await delay(ADAPTER_READ_RETRY_DELAY_MS * attempt);
+    }
+  }
+  throw new Error("MANCODE_V3_ADAPTER_READ_RETRY_EXHAUSTED");
+}
+async function atomicWrite(filePath, content) {
+  const temporary = path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    await writeFile(temporary, content, { encoding: "utf8", flag: "wx" });
+    await rename(temporary, filePath);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+}
+function targetFor(platform) {
+  switch (platform) {
+    case "claude-code":
+      return ".claude/skills/mancode-v3/SKILL.md";
+    case "cursor":
+      return ".cursor/rules/mancode-v3.mdc";
+    case "codex":
+    case "zcode":
+      return "AGENTS.md";
+    case "copilot":
+      return ".github/copilot-instructions.md";
+  }
+}
+function platformLabelFor(platform) {
+  switch (platform) {
+    case "claude-code":
+      return "Claude Code";
+    case "cursor":
+      return "Cursor";
+    case "codex":
+      return "Codex or ZCode (shared AGENTS.md bootstrap)";
+    case "copilot":
+      return "GitHub Copilot";
+    case "zcode":
+      return "Codex or ZCode (shared AGENTS.md bootstrap)";
+  }
+}
+function capabilitiesFor(_platform) {
+  return {
+    nativeModeEntry: true,
+    sessionHook: false,
+    promptHook: false,
+    sessionIdentity: "explicit-required"
+  };
+}
+function isNodeError(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+function isRetriableAdapterReadError(error) {
+  return isNodeError(error) && RETRIABLE_ADAPTER_READ_CODES.has(error.code ?? "");
+}
+async function delay(milliseconds) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+
+export {
+  DEFAULT_MANCODE_START_MARKER,
+  DEFAULT_MANCODE_END_MARKER,
+  removeManagedBlock,
+  hasManagedBlock,
+  replaceManagedBlock,
+  V3_ADAPTER_VERSION,
+  V3_ADAPTER_MANAGED_MARKER,
+  V3_MODE_ENTRY_MANAGED_MARKER,
+  V3_MODE_NAMES,
+  V3_ADAPTER_FILE_TARGETS,
+  planV3AdapterFiles,
+  applyV3AdapterFilePlan,
+  stageV3Adapter,
+  v3AdapterTargetPath,
+  assertV3AdapterTargetSafe,
+  v3ModeEntryPath,
+  installV3Adapter,
+  assertV3AdapterInstallable,
+  inspectV3Adapter,
+  inspectV3AdapterVersions,
+  removeV3Adapter,
+  renderV3Bootstrap,
+  renderV3ModeEntry
+};
+//# sourceMappingURL=chunk-CFC3HBNA.js.map