mancode 0.3.6 → 0.3.7

package/dist/cli.js

@@ -7,9 +7,9 @@ import {
 import { program } from "commander";
 
 // src/commands/init.ts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 import os from "os";
-import path14 from "path";
+import path15 from "path";
 import process5 from "process";
 
 // src/installers/claude-code.ts
@@ -2631,9 +2631,9 @@ function renderManpsRule() {
   return renderModeSkill("manps", "/");
 }
 
-// src/installers/codex.ts
-import { writeFile as writeFile6 } from "fs/promises";
-import path7 from "path";
+// src/installers/platform-status.ts
+import { promises as fs } from "fs";
+import path8 from "path";
 
 // src/installers/managed-block.ts
 var DEFAULT_MANCODE_START_MARKER = "<!-- mancode:start -->";
@@ -2725,104 +2725,14 @@ function findMarkerLine(content, marker) {
   return null;
 }
 
-// src/installers/codex.ts
-async function installCodex(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const agentsPath = path7.join(projectRoot, "AGENTS.md");
-  const existing = await readTextIfExists(agentsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
-    platform: "codex",
-    displayName: "Codex (ChatGPT desktop/CLI)",
-    capabilities: {
-      slashCommands: "partial",
-      subagents: false,
-      hooks: false,
-      skills: "agents-skills"
-    },
-    minimal: options.minimal,
-    techStack: options.techStack,
-    uiLibrary: options.uiLibrary,
-    projectProfile: options.projectProfile
-  });
-  const block = [
-    DEFAULT_MANCODE_START_MARKER,
-    "<!-- Managed by mancode. Do not edit this block manually. -->",
-    "",
-    "# mancode Configuration",
-    "",
-    sharedContent.trim(),
-    DEFAULT_MANCODE_END_MARKER
-  ].join("\n");
-  await writeFile6(agentsPath, replaceManagedBlock(existing, block), "utf-8");
-  await installCodexSkills(projectRoot, options.minimal ?? false);
-}
-
-// src/installers/copilot.ts
-import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
-import path8 from "path";
-async function installCopilot(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const githubDir = path8.join(projectRoot, ".github");
-  await mkdir6(githubDir, { recursive: true });
-  const instructionsPath = path8.join(githubDir, "copilot-instructions.md");
-  const existing = await readTextIfExists(instructionsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
-    platform: "copilot",
-    displayName: "GitHub Copilot",
-    capabilities: {
-      slashCommands: "none",
-      subagents: false,
-      hooks: false,
-      skills: "instructions"
-    },
-    minimal: true,
-    techStack: options.techStack,
-    uiLibrary: options.uiLibrary,
-    projectProfile: options.projectProfile
-  });
-  const sections = [
-    DEFAULT_MANCODE_START_MARKER,
-    "<!-- Managed by mancode. Do not edit this block manually. -->",
-    "",
-    "# mancode for GitHub Copilot",
-    "",
-    sharedContent.trim()
-  ];
-  if (!options.minimal) {
-    sections.push("", renderCopilotPromptConventions());
-  }
-  sections.push(DEFAULT_MANCODE_END_MARKER);
-  await writeFile7(
-    instructionsPath,
-    replaceManagedBlock(existing, sections.join("\n")),
-    "utf-8"
-  );
-  await installCopilotPrompts(projectRoot, options.minimal ?? false);
-}
-function renderCopilotPromptConventions() {
-  return [
-    "## mancode Prompt Conventions",
-    "",
-    "GitHub Copilot does not provide native mancode slash commands, hooks, or isolated subagents. Treat these names as user prompt conventions:",
-    "",
-    "- man: use progressive research, planning, implementation, verification, and bounded risk-based review.",
-    "- manba: diagnose bugs and validate real user flows or regressions.",
-    "- manteam: read team memory and write handoff-friendly summaries.",
-    "- manps: prefer `mancode manps [area]` before cleanup.",
-    "- mansolo: exit any active mode and return to default solo behavior.",
-    "",
-    "These correspond to prompt files in `.github/prompts/`. Select the matching prompt to activate a mode."
-  ].join("\n");
-}
-
 // src/installers/zcode.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import path9 from "path";
+import { writeFile as writeFile6 } from "fs/promises";
+import path7 from "path";
 var ZCODE_MANCODE_START_MARKER = "<!-- mancode:zcode:start -->";
 var ZCODE_MANCODE_END_MARKER = "<!-- mancode:zcode:end -->";
 async function installZcode(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path9.join(projectRoot, "AGENTS.md");
+  const agentsPath = path7.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "zcode",
@@ -2847,7 +2757,7 @@ async function installZcode(projectRoot, options) {
     sharedContent.trim(),
     ZCODE_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile8(
+  await writeFile6(
     agentsPath,
     replaceManagedBlock(
       existing,
@@ -2860,143 +2770,514 @@ async function installZcode(projectRoot, options) {
   await installZcodeSkills(projectRoot, options.minimal ?? false);
 }
 
-// src/installers/registry.ts
-var PLATFORM_INSTALLERS = {
-  "claude-code": {
-    name: "claude-code",
-    displayName: "Claude Code",
-    capabilities: {
-      slashCommands: "native",
-      subagents: true,
-      hooks: true,
-      skills: "native"
-    },
-    install: installClaudeCode
-  },
-  cursor: {
-    name: "cursor",
-    displayName: "Cursor",
-    capabilities: {
-      slashCommands: "native",
-      subagents: false,
-      hooks: false,
-      skills: "rules"
-    },
-    install: installCursor
-  },
-  codex: {
-    name: "codex",
-    displayName: "Codex (ChatGPT desktop/CLI)",
-    capabilities: {
-      slashCommands: "partial",
-      subagents: false,
-      hooks: false,
-      skills: "agents-skills"
-    },
-    install: installCodex
-  },
-  copilot: {
-    name: "copilot",
-    displayName: "GitHub Copilot",
-    capabilities: {
-      slashCommands: "none",
-      subagents: false,
-      hooks: false,
-      skills: "instructions"
-    },
-    install: installCopilot
-  },
-  zcode: {
-    name: "zcode",
-    displayName: "ZCode",
-    capabilities: {
-      slashCommands: "partial",
-      subagents: false,
-      hooks: false,
-      skills: "agents-skills"
-    },
-    install: installZcode
-  }
-};
-function getPlatformInstaller(platform) {
-  if (!isPlatformName(platform)) return null;
-  return PLATFORM_INSTALLERS[platform];
-}
-function getPlatformInstallers() {
-  return Object.values(PLATFORM_INSTALLERS);
-}
-function formatPlatformName(platform) {
-  return getPlatformInstaller(platform)?.displayName ?? platform;
+// src/installers/platform-status.ts
+async function checkPlatformStatus(rootDir, platform, installed) {
+  const readiness = await checkPlatformReadiness(rootDir, platform);
+  return {
+    installed,
+    ready: installed && readiness.ready,
+    target: readiness.target,
+    detail: describeStatus(installed, readiness)
+  };
 }
-function isPlatformName(platform) {
-  return Object.prototype.hasOwnProperty.call(PLATFORM_INSTALLERS, platform);
+async function isPlatformPresent(rootDir, platform) {
+  return (await checkPlatformReadiness(rootDir, platform)).present;
 }
-
-// src/system/detect-team.ts
-import { execFile } from "child_process";
-import { access as access2 } from "fs/promises";
-import path10 from "path";
-import process2 from "process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var NO_TEAM = {
-  isTeam: false,
-  contributors: 1,
-  recentActive: 1,
-  hasRemote: false
-};
-var REMOTE_PATTERN = /github\.com|gitlab\.com|bitbucket\.org/;
-var GIT_ENV = {
-  ...process2.env,
-  GIT_PAGER: "cat",
-  PAGER: "cat",
-  GIT_TERMINAL_PROMPT: "0"
-};
-async function detectTeamStatus(projectRoot) {
-  try {
-    await access2(path10.join(projectRoot, ".git"));
-    const inside = await runGit(projectRoot, [
-      "rev-parse",
-      "--is-inside-work-tree"
-    ]);
-    if (inside.trim() !== "true") return NO_TEAM;
-    const [allEmails, recentEmails, remotes] = await Promise.all([
-      runGit(projectRoot, ["log", "--all", "--format=%ae"]),
-      runGit(projectRoot, ["log", "--since=30 days ago", "--format=%ae"]),
-      runGit(projectRoot, ["remote", "-v"])
+async function checkPlatformReadiness(rootDir, platform) {
+  if (platform === "claude-code") {
+    const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
+      fileMatches(
+        path8.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        (content) => isGeneratedClaudeSkill(content, "solo")
+      ),
+      claudeHooksRegistered(rootDir),
+      pathsExist([
+        path8.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path8.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      ])
     ]);
-    const contributors = countUniqueLines(allEmails);
-    const recentActive = countUniqueLines(recentEmails);
-    const hasRemote = REMOTE_PATTERN.test(remotes);
+    const present = hasSoloSkill && registered && hasHookFiles;
+    const minimal = await isPlatformMinimal(rootDir, "claude-code");
+    const fullContentReady = minimal ? true : await claudeFullContentReady(rootDir);
     return {
-      isTeam: contributors > 1 && hasRemote && recentActive > 1,
-      contributors: contributors || 1,
-      recentActive: recentActive || 1,
-      hasRemote
+      present,
+      ready: present && fullContentReady,
+      target: ".claude/",
+      readyDetail: present && fullContentReady ? minimal ? "solo skill and hooks ready" : "skills, agents, and hooks ready" : "skills, agents, hook files, or hook registration are incomplete"
     };
-  } catch {
-    return NO_TEAM;
   }
-}
-async function runGit(cwd, args) {
-  const { stdout: stdout2 } = await execFileAsync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    env: GIT_ENV,
-    windowsHide: true
-  });
-  return stdout2;
-}
-function countUniqueLines(output) {
-  return new Set(
-    output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
-  ).size;
-}
-
-// src/system/detect.ts
-import { execFile as execFile2 } from "child_process";
-import process3 from "process";
-import { promisify as promisify2 } from "util";
+  if (platform === "cursor") {
+    const hasCoreRules = await allManagedSkills(
+      MANCODE_CURSOR_CORE_RULE_FILES.map(
+        (file) => path8.join(rootDir, ".cursor", "rules", file)
+      ),
+      [CURSOR_RULE_MANAGED_MARKER]
+    );
+    if (await isPlatformMinimal(rootDir, "cursor")) {
+      return {
+        present: hasCoreRules,
+        ready: hasCoreRules,
+        target: ".cursor/rules/",
+        readyDetail: "mancode core rules present"
+      };
+    }
+    const [hasRules, hasCommands] = await Promise.all([
+      allManagedSkills(
+        MANCODE_CURSOR_RULE_FILES.map(
+          (file) => path8.join(rootDir, ".cursor", "rules", file)
+        ),
+        [CURSOR_RULE_MANAGED_MARKER]
+      ),
+      allManagedSkills(
+        MODE_NAMES.map(
+          (mode) => path8.join(rootDir, ".cursor", "commands", `${mode}.md`)
+        ),
+        [MODE_FILE_MANAGED_MARKER]
+      )
+    ]);
+    return {
+      present: hasCoreRules,
+      ready: hasRules && hasCommands,
+      target: ".cursor/rules/ + .cursor/commands/",
+      readyDetail: hasRules && hasCommands ? "mancode rules and commands present" : "mode rules or commands are missing, incomplete, or user-authored"
+    };
+  }
+  if (platform === "codex") {
+    const hasBlock2 = await fileHasManagedBlock(path8.join(rootDir, "AGENTS.md"));
+    if (!hasBlock2) {
+      return {
+        present: false,
+        ready: false,
+        target: "AGENTS.md",
+        readyDetail: "managed block missing"
+      };
+    }
+    if (await isPlatformMinimal(rootDir, "codex")) {
+      return {
+        present: true,
+        ready: true,
+        target: "AGENTS.md",
+        readyDetail: "managed block present"
+      };
+    }
+    const skillsDir = path8.join(rootDir, ".agents", "skills");
+    const hasSkills = await allManagedSkills(
+      MODE_NAMES.map((mode) => path8.join(skillsDir, mode, "SKILL.md")),
+      MANCODE_AGENT_SKILL_MARKERS
+    );
+    return {
+      present: true,
+      ready: hasSkills,
+      target: "AGENTS.md + .agents/skills/",
+      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
+    };
+  }
+  if (platform === "zcode") {
+    const hasBlock2 = await fileHasManagedBlock(
+      path8.join(rootDir, "AGENTS.md"),
+      ZCODE_MANCODE_START_MARKER,
+      ZCODE_MANCODE_END_MARKER
+    );
+    if (!hasBlock2) {
+      return {
+        present: false,
+        ready: false,
+        target: "AGENTS.md",
+        readyDetail: "managed block missing"
+      };
+    }
+    if (await isPlatformMinimal(rootDir, "zcode")) {
+      return {
+        present: true,
+        ready: true,
+        target: "AGENTS.md",
+        readyDetail: "managed block present"
+      };
+    }
+    const skillsDir = path8.join(rootDir, ".agents", "skills");
+    const hasSkills = await allManagedSkills(
+      MODE_NAMES.map((mode) => path8.join(skillsDir, mode, "SKILL.md")),
+      MANCODE_AGENT_SKILL_MARKERS
+    );
+    return {
+      present: true,
+      ready: hasSkills,
+      target: "AGENTS.md + .agents/skills/",
+      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
+    };
+  }
+  const hasBlock = await fileHasManagedBlock(
+    path8.join(rootDir, ".github", "copilot-instructions.md")
+  );
+  if (!hasBlock) {
+    return {
+      present: false,
+      ready: false,
+      target: ".github/copilot-instructions.md",
+      readyDetail: "managed block missing"
+    };
+  }
+  if (!await isPlatformMinimal(rootDir, "copilot")) {
+    const promptsDir = path8.join(rootDir, ".github", "prompts");
+    const hasPrompts = await allManagedSkills(
+      MODE_NAMES.map((mode) => path8.join(promptsDir, `${mode}.prompt.md`)),
+      [MODE_FILE_MANAGED_MARKER]
+    );
+    return {
+      present: true,
+      ready: hasPrompts,
+      target: ".github/copilot-instructions.md + .github/prompts/",
+      readyDetail: hasPrompts ? "managed block and prompts present" : "mode prompts are missing, incomplete, or user-authored"
+    };
+  }
+  return {
+    present: true,
+    ready: true,
+    target: ".github/copilot-instructions.md",
+    readyDetail: "managed block present"
+  };
+}
+function describeStatus(installed, readiness) {
+  if (installed && readiness.present) return readiness.readyDetail;
+  if (!installed && readiness.present) {
+    return "target files present but platform is not recorded in config";
+  }
+  return "missing generated files or registration";
+}
+async function allManagedSkills(paths, markers) {
+  const results = await Promise.all(
+    paths.map((filePath) => fileHasAnyMarker(filePath, markers))
+  );
+  return results.every(Boolean);
+}
+async function claudeFullContentReady(rootDir) {
+  const skillChecks = MVP2_SKILLS.map(
+    (skill) => fileMatches(
+      path8.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      (content) => isGeneratedClaudeSkill(content, skill.name)
+    )
+  );
+  const agentChecks = ALL_AGENTS.map(
+    (agent) => fileMatches(
+      path8.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      (content) => isGeneratedClaudeAgent(content, agent.name)
+    )
+  );
+  const results = await Promise.all([...skillChecks, ...agentChecks]);
+  return results.every(Boolean);
+}
+async function fileMatches(filePath, predicate) {
+  try {
+    return predicate(await fs.readFile(filePath, "utf-8"));
+  } catch {
+    return false;
+  }
+}
+async function pathsExist(paths) {
+  return (await Promise.all(paths.map(pathExists2))).every(Boolean);
+}
+async function fileHasAnyMarker(filePath, needles) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return needles.some((needle) => content.includes(needle));
+  } catch {
+    return false;
+  }
+}
+async function isPlatformMinimal(rootDir, platform) {
+  try {
+    const raw = await fs.readFile(
+      path8.join(rootDir, ".mancode", "config.json"),
+      "utf-8"
+    );
+    const config = JSON.parse(raw);
+    if (!isRecord3(config.platformOptions)) return false;
+    const options = config.platformOptions[platform];
+    return isRecord3(options) && options.minimal === true;
+  } catch {
+    return false;
+  }
+}
+async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return hasManagedBlock(content, startMarker, endMarker);
+  } catch {
+    return false;
+  }
+}
+async function claudeHooksRegistered(rootDir) {
+  try {
+    const raw = await fs.readFile(
+      path8.join(rootDir, ".claude", "settings.json"),
+      "utf-8"
+    );
+    const settings = JSON.parse(raw);
+    return hooksRegistered(settings);
+  } catch {
+    return false;
+  }
+}
+function hooksRegistered(settings) {
+  if (!isRecord3(settings)) return false;
+  const hooks = settings.hooks;
+  if (!isRecord3(hooks)) return false;
+  return hasHookCommand(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand(
+    hooks.UserPromptSubmit,
+    ".mancode/hooks/user-prompt-submit.mjs"
+  );
+}
+function hasHookCommand(value, needle) {
+  if (!Array.isArray(value)) return false;
+  return value.some((group) => {
+    if (!isRecord3(group) || !Array.isArray(group.hooks)) return false;
+    return group.hooks.some((hook) => {
+      if (!isRecord3(hook) || typeof hook.command !== "string") return false;
+      return hook.command.includes(needle);
+    });
+  });
+}
+async function pathExists2(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/installers/codex.ts
+import { writeFile as writeFile7 } from "fs/promises";
+import path9 from "path";
+async function installCodex(projectRoot, options) {
+  await installMancodeCore(projectRoot);
+  const agentsPath = path9.join(projectRoot, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
+    platform: "codex",
+    displayName: "Codex (ChatGPT desktop/CLI)",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    minimal: options.minimal,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const block = [
+    DEFAULT_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode Configuration",
+    "",
+    sharedContent.trim(),
+    DEFAULT_MANCODE_END_MARKER
+  ].join("\n");
+  await writeFile7(agentsPath, replaceManagedBlock(existing, block), "utf-8");
+  await installCodexSkills(projectRoot, options.minimal ?? false);
+}
+
+// src/installers/copilot.ts
+import { mkdir as mkdir6, writeFile as writeFile8 } from "fs/promises";
+import path10 from "path";
+async function installCopilot(projectRoot, options) {
+  await installMancodeCore(projectRoot);
+  const githubDir = path10.join(projectRoot, ".github");
+  await mkdir6(githubDir, { recursive: true });
+  const instructionsPath = path10.join(githubDir, "copilot-instructions.md");
+  const existing = await readTextIfExists(instructionsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
+    platform: "copilot",
+    displayName: "GitHub Copilot",
+    capabilities: {
+      slashCommands: "none",
+      subagents: false,
+      hooks: false,
+      skills: "instructions"
+    },
+    minimal: true,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const sections = [
+    DEFAULT_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode for GitHub Copilot",
+    "",
+    sharedContent.trim()
+  ];
+  if (!options.minimal) {
+    sections.push("", renderCopilotPromptConventions());
+  }
+  sections.push(DEFAULT_MANCODE_END_MARKER);
+  await writeFile8(
+    instructionsPath,
+    replaceManagedBlock(existing, sections.join("\n")),
+    "utf-8"
+  );
+  await installCopilotPrompts(projectRoot, options.minimal ?? false);
+}
+function renderCopilotPromptConventions() {
+  return [
+    "## mancode Prompt Conventions",
+    "",
+    "GitHub Copilot does not provide native mancode slash commands, hooks, or isolated subagents. Treat these names as user prompt conventions:",
+    "",
+    "- man: use progressive research, planning, implementation, verification, and bounded risk-based review.",
+    "- manba: diagnose bugs and validate real user flows or regressions.",
+    "- manteam: read team memory and write handoff-friendly summaries.",
+    "- manps: prefer `mancode manps [area]` before cleanup.",
+    "- mansolo: exit any active mode and return to default solo behavior.",
+    "",
+    "These correspond to prompt files in `.github/prompts/`. Select the matching prompt to activate a mode."
+  ].join("\n");
+}
+
+// src/installers/registry.ts
+var PLATFORM_INSTALLERS = {
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    capabilities: {
+      slashCommands: "native",
+      subagents: true,
+      hooks: true,
+      skills: "native"
+    },
+    install: installClaudeCode
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    capabilities: {
+      slashCommands: "native",
+      subagents: false,
+      hooks: false,
+      skills: "rules"
+    },
+    install: installCursor
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex (ChatGPT desktop/CLI)",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    install: installCodex
+  },
+  copilot: {
+    name: "copilot",
+    displayName: "GitHub Copilot",
+    capabilities: {
+      slashCommands: "none",
+      subagents: false,
+      hooks: false,
+      skills: "instructions"
+    },
+    install: installCopilot
+  },
+  zcode: {
+    name: "zcode",
+    displayName: "ZCode",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    install: installZcode
+  }
+};
+function getPlatformInstaller(platform) {
+  if (!isPlatformName(platform)) return null;
+  return PLATFORM_INSTALLERS[platform];
+}
+function getPlatformInstallers() {
+  return Object.values(PLATFORM_INSTALLERS);
+}
+function formatPlatformName(platform) {
+  return getPlatformInstaller(platform)?.displayName ?? platform;
+}
+function isPlatformName(platform) {
+  return Object.prototype.hasOwnProperty.call(PLATFORM_INSTALLERS, platform);
+}
+
+// src/system/detect-team.ts
+import { execFile } from "child_process";
+import { access as access2 } from "fs/promises";
+import path11 from "path";
+import process2 from "process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var NO_TEAM = {
+  isTeam: false,
+  contributors: 1,
+  recentActive: 1,
+  hasRemote: false
+};
+var REMOTE_PATTERN = /github\.com|gitlab\.com|bitbucket\.org/;
+var GIT_ENV = {
+  ...process2.env,
+  GIT_PAGER: "cat",
+  PAGER: "cat",
+  GIT_TERMINAL_PROMPT: "0"
+};
+async function detectTeamStatus(projectRoot) {
+  try {
+    await access2(path11.join(projectRoot, ".git"));
+    const inside = await runGit(projectRoot, [
+      "rev-parse",
+      "--is-inside-work-tree"
+    ]);
+    if (inside.trim() !== "true") return NO_TEAM;
+    const [allEmails, recentEmails, remotes] = await Promise.all([
+      runGit(projectRoot, ["log", "--all", "--format=%ae"]),
+      runGit(projectRoot, ["log", "--since=30 days ago", "--format=%ae"]),
+      runGit(projectRoot, ["remote", "-v"])
+    ]);
+    const contributors = countUniqueLines(allEmails);
+    const recentActive = countUniqueLines(recentEmails);
+    const hasRemote = REMOTE_PATTERN.test(remotes);
+    return {
+      isTeam: contributors > 1 && hasRemote && recentActive > 1,
+      contributors: contributors || 1,
+      recentActive: recentActive || 1,
+      hasRemote
+    };
+  } catch {
+    return NO_TEAM;
+  }
+}
+async function runGit(cwd, args) {
+  const { stdout: stdout2 } = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    env: GIT_ENV,
+    windowsHide: true
+  });
+  return stdout2;
+}
+function countUniqueLines(output) {
+  return new Set(
+    output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  ).size;
+}
+
+// src/system/detect.ts
+import { execFile as execFile2 } from "child_process";
+import process3 from "process";
+import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 async function detectSystemDeps(env = process3.env) {
   try {
@@ -3012,8 +3293,8 @@ async function detectSystemDeps(env = process3.env) {
 
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
-import { promises as fs } from "fs";
-import path11 from "path";
+import { promises as fs2 } from "fs";
+import path12 from "path";
 import process4 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -3118,7 +3399,7 @@ async function detectPlatformHints(rootDir, environment = process4.env) {
     hints.add("copilot");
   const exists = async (relative) => {
     try {
-      await fs.access(path11.join(rootDir, relative));
+      await fs2.access(path12.join(rootDir, relative));
       return true;
     } catch {
       return false;
@@ -3194,7 +3475,7 @@ function createTerminalPrompter() {
 
 // src/system/project-profile.ts
 import { readFile as readFile7, readdir as readdir3, stat as stat2 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var PROJECT_MANIFESTS = [
   "package.json",
   "pyproject.toml",
@@ -3227,12 +3508,12 @@ async function detectProjectProfile(projectRoot) {
     "data",
     "notebooks"
   ]);
-  const packageJson = await readJson2(path12.join(projectRoot, "package.json"));
+  const packageJson = await readJson2(path13.join(projectRoot, "package.json"));
   const [pubspec, pythonManifests] = await Promise.all([
-    readText(path12.join(projectRoot, "pubspec.yaml")),
+    readText(path13.join(projectRoot, "pubspec.yaml")),
     Promise.all([
-      readText(path12.join(projectRoot, "pyproject.toml")),
-      readText(path12.join(projectRoot, "requirements.txt"))
+      readText(path13.join(projectRoot, "pyproject.toml")),
+      readText(path13.join(projectRoot, "requirements.txt"))
     ]).then((parts) => parts.filter(Boolean).join("\n"))
   ]);
   const deps = Object.keys({
@@ -3241,7 +3522,7 @@ async function detectProjectProfile(projectRoot) {
     ...packageJson?.peerDependencies
   });
   const flutter = isFlutterProject(pubspec);
-  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path12.join(projectRoot, "src", "components", "ui"));
+  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path13.join(projectRoot, "src", "components", "ui"));
   const languages = inferLanguages(manifests, entries);
   const frameworks = inferFrameworks(
     deps,
@@ -3284,7 +3565,7 @@ async function existingDirs(root, candidates) {
   const found = [];
   for (const candidate of candidates) {
     try {
-      if ((await stat2(path12.join(root, candidate))).isDirectory())
+      if ((await stat2(path13.join(root, candidate))).isDirectory())
         found.push(candidate);
     } catch {
     }
@@ -3458,8 +3739,8 @@ function isFlutterProject(pubspec) {
 }
 
 // src/system/scan-aesthetics.ts
-import { promises as fs2 } from "fs";
-import path13 from "path";
+import { promises as fs3 } from "fs";
+import path14 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null) {
@@ -3472,7 +3753,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   const cssScan = await scanCssVariables(projectRoot);
   if (configResult) {
     sourceFiles.push(configResult.relPath);
-    const content = await fs2.readFile(configResult.absPath, "utf-8");
+    const content = await fs3.readFile(configResult.absPath, "utf-8");
     const inspectableContent = stripJsComments(content);
     const themeBlock = findKeyBlock(inspectableContent, "theme");
     if (themeBlock) {
@@ -3495,7 +3776,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists2(path13.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists3(path14.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -3520,8 +3801,8 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path13.join(projectRoot, name);
-    if (await pathExists2(absPath)) {
+    const absPath = path14.join(projectRoot, name);
+    if (await pathExists3(absPath)) {
       return { absPath, relPath: name };
     }
   }
@@ -3747,8 +4028,8 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path13.join(projectRoot, relRoot);
-    if (!await pathExists2(absRoot)) continue;
+    const absRoot = path14.join(projectRoot, relRoot);
+    if (!await pathExists3(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
   }
@@ -3761,16 +4042,16 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   let fileCount = visitedFiles;
   let entries;
   try {
-    entries = await fs2.readdir(dir);
+    entries = await fs3.readdir(dir);
   } catch {
     return fileCount;
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path13.join(dir, entry);
+    const abs = path14.join(dir, entry);
     let info;
     try {
-      info = await fs2.lstat(abs);
+      info = await fs3.lstat(abs);
     } catch {
       continue;
     }
@@ -3788,7 +4069,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path13.basename(dir);
+      base = path14.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -3810,9 +4091,9 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path13.join(projectRoot, relPath);
-    if (!await pathExists2(absPath)) continue;
-    const content = await fs2.readFile(absPath, "utf-8");
+    const absPath = path14.join(projectRoot, relPath);
+    if (!await pathExists3(absPath)) continue;
+    const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
     if (Object.keys(found).length === 0) continue;
     Object.assign(variables, found);
@@ -3855,8 +4136,8 @@ function toPascalCase(value) {
 }
 async function hasTailwindDep(projectRoot) {
   try {
-    const raw = await fs2.readFile(
-      path13.join(projectRoot, "package.json"),
+    const raw = await fs3.readFile(
+      path14.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -3870,9 +4151,9 @@ async function hasTailwindDep(projectRoot) {
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function pathExists2(p) {
+async function pathExists3(p) {
   try {
-    await fs2.access(p);
+    await fs3.access(p);
     return true;
   } catch {
     return false;
@@ -3887,9 +4168,9 @@ var EXIT_USER_CANCEL = 3;
 var EXIT_INIT_FAILED = 5;
 var DEFAULT_INIT_PLATFORM = "claude-code";
 async function init(rootDir = process5.cwd(), options = {}) {
-  const mancodeDir = path14.join(rootDir, ".mancode");
-  const stateFile = path14.join(mancodeDir, "state.json");
-  const wasInitialized = await pathExists3(stateFile);
+  const mancodeDir = path15.join(rootDir, ".mancode");
+  const stateFile = path15.join(mancodeDir, "state.json");
+  const wasInitialized = await pathExists4(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
   const locale = detectInitLocale(options.lang);
@@ -3925,7 +4206,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
       )
     );
   }
-  if (!await pathExists3(rootDir)) {
+  if (!await pathExists4(rootDir)) {
     console.error(
       localize(
         locale,
@@ -3935,26 +4216,28 @@ async function init(rootDir = process5.cwd(), options = {}) {
     );
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  const isGitRepo = await pathExists3(path14.join(rootDir, ".git"));
+  const isGitRepo = await pathExists4(path15.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   let isGenericProject = false;
   if (!isGitRepo && !hasManifest) {
     const genericSafety = await canInitializeGenericProject(rootDir);
-    if (!genericSafety.ok) {
+    if (!genericSafety.ok && !(wasInitialized && genericSafety.reason === "nonempty")) {
       printNotProjectDirectory(rootDir, locale, genericSafety.reason);
       return EXIT_NOT_A_PROJECT_DIR;
     }
-    const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
-    const confirmed = options.empty || options.yes ? true : prompter ? await prompter.confirmGenericProject({ rootDir, locale }) : false;
-    if (!confirmed) {
-      if (options.interactive) {
-        console.log(
-          locale === "zh-CN" ? "\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002" : "Initialization cancelled."
-        );
-        return EXIT_USER_CANCEL;
+    if (!wasInitialized) {
+      const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
+      const confirmed = options.empty || options.yes ? true : prompter ? await prompter.confirmGenericProject({ rootDir, locale }) : false;
+      if (!confirmed) {
+        if (options.interactive) {
+          console.log(
+            locale === "zh-CN" ? "\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002" : "Initialization cancelled."
+          );
+          return EXIT_USER_CANCEL;
+        }
+        printNotProjectDirectory(rootDir, locale, "empty");
+        return EXIT_NOT_A_PROJECT_DIR;
       }
-      printNotProjectDirectory(rootDir, locale, "empty");
-      return EXIT_NOT_A_PROJECT_DIR;
     }
     isGenericProject = true;
   }
@@ -4009,9 +4292,12 @@ async function init(rootDir = process5.cwd(), options = {}) {
       );
     }
     const existingPlatform = wasInitialized ? await readExistingInitPlatform(stateFile) : null;
+    const existingConfig = wasInitialized ? await readExistingInitPreferences(mancodeDir) : { platforms: [], minimalByPlatform: {} };
+    const recoverablePlatforms = wasInitialized && existingConfig.platforms.length === 0 ? await detectManagedInitPlatforms(rootDir) : [];
+    const forceReinstallPlatforms = options.force && options.platform === void 0 ? existingConfig.platforms.length > 0 ? existingConfig.platforms : recoverablePlatforms : [];
     const platformHints = await detectPlatformHints(rootDir);
     const selectedPlatforms = await selectInitPlatforms({
-      option: options.platform,
+      option: options.platform ?? (forceReinstallPlatforms.length > 0 ? forceReinstallPlatforms.join(",") : void 0),
       existingPlatform,
       hints: platformHints,
       interactive: options.interactive,
@@ -4048,13 +4334,17 @@ async function init(rootDir = process5.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path14.join(mancodeDir, "workflows"),
-      path14.join(mancodeDir, "preseason-reports")
+      path15.join(mancodeDir, "workflows"),
+      path15.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
-    const existingPreferences = wasInitialized ? await readExistingInitPreferences(mancodeDir, primaryPlatform) : {};
-    const initialMinimal = existingPreferences.minimal ?? false;
-    const existingTeamMode = existingPreferences.forceTeamMode === true ? "on" : existingPreferences.teamMode ?? "auto";
+    const platformMinimal = Object.fromEntries(
+      selectedPlatforms.map((platform) => [
+        platform,
+        existingConfig.minimalByPlatform[platform] ?? false
+      ])
+    );
+    const existingTeamMode = existingConfig.forceTeamMode === true ? "on" : existingConfig.teamMode ?? "auto";
     const teamModeEnabled = options.team ?? (existingTeamMode === "on" ? true : existingTeamMode === "off" ? false : team.isTeam);
     if (options.team === true) {
       console.log(
@@ -4100,12 +4390,12 @@ async function init(rootDir = process5.cwd(), options = {}) {
       await validateClaudeCodeSettings(rootDir);
     }
     await installMancodeCore(rootDir);
-    await fs3.mkdir(mancodeDir, { recursive: true });
+    await fs4.mkdir(mancodeDir, { recursive: true });
     const stateContent = `${JSON.stringify(state, null, 2)}
 `;
-    await fs3.writeFile(stateFile, stateContent, "utf-8");
-    await fs3.writeFile(
-      path14.join(mancodeDir, "project-profile.json"),
+    await fs4.writeFile(stateFile, stateContent, "utf-8");
+    await fs4.writeFile(
+      path15.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -4121,7 +4411,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
           ...Object.fromEntries(
             selectedPlatforms.map((platform) => [
               platform,
-              { minimal: initialMinimal }
+              { minimal: platformMinimal[platform] ?? false }
             ])
           )
         }
@@ -4142,12 +4432,12 @@ async function init(rootDir = process5.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path14.join(
+      const tokensPath = path15.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
       );
-      await fs3.writeFile(
+      await fs4.writeFile(
         tokensPath,
         `${JSON.stringify(tokens, null, 2)}
 `,
@@ -4208,7 +4498,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
         techStack: profileStack,
         uiLibrary,
         projectProfile: profile,
-        minimal: initialMinimal,
+        minimal: platformMinimal[installer.name] ?? false,
         force: options.force
       });
     }
@@ -4293,16 +4583,16 @@ async function init(rootDir = process5.cwd(), options = {}) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path14.join(mancodeDir, "config.json");
+  const configPath = path15.join(mancodeDir, "config.json");
   let config = {};
   try {
-    config = JSON.parse(await fs3.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
   } catch {
   }
   const existingPlatforms = Array.isArray(config.platforms) ? config.platforms.filter(
     (platform) => typeof platform === "string"
   ) : [];
-  const existingPlatformOptions = isRecord3(config.platformOptions) ? config.platformOptions : {};
+  const existingPlatformOptions = isRecord4(config.platformOptions) ? config.platformOptions : {};
   const definedPatch = Object.fromEntries(
     Object.entries(patch).filter(([, value]) => value !== void 0)
   );
@@ -4316,44 +4606,60 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
       ...patch.platformOptions
     }
   } : definedPatch;
-  await fs3.writeFile(
+  await fs4.writeFile(
     configPath,
     `${JSON.stringify({ ...config, ...mergedPatch }, null, 2)}
 `,
     "utf-8"
   );
 }
-async function readExistingInitPreferences(mancodeDir, platform) {
+async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs3.readFile(path14.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path15.join(mancodeDir, "config.json"), "utf-8")
     );
-    const preferences = {};
+    const preferences = {
+      platforms: Array.isArray(config.platforms) ? config.platforms.filter(
+        (platform) => typeof platform === "string" && getPlatformInstaller(platform) !== null
+      ) : [],
+      minimalByPlatform: {}
+    };
     if (typeof config.forceTeamMode === "boolean") {
       preferences.forceTeamMode = config.forceTeamMode;
     }
     if (config.teamMode === "auto" || config.teamMode === "on" || config.teamMode === "off") {
       preferences.teamMode = config.teamMode;
     }
-    if (Array.isArray(config.platforms) && config.platforms.includes(platform) && isRecord3(config.platformOptions)) {
-      const platformOptions = config.platformOptions[platform];
-      if (isRecord3(platformOptions) && platformOptions.minimal === true) {
-        preferences.minimal = true;
+    if (isRecord4(config.platformOptions)) {
+      for (const platform of preferences.platforms) {
+        const platformOptions = config.platformOptions[platform];
+        if (isRecord4(platformOptions) && platformOptions.minimal === true) {
+          preferences.minimalByPlatform[platform] = true;
+        }
       }
     }
     return preferences;
   } catch {
-    return {};
+    return { platforms: [], minimalByPlatform: {} };
   }
 }
 async function readExistingInitPlatform(stateFile) {
   try {
-    const state = JSON.parse(await fs3.readFile(stateFile, "utf-8"));
+    const state = JSON.parse(await fs4.readFile(stateFile, "utf-8"));
     return typeof state.platform === "string" && getPlatformInstaller(state.platform) ? state.platform : null;
   } catch {
     return null;
   }
 }
+async function detectManagedInitPlatforms(rootDir) {
+  const detected = await Promise.all(
+    getPlatformInstallers().map(async (platform) => ({
+      name: platform.name,
+      present: await isPlatformPresent(rootDir, platform.name)
+    }))
+  );
+  return detected.filter((platform) => platform.present).map(({ name }) => name);
+}
 async function selectInitPlatforms(input) {
   if (input.option !== void 0) {
     return parsePlatformSelection(input.option);
@@ -4376,17 +4682,17 @@ async function selectInitPlatforms(input) {
 }
 async function hasProjectManifest(rootDir) {
   for (const name of PROJECT_MANIFESTS) {
-    if (await pathExists3(path14.join(rootDir, name))) return true;
+    if (await pathExists4(path15.join(rootDir, name))) return true;
   }
   return false;
 }
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path14.resolve(rootDir);
-  if (resolved === path14.parse(resolved).root || resolved === path14.resolve(os.homedir())) {
+  const resolved = path15.resolve(rootDir);
+  if (resolved === path15.parse(resolved).root || resolved === path15.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
-    const entries = await fs3.readdir(resolved);
+    const entries = await fs4.readdir(resolved);
     const meaningfulEntries = entries.filter(
       (entry) => ![".DS_Store", "Thumbs.db", ".gitkeep"].includes(entry)
     );
@@ -4507,13 +4813,13 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path14.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path15.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
     filePaths.map(async (filePath) => {
       try {
-        return { filePath, content: await fs3.readFile(filePath, "utf-8") };
+        return { filePath, content: await fs4.readFile(filePath, "utf-8") };
       } catch (error) {
         if (isNodeError5(error) && error.code === "ENOENT") {
           return { filePath, content: null };
@@ -4526,39 +4832,39 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path14.dirname(filePath);
-    while (current !== path14.dirname(current)) {
+    let current = path15.dirname(filePath);
+    while (current !== path15.dirname(current)) {
       directories.add(current);
-      current = path14.dirname(current);
+      current = path15.dirname(current);
     }
   }
   return Promise.all(
     [...directories].map(async (dirPath) => ({
       dirPath,
-      existed: await pathExists3(dirPath)
+      existed: await pathExists4(dirPath)
     }))
   );
 }
 async function restoreFiles(snapshots) {
   for (const snapshot of snapshots) {
     if (snapshot.content === null) {
-      await fs3.rm(snapshot.filePath, { force: true });
+      await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs3.mkdir(path14.dirname(snapshot.filePath), { recursive: true });
-    await fs3.writeFile(snapshot.filePath, snapshot.content, "utf-8");
+    await fs4.mkdir(path15.dirname(snapshot.filePath), { recursive: true });
+    await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
 async function removeNewEmptyDirectories(snapshots) {
   const candidates = snapshots.filter((snapshot) => !snapshot.existed).sort((a, b) => b.dirPath.length - a.dirPath.length);
   for (const { dirPath } of candidates) {
     try {
-      await fs3.rmdir(dirPath);
+      await fs4.rmdir(dirPath);
     } catch {
     }
   }
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError5(error) {
@@ -4601,9 +4907,9 @@ function printPlatformCreatedFiles(platform, locale) {
 function localize(locale, chinese, english) {
   return locale === "zh-CN" ? chinese : english;
 }
-async function pathExists3(p) {
+async function pathExists4(p) {
   try {
-    await fs3.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
@@ -4614,286 +4920,6 @@ async function pathExists3(p) {
 import { promises as fs5 } from "fs";
 import path16 from "path";
 import process6 from "process";
-
-// src/installers/platform-status.ts
-import { promises as fs4 } from "fs";
-import path15 from "path";
-async function checkPlatformStatus(rootDir, platform, installed) {
-  const readiness = await checkPlatformReadiness(rootDir, platform);
-  return {
-    installed,
-    ready: installed && readiness.ready,
-    target: readiness.target,
-    detail: describeStatus(installed, readiness)
-  };
-}
-async function checkPlatformReadiness(rootDir, platform) {
-  if (platform === "claude-code") {
-    const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
-      fileMatches(
-        path15.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
-        (content) => isGeneratedClaudeSkill(content, "solo")
-      ),
-      claudeHooksRegistered(rootDir),
-      pathsExist([
-        path15.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path15.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
-      ])
-    ]);
-    const present = hasSoloSkill && registered && hasHookFiles;
-    const minimal = await isPlatformMinimal(rootDir, "claude-code");
-    const fullContentReady = minimal ? true : await claudeFullContentReady(rootDir);
-    return {
-      present,
-      ready: present && fullContentReady,
-      target: ".claude/",
-      readyDetail: present && fullContentReady ? minimal ? "solo skill and hooks ready" : "skills, agents, and hooks ready" : "skills, agents, hook files, or hook registration are incomplete"
-    };
-  }
-  if (platform === "cursor") {
-    const hasCoreRules = await allManagedSkills(
-      MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path15.join(rootDir, ".cursor", "rules", file)
-      ),
-      [CURSOR_RULE_MANAGED_MARKER]
-    );
-    if (await isPlatformMinimal(rootDir, "cursor")) {
-      return {
-        present: hasCoreRules,
-        ready: hasCoreRules,
-        target: ".cursor/rules/",
-        readyDetail: "mancode core rules present"
-      };
-    }
-    const [hasRules, hasCommands] = await Promise.all([
-      allManagedSkills(
-        MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path15.join(rootDir, ".cursor", "rules", file)
-        ),
-        [CURSOR_RULE_MANAGED_MARKER]
-      ),
-      allManagedSkills(
-        MODE_NAMES.map(
-          (mode) => path15.join(rootDir, ".cursor", "commands", `${mode}.md`)
-        ),
-        [MODE_FILE_MANAGED_MARKER]
-      )
-    ]);
-    return {
-      present: hasCoreRules,
-      ready: hasRules && hasCommands,
-      target: ".cursor/rules/ + .cursor/commands/",
-      readyDetail: hasRules && hasCommands ? "mancode rules and commands present" : "mode rules or commands are missing, incomplete, or user-authored"
-    };
-  }
-  if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path15.join(rootDir, "AGENTS.md"));
-    if (!hasBlock2) {
-      return {
-        present: false,
-        ready: false,
-        target: "AGENTS.md",
-        readyDetail: "managed block missing"
-      };
-    }
-    if (await isPlatformMinimal(rootDir, "codex")) {
-      return {
-        present: true,
-        ready: true,
-        target: "AGENTS.md",
-        readyDetail: "managed block present"
-      };
-    }
-    const skillsDir = path15.join(rootDir, ".agents", "skills");
-    const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
-      MANCODE_AGENT_SKILL_MARKERS
-    );
-    return {
-      present: true,
-      ready: hasSkills,
-      target: "AGENTS.md + .agents/skills/",
-      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
-    };
-  }
-  if (platform === "zcode") {
-    const hasBlock2 = await fileHasManagedBlock(
-      path15.join(rootDir, "AGENTS.md"),
-      ZCODE_MANCODE_START_MARKER,
-      ZCODE_MANCODE_END_MARKER
-    );
-    if (!hasBlock2) {
-      return {
-        present: false,
-        ready: false,
-        target: "AGENTS.md",
-        readyDetail: "managed block missing"
-      };
-    }
-    if (await isPlatformMinimal(rootDir, "zcode")) {
-      return {
-        present: true,
-        ready: true,
-        target: "AGENTS.md",
-        readyDetail: "managed block present"
-      };
-    }
-    const skillsDir = path15.join(rootDir, ".agents", "skills");
-    const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
-      MANCODE_AGENT_SKILL_MARKERS
-    );
-    return {
-      present: true,
-      ready: hasSkills,
-      target: "AGENTS.md + .agents/skills/",
-      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
-    };
-  }
-  const hasBlock = await fileHasManagedBlock(
-    path15.join(rootDir, ".github", "copilot-instructions.md")
-  );
-  if (!hasBlock) {
-    return {
-      present: false,
-      ready: false,
-      target: ".github/copilot-instructions.md",
-      readyDetail: "managed block missing"
-    };
-  }
-  if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path15.join(rootDir, ".github", "prompts");
-    const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path15.join(promptsDir, `${mode}.prompt.md`)),
-      [MODE_FILE_MANAGED_MARKER]
-    );
-    return {
-      present: true,
-      ready: hasPrompts,
-      target: ".github/copilot-instructions.md + .github/prompts/",
-      readyDetail: hasPrompts ? "managed block and prompts present" : "mode prompts are missing, incomplete, or user-authored"
-    };
-  }
-  return {
-    present: true,
-    ready: true,
-    target: ".github/copilot-instructions.md",
-    readyDetail: "managed block present"
-  };
-}
-function describeStatus(installed, readiness) {
-  if (installed && readiness.present) return readiness.readyDetail;
-  if (!installed && readiness.present) {
-    return "target files present but platform is not recorded in config";
-  }
-  return "missing generated files or registration";
-}
-async function allManagedSkills(paths, markers) {
-  const results = await Promise.all(
-    paths.map((filePath) => fileHasAnyMarker(filePath, markers))
-  );
-  return results.every(Boolean);
-}
-async function claudeFullContentReady(rootDir) {
-  const skillChecks = MVP2_SKILLS.map(
-    (skill) => fileMatches(
-      path15.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
-      (content) => isGeneratedClaudeSkill(content, skill.name)
-    )
-  );
-  const agentChecks = ALL_AGENTS.map(
-    (agent) => fileMatches(
-      path15.join(rootDir, ".claude", "agents", `${agent.name}.md`),
-      (content) => isGeneratedClaudeAgent(content, agent.name)
-    )
-  );
-  const results = await Promise.all([...skillChecks, ...agentChecks]);
-  return results.every(Boolean);
-}
-async function fileMatches(filePath, predicate) {
-  try {
-    return predicate(await fs4.readFile(filePath, "utf-8"));
-  } catch {
-    return false;
-  }
-}
-async function pathsExist(paths) {
-  return (await Promise.all(paths.map(pathExists4))).every(Boolean);
-}
-async function fileHasAnyMarker(filePath, needles) {
-  try {
-    const content = await fs4.readFile(filePath, "utf-8");
-    return needles.some((needle) => content.includes(needle));
-  } catch {
-    return false;
-  }
-}
-async function isPlatformMinimal(rootDir, platform) {
-  try {
-    const raw = await fs4.readFile(
-      path15.join(rootDir, ".mancode", "config.json"),
-      "utf-8"
-    );
-    const config = JSON.parse(raw);
-    if (!isRecord4(config.platformOptions)) return false;
-    const options = config.platformOptions[platform];
-    return isRecord4(options) && options.minimal === true;
-  } catch {
-    return false;
-  }
-}
-async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
-  try {
-    const content = await fs4.readFile(filePath, "utf-8");
-    return hasManagedBlock(content, startMarker, endMarker);
-  } catch {
-    return false;
-  }
-}
-async function claudeHooksRegistered(rootDir) {
-  try {
-    const raw = await fs4.readFile(
-      path15.join(rootDir, ".claude", "settings.json"),
-      "utf-8"
-    );
-    const settings = JSON.parse(raw);
-    return hooksRegistered(settings);
-  } catch {
-    return false;
-  }
-}
-function hooksRegistered(settings) {
-  if (!isRecord4(settings)) return false;
-  const hooks = settings.hooks;
-  if (!isRecord4(hooks)) return false;
-  return hasHookCommand(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand(
-    hooks.UserPromptSubmit,
-    ".mancode/hooks/user-prompt-submit.mjs"
-  );
-}
-function hasHookCommand(value, needle) {
-  if (!Array.isArray(value)) return false;
-  return value.some((group) => {
-    if (!isRecord4(group) || !Array.isArray(group.hooks)) return false;
-    return group.hooks.some((hook) => {
-      if (!isRecord4(hook) || typeof hook.command !== "string") return false;
-      return hook.command.includes(needle);
-    });
-  });
-}
-async function pathExists4(p) {
-  try {
-    await fs4.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/commands/install.ts
 var EXIT_OK2 = 0;
 var EXIT_NOT_INITIALIZED = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;