mancode 0.3.3 → 0.3.5

package/dist/cli.js

@@ -7,9 +7,10 @@ import {
 import { program } from "commander";
 
 // src/commands/init.ts
-import { promises as fs2 } from "fs";
-import path13 from "path";
-import process4 from "process";
+import { promises as fs3 } from "fs";
+import os from "os";
+import path14 from "path";
+import process5 from "process";
 
 // src/installers/claude-code.ts
 import {
@@ -1385,6 +1386,7 @@ var DEFAULT_CONFIG = {
   platforms: ["claude-code"],
   cliCommand: "mancode",
   cliArgs: [],
+  teamMode: "auto",
   forceTeamMode: false,
   defaultStyle: null,
   hooks: {
@@ -1773,100 +1775,10 @@ function isNodeError2(err) {
   return err instanceof Error && "code" in err;
 }
 
-// src/installers/codex.ts
-import { writeFile as writeFile5 } from "fs/promises";
+// src/installers/cursor.ts
+import { mkdir as mkdir5, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "fs/promises";
 import path6 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/mode-skills.ts
 import { mkdir as mkdir4, readFile as readFile4, readdir as readdir2, rm as rm2, writeFile as writeFile4 } from "fs/promises";
 import path4 from "path";
@@ -2452,99 +2364,7 @@ function formatValue(value) {
   return "";
 }
 
-// src/installers/codex.ts
-async function installCodex(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const agentsPath = path6.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 writeFile5(agentsPath, replaceManagedBlock(existing, block), "utf-8");
-  await installCodexSkills(projectRoot, options.minimal ?? false);
-}
-
-// src/installers/copilot.ts
-import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import path7 from "path";
-async function installCopilot(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const githubDir = path7.join(projectRoot, ".github");
-  await mkdir5(githubDir, { recursive: true });
-  const instructionsPath = path7.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 writeFile6(
-    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.",
-    "- mamba: 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/cursor.ts
-import { mkdir as mkdir6, readFile as readFile6, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import path8 from "path";
 var MANCODE_CURSOR_CORE_RULE_FILES = [
   "mancode-context.mdc",
   "mancode-practice.mdc",
@@ -2563,8 +2383,8 @@ var MANCODE_CURSOR_RULE_FILES = [
 ];
 async function installCursor(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const rulesDir = path8.join(projectRoot, ".cursor", "rules");
-  await mkdir6(rulesDir, { recursive: true });
+  const rulesDir = path6.join(projectRoot, ".cursor", "rules");
+  await mkdir5(rulesDir, { recursive: true });
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "cursor",
     displayName: "Cursor",
@@ -2652,14 +2472,14 @@ async function writeRule(rulesDir, fileName, description, alwaysApply, body) {
 
 ${body.trim()}
 `;
-  const rulePath = path8.join(rulesDir, fileName);
+  const rulePath = path6.join(rulesDir, fileName);
   const existing = await readTextIfExists4(rulePath);
   if (existing !== null && !isGeneratedCursorRule(existing, fileName)) {
     throw new Error(
       `refusing to overwrite user-authored Cursor rule: ${rulePath}`
     );
   }
-  await writeFile7(
+  await writeFile5(
     rulePath,
     content.replace("---\n\n", `---
 
@@ -2673,17 +2493,17 @@ async function removeAdvancedRules(rulesDir) {
   for (const fileName of MANCODE_CURSOR_ADVANCED_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
-  await removeLegacyCursorRules(path8.dirname(path8.dirname(rulesDir)));
+  await removeLegacyCursorRules(path6.dirname(path6.dirname(rulesDir)));
 }
 async function removeCursorGeneratedRules(projectRoot) {
-  const rulesDir = path8.join(projectRoot, ".cursor", "rules");
+  const rulesDir = path6.join(projectRoot, ".cursor", "rules");
   for (const fileName of MANCODE_CURSOR_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
   await removeLegacyCursorRules(projectRoot);
 }
 async function removeLegacyCursorRules(projectRoot) {
-  const legacyPath = path8.join(
+  const legacyPath = path6.join(
     projectRoot,
     ".cursor",
     "rules",
@@ -2698,7 +2518,7 @@ async function removeLegacyCursorRules(projectRoot) {
   }
 }
 async function removeGeneratedCursorRule(rulesDir, fileName) {
-  const rulePath = path8.join(rulesDir, fileName);
+  const rulePath = path6.join(rulesDir, fileName);
   const content = await readTextIfExists4(rulePath);
   if (content && isGeneratedCursorRule(content, fileName)) {
     await rm3(rulePath, { force: true });
@@ -2768,78 +2588,262 @@ function renderManpsRule() {
   return renderModeSkill("manps", "/");
 }
 
-// src/installers/zcode.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import path9 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 existing = await readTextIfExists(agentsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
-    platform: "zcode",
-    displayName: "ZCode",
-    capabilities: {
-      slashCommands: "partial",
-      subagents: false,
-      hooks: false,
-      skills: "agents-skills"
-    },
-    minimal: options.minimal,
-    techStack: options.techStack,
-    uiLibrary: options.uiLibrary,
-    projectProfile: options.projectProfile
-  });
-  const block = [
-    ZCODE_MANCODE_START_MARKER,
-    "<!-- Managed by mancode. Do not edit this block manually. -->",
-    "",
-    "# mancode Configuration",
-    "",
-    sharedContent.trim(),
-    ZCODE_MANCODE_END_MARKER
-  ].join("\n");
-  await writeFile8(
-    agentsPath,
-    replaceManagedBlock(
-      existing,
-      block,
-      ZCODE_MANCODE_START_MARKER,
-      ZCODE_MANCODE_END_MARKER
-    ),
-    "utf-8"
-  );
-  await installZcodeSkills(projectRoot, options.minimal ?? false);
-}
+// src/installers/codex.ts
+import { writeFile as writeFile6 } from "fs/promises";
+import path7 from "path";
 
-// 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)",
+// 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/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.",
+    "- mamba: 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";
+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 existing = await readTextIfExists(agentsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
+    platform: "zcode",
+    displayName: "ZCode",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    minimal: options.minimal,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const block = [
+    ZCODE_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode Configuration",
+    "",
+    sharedContent.trim(),
+    ZCODE_MANCODE_END_MARKER
+  ].join("\n");
+  await writeFile8(
+    agentsPath,
+    replaceManagedBlock(
+      existing,
+      block,
+      ZCODE_MANCODE_START_MARKER,
+      ZCODE_MANCODE_END_MARKER
+    ),
+    "utf-8"
+  );
+  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,
@@ -2932,13 +2936,13 @@ async function detectTeamStatus(projectRoot) {
   }
 }
 async function runGit(cwd, args) {
-  const { stdout } = await execFileAsync("git", args, {
+  const { stdout: stdout2 } = await execFileAsync("git", args, {
     cwd,
     encoding: "utf-8",
     env: GIT_ENV,
     windowsHide: true
   });
-  return stdout;
+  return stdout2;
 }
 function countUniqueLines(output) {
   return new Set(
@@ -2963,9 +2967,191 @@ 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 process4 from "process";
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+var ALL_PLATFORMS = Object.keys(PLATFORM_INSTALLERS);
+var cachedNativeSystemLocale;
+function detectInitLocale(override, environment = process4.env, systemLocale = Intl.DateTimeFormat().resolvedOptions().locale, nativeLocale) {
+  if (override) return parseLocale(override);
+  const resolvedNativeLocale = nativeLocale === void 0 ? getNativeSystemLocale() : nativeLocale;
+  return parseLocale(resolvedNativeLocale) ?? detectEnvironmentLocale(environment) ?? parseLocale(systemLocale) ?? "en";
+}
+function detectNativeSystemLocale(platform = process4.platform, runCommand = runLocaleCommand) {
+  if (platform === "darwin") {
+    const languages = runCommand("defaults", ["read", "-g", "AppleLanguages"]);
+    const primaryLanguage = parsePrimaryAppleLanguage(languages);
+    if (primaryLanguage) return primaryLanguage;
+    return cleanLocaleOutput(
+      runCommand("defaults", ["read", "-g", "AppleLocale"])
+    );
+  }
+  if (platform === "win32") {
+    return cleanLocaleOutput(
+      runCommand("powershell.exe", [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "[System.Globalization.CultureInfo]::CurrentUICulture.Name"
+      ])
+    );
+  }
+  return null;
+}
+function getNativeSystemLocale() {
+  if (cachedNativeSystemLocale === void 0) {
+    cachedNativeSystemLocale = detectNativeSystemLocale();
+  }
+  return cachedNativeSystemLocale;
+}
+function detectEnvironmentLocale(environment) {
+  const candidates = [
+    environment.LANGUAGE,
+    environment.LC_ALL,
+    environment.LC_MESSAGES,
+    environment.LANG
+  ];
+  for (const candidate of candidates) {
+    for (const locale of candidate?.split(":") ?? []) {
+      const parsed = parseLocale(locale);
+      if (parsed) return parsed;
+    }
+  }
+  return null;
+}
+function runLocaleCommand(command, args) {
+  try {
+    const output = execFileSync(command, [...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3,
+      windowsHide: true
+    });
+    return cleanLocaleOutput(output);
+  } catch {
+    return null;
+  }
+}
+function parsePrimaryAppleLanguage(output) {
+  const cleaned = cleanLocaleOutput(output);
+  if (!cleaned) return null;
+  const quoted = cleaned.match(/"([^"]+)"/)?.[1];
+  if (quoted) return quoted;
+  return cleaned.split(/[\s(),]+/).find((value) => /^[a-z]{2,3}(?:[-_][a-z0-9]+)*$/i.test(value)) ?? null;
+}
+function cleanLocaleOutput(output) {
+  const cleaned = output?.replace(/^\uFEFF/, "").trim();
+  return cleaned || null;
+}
+function parseLocale(value) {
+  if (!value) return null;
+  const normalized = value.toLowerCase().replace("_", "-");
+  if (normalized === "zh" || normalized.startsWith("zh-")) return "zh-CN";
+  if (normalized === "en" || normalized.startsWith("en-")) return "en";
+  return null;
+}
+function parsePlatformSelection(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all" || normalized === "\u5168\u90E8") return [...ALL_PLATFORMS];
+  const choices = normalized.split(",").map((item) => item.trim()).filter(Boolean);
+  if (choices.length === 0) return null;
+  if (!choices.every((item) => item in PLATFORM_INSTALLERS)) {
+    return null;
+  }
+  return [...new Set(choices)];
+}
+async function detectPlatformHints(rootDir, environment = process4.env) {
+  const hints = /* @__PURE__ */ new Set();
+  if (environment.CLAUDECODE || environment.CLAUDE_CODE)
+    hints.add("claude-code");
+  if (environment.CODEX_HOME) hints.add("codex");
+  if (environment.CURSOR_TRACE_ID) hints.add("cursor");
+  if (environment.COPILOT_AGENT || environment.GITHUB_COPILOT)
+    hints.add("copilot");
+  const exists = async (relative) => {
+    try {
+      await fs.access(path11.join(rootDir, relative));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (await exists(".claude")) hints.add("claude-code");
+  if (await exists(".cursor")) hints.add("cursor");
+  if (await exists(".github/copilot-instructions.md")) hints.add("copilot");
+  return ALL_PLATFORMS.filter((platform) => hints.has(platform));
+}
+function createTerminalPrompter() {
+  return {
+    async confirmGenericProject({ rootDir, locale }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        if (locale === "zh-CN") {
+          console.log("\u5F53\u524D\u76EE\u5F55\u6CA1\u6709\u8BC6\u522B\u5230\u9879\u76EE\u6587\u4EF6\u3002");
+          console.log(`\u76EE\u5F55\uFF1A${rootDir}`);
+          console.log("\u8FD9\u662F\u4E00\u4E2A\u65B0\u9879\u76EE\u5417\uFF1F");
+          console.log("[y] \u521D\u59CB\u5316\u4E3A\u901A\u7528\u9879\u76EE");
+          console.log("[n] \u9000\u51FA");
+          const answer2 = await rl.question("\u8BF7\u9009\u62E9 [y/N]: ");
+          return ["y", "yes", "\u662F"].includes(answer2.trim().toLowerCase());
+        }
+        console.log("No project files were detected in the current directory.");
+        console.log(`Directory: ${rootDir}`);
+        console.log("Is this a new project?");
+        console.log("[y] Initialize as a generic project");
+        console.log("[n] Exit");
+        const answer = await rl.question("Choose [y/N]: ");
+        return ["y", "yes"].includes(answer.trim().toLowerCase());
+      } finally {
+        rl.close();
+      }
+    },
+    async selectPlatforms({ locale, detected }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        const names = ALL_PLATFORMS.map((platform, index) => {
+          const suffix = detected.includes(platform) ? locale === "zh-CN" ? "\uFF08\u5DF2\u68C0\u6D4B\u5230\uFF09" : " (detected)" : "";
+          return `${index + 1}. ${PLATFORM_INSTALLERS[platform].displayName}${suffix}`;
+        });
+        console.log(
+          locale === "zh-CN" ? "\n\u9009\u62E9\u8981\u521D\u59CB\u5316\u7684\u5E73\u53F0\uFF1A" : "\nChoose platforms to initialize:"
+        );
+        console.log(names.join("\n"));
+        console.log(locale === "zh-CN" ? "a. \u5168\u90E8\u5E73\u53F0" : "a. All platforms");
+        console.log(
+          locale === "zh-CN" ? "\u53EF\u8F93\u5165\u7F16\u53F7\uFF08\u4F8B\u5982 1,3\uFF09\u6216 a\u3002" : "Enter numbers (for example 1,3) or a."
+        );
+        const answer = (await rl.question(locale === "zh-CN" ? "\u9009\u62E9: " : "Selection: ")).trim().toLowerCase();
+        if (answer === "a" || answer === "all" || answer === "\u5168\u90E8")
+          return [...ALL_PLATFORMS];
+        const indexes = answer.split(",").map((item) => Number(item.trim()));
+        if (!indexes.length || indexes.some(
+          (index) => !Number.isInteger(index) || index < 1 || index > ALL_PLATFORMS.length
+        )) {
+          return null;
+        }
+        const selected = [];
+        for (const index of indexes) {
+          const platform = ALL_PLATFORMS[index - 1];
+          if (!platform) return null;
+          selected.push(platform);
+        }
+        return [...new Set(selected)];
+      } finally {
+        rl.close();
+      }
+    }
+  };
+}
+
 // src/system/project-profile.ts
 import { readFile as readFile7, readdir as readdir3, stat as stat2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var PROJECT_MANIFESTS = [
   "package.json",
   "pyproject.toml",
@@ -2998,12 +3184,12 @@ async function detectProjectProfile(projectRoot) {
     "data",
     "notebooks"
   ]);
-  const packageJson = await readJson2(path11.join(projectRoot, "package.json"));
+  const packageJson = await readJson2(path12.join(projectRoot, "package.json"));
   const [pubspec, pythonManifests] = await Promise.all([
-    readText(path11.join(projectRoot, "pubspec.yaml")),
+    readText(path12.join(projectRoot, "pubspec.yaml")),
     Promise.all([
-      readText(path11.join(projectRoot, "pyproject.toml")),
-      readText(path11.join(projectRoot, "requirements.txt"))
+      readText(path12.join(projectRoot, "pyproject.toml")),
+      readText(path12.join(projectRoot, "requirements.txt"))
     ]).then((parts) => parts.filter(Boolean).join("\n"))
   ]);
   const deps = Object.keys({
@@ -3012,7 +3198,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(path11.join(projectRoot, "src", "components", "ui"));
+  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path12.join(projectRoot, "src", "components", "ui"));
   const languages = inferLanguages(manifests, entries);
   const frameworks = inferFrameworks(
     deps,
@@ -3055,7 +3241,7 @@ async function existingDirs(root, candidates) {
   const found = [];
   for (const candidate of candidates) {
     try {
-      if ((await stat2(path11.join(root, candidate))).isDirectory())
+      if ((await stat2(path12.join(root, candidate))).isDirectory())
         found.push(candidate);
     } catch {
     }
@@ -3229,8 +3415,8 @@ function isFlutterProject(pubspec) {
 }
 
 // src/system/scan-aesthetics.ts
-import { promises as fs } from "fs";
-import path12 from "path";
+import { promises as fs2 } from "fs";
+import path13 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null) {
@@ -3243,7 +3429,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   const cssScan = await scanCssVariables(projectRoot);
   if (configResult) {
     sourceFiles.push(configResult.relPath);
-    const content = await fs.readFile(configResult.absPath, "utf-8");
+    const content = await fs2.readFile(configResult.absPath, "utf-8");
     const inspectableContent = stripJsComments(content);
     const themeBlock = findKeyBlock(inspectableContent, "theme");
     if (themeBlock) {
@@ -3266,7 +3452,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists2(path12.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists2(path13.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -3291,7 +3477,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path12.join(projectRoot, name);
+    const absPath = path13.join(projectRoot, name);
     if (await pathExists2(absPath)) {
       return { absPath, relPath: name };
     }
@@ -3518,7 +3704,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path12.join(projectRoot, relRoot);
+    const absRoot = path13.join(projectRoot, relRoot);
     if (!await pathExists2(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -3532,16 +3718,16 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   let fileCount = visitedFiles;
   let entries;
   try {
-    entries = await fs.readdir(dir);
+    entries = await fs2.readdir(dir);
   } catch {
     return fileCount;
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path12.join(dir, entry);
+    const abs = path13.join(dir, entry);
     let info;
     try {
-      info = await fs.lstat(abs);
+      info = await fs2.lstat(abs);
     } catch {
       continue;
     }
@@ -3559,7 +3745,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path12.basename(dir);
+      base = path13.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -3581,9 +3767,9 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path12.join(projectRoot, relPath);
+    const absPath = path13.join(projectRoot, relPath);
     if (!await pathExists2(absPath)) continue;
-    const content = await fs.readFile(absPath, "utf-8");
+    const content = await fs2.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
     if (Object.keys(found).length === 0) continue;
     Object.assign(variables, found);
@@ -3626,8 +3812,8 @@ function toPascalCase(value) {
 }
 async function hasTailwindDep(projectRoot) {
   try {
-    const raw = await fs.readFile(
-      path12.join(projectRoot, "package.json"),
+    const raw = await fs2.readFile(
+      path13.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -3643,7 +3829,7 @@ function escapeRegex(s) {
 }
 async function pathExists2(p) {
   try {
-    await fs.access(p);
+    await fs2.access(p);
     return true;
   } catch {
     return false;
@@ -3654,65 +3840,104 @@ async function pathExists2(p) {
 var EXIT_OK = 0;
 var EXIT_ALREADY_INITIALIZED = 1;
 var EXIT_NOT_A_PROJECT_DIR = 2;
+var EXIT_USER_CANCEL = 3;
 var EXIT_INIT_FAILED = 5;
 var DEFAULT_INIT_PLATFORM = "claude-code";
-async function init(rootDir = process4.cwd(), options = {}) {
-  const mancodeDir = path13.join(rootDir, ".mancode");
-  const stateFile = path13.join(mancodeDir, "state.json");
+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);
-  let reinstallSnapshots = [];
+  let mutationSnapshots = [];
+  let directorySnapshots = [];
+  const locale = detectInitLocale(options.lang);
+  if (!locale) {
+    console.error(`\u2717  Unsupported init language: ${options.lang}`);
+    console.error("   Supported values: zh-CN, en");
+    return EXIT_INIT_FAILED;
+  }
   if (wasInitialized) {
     if (!options.force) {
-      console.log("\u2139\uFE0F  mancode already initialized.");
+      console.log(
+        localize(
+          locale,
+          "\u2139\uFE0F  mancode \u5DF2\u7ECF\u521D\u59CB\u5316\u3002",
+          "\u2139\uFE0F  mancode already initialized."
+        )
+      );
       console.log(`   ${stateFile}`);
-      console.log("   Run `mancode init --force` to reinstall.");
+      console.log(
+        localize(
+          locale,
+          "   \u8FD0\u884C `mancode init --force` \u91CD\u65B0\u5B89\u88C5\u3002",
+          "   Run `mancode init --force` to reinstall."
+        )
+      );
       return EXIT_ALREADY_INITIALIZED;
     }
-    try {
-      reinstallSnapshots = await snapshotFiles([
-        stateFile,
-        path13.join(mancodeDir, "config.json"),
-        path13.join(mancodeDir, "project-profile.json"),
-        path13.join(mancodeDir, "aesthetics", "style-tokens.json")
-      ]);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`\u2717  Cannot snapshot existing mancode state: ${message}`);
-      return EXIT_INIT_FAILED;
-    }
-    console.log("\u26A0\uFE0F  Reinstalling with --force...");
+    console.log(
+      localize(
+        locale,
+        "\u26A0\uFE0F  \u6B63\u5728\u4F7F\u7528 --force \u91CD\u65B0\u5B89\u88C5...",
+        "\u26A0\uFE0F  Reinstalling with --force..."
+      )
+    );
   }
   if (!await pathExists3(rootDir)) {
-    console.error(`\u2717  Target directory does not exist: ${rootDir}`);
-    return EXIT_NOT_A_PROJECT_DIR;
-  }
-  const isGitRepo = await pathExists3(path13.join(rootDir, ".git"));
-  const hasManifest = await Promise.any(
-    PROJECT_MANIFESTS.map(async (name) => {
-      if (await pathExists3(path13.join(rootDir, name))) return true;
-      throw new Error("manifest missing");
-    })
-  ).catch(() => false);
-  if (!isGitRepo && !hasManifest) {
-    console.error(`\u2717  Not a project directory: ${rootDir}`);
-    console.error("   (No .git or recognized project manifest found)");
-    console.error("");
     console.error(
-      "   Run mancode init in a git repository or a recognized project directory."
+      localize(
+        locale,
+        `\u2717  \u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${rootDir}`,
+        `\u2717  Target directory does not exist: ${rootDir}`
+      )
     );
     return EXIT_NOT_A_PROJECT_DIR;
   }
+  const isGitRepo = await pathExists3(path14.join(rootDir, ".git"));
+  const hasManifest = await hasProjectManifest(rootDir);
+  let isGenericProject = false;
+  if (!isGitRepo && !hasManifest) {
+    const genericSafety = await canInitializeGenericProject(rootDir);
+    if (!genericSafety.ok) {
+      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;
+      }
+      printNotProjectDirectory(rootDir, locale, "empty");
+      return EXIT_NOT_A_PROJECT_DIR;
+    }
+    isGenericProject = true;
+  }
   try {
-    console.log("\u2713  \u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...");
+    console.log(
+      localize(
+        locale,
+        "\u2713  \u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...",
+        "\u2713  Checking system dependencies..."
+      )
+    );
     const deps = await detectSystemDeps();
     if (!deps.git) {
       console.log(
-        "\u26A0\uFE0F  Git not found (optional). Team auto-detection will use solo defaults."
+        localize(
+          locale,
+          "\u26A0\uFE0F  \u672A\u627E\u5230 Git\uFF08\u53EF\u9009\uFF09\u3002\u56E2\u961F\u81EA\u52A8\u68C0\u6D4B\u5C06\u4F7F\u7528 solo \u9ED8\u8BA4\u503C\u3002",
+          "\u26A0\uFE0F  Git not found (optional). Team auto-detection will use solo defaults."
+        )
       );
     } else {
       console.log("   git \u2713");
     }
-    console.log("\u2713  \u68C0\u6D4B\u9879\u76EE\u7C7B\u578B...");
+    console.log(
+      localize(locale, "\u2713  \u68C0\u6D4B\u9879\u76EE\u7C7B\u578B...", "\u2713  Detecting project type...")
+    );
     const profile = await detectProjectProfile(rootDir);
     const profileStack = [...profile.languages, ...profile.frameworks];
     const techStackStr = profileStack.join(" + ") || "Unknown";
@@ -3724,37 +3949,100 @@ async function init(rootDir = process4.cwd(), options = {}) {
         console.log(`   UI: ${uiLibraryStr}`);
       }
     } else if (hasManifest) {
-      console.log("   project manifest found, no known framework dependencies");
+      console.log(
+        localize(
+          locale,
+          "   \u5DF2\u53D1\u73B0\u9879\u76EE manifest\uFF0C\u672A\u8BC6\u522B\u5230\u6846\u67B6\u4F9D\u8D56",
+          "   Project manifest found; no known framework dependencies"
+        )
+      );
     } else {
       console.log(
-        "   (No recognized manifest found, profile confidence is low)"
+        localize(
+          locale,
+          "   \uFF08\u672A\u53D1\u73B0\u5DF2\u8BC6\u522B\u7684 manifest\uFF0C\u9879\u76EE\u753B\u50CF\u7F6E\u4FE1\u5EA6\u8F83\u4F4E\uFF09",
+          "   (No recognized manifest found; profile confidence is low)"
+        )
       );
     }
     const existingPlatform = wasInitialized ? await readExistingInitPlatform(stateFile) : null;
-    const initPlatformName = options.platform ?? existingPlatform ?? DEFAULT_INIT_PLATFORM;
-    const installer = getPlatformInstaller(initPlatformName);
-    if (!installer) {
-      console.error(`\u2717  Unsupported platform: ${initPlatformName}`);
+    const platformHints = await detectPlatformHints(rootDir);
+    const selectedPlatforms = await selectInitPlatforms({
+      option: options.platform,
+      existingPlatform,
+      hints: platformHints,
+      interactive: options.interactive,
+      prompter: options.prompter,
+      locale,
+      yes: options.yes
+    });
+    if (!selectedPlatforms) {
+      console.error(
+        locale === "zh-CN" ? "\u2717  \u672A\u9009\u62E9\u5E73\u53F0\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C\u5E76\u9009\u62E9\u5E73\u53F0\uFF0C\u6216\u4F7F\u7528 --platform codex,cursor / --platform all\u3002" : "\u2717  No platform selected. Choose one interactively or pass --platform codex,cursor / --platform all."
+      );
+      return EXIT_INIT_FAILED;
+    }
+    if (selectedPlatforms.length === 0) {
+      console.error("\u2717  No platform selected.");
+      return EXIT_INIT_FAILED;
+    }
+    const firstPlatform = selectedPlatforms[0];
+    if (!firstPlatform) {
+      console.error("\u2717  No platform selected.");
+      return EXIT_INIT_FAILED;
+    }
+    const installers = selectedPlatforms.map(getPlatformInstaller);
+    if (installers.some((installer) => !installer)) {
+      console.error(`\u2717  Unsupported platform: ${options.platform}`);
       return EXIT_INIT_FAILED;
     }
+    const typedInstallers = installers.filter(
+      (installer) => installer !== null
+    );
+    const onlyPlatformHint = platformHints.length === 1 ? platformHints[0] : null;
+    const detectedPrimary = onlyPlatformHint && selectedPlatforms.includes(onlyPlatformHint) ? onlyPlatformHint : null;
+    const primaryPlatform = existingPlatform && selectedPlatforms.includes(existingPlatform) ? existingPlatform : detectedPrimary ?? firstPlatform;
+    const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
+    mutationSnapshots = await snapshotFiles(managedFiles);
+    directorySnapshots = await snapshotDirectories(managedFiles, [
+      path14.join(mancodeDir, "workflows"),
+      path14.join(mancodeDir, "preseason-reports")
+    ]);
     const team = await detectTeamStatus(rootDir);
-    const existingPreferences = wasInitialized ? await readExistingInitPreferences(mancodeDir, installer.name) : {};
+    const existingPreferences = wasInitialized ? await readExistingInitPreferences(mancodeDir, primaryPlatform) : {};
     const initialMinimal = existingPreferences.minimal ?? false;
-    const teamModeEnabled = options.team ?? existingPreferences.forceTeamMode ?? team.isTeam;
+    const existingTeamMode = existingPreferences.forceTeamMode === true ? "on" : existingPreferences.teamMode ?? "auto";
+    const teamModeEnabled = options.team ?? (existingTeamMode === "on" ? true : existingTeamMode === "off" ? false : team.isTeam);
     if (options.team === true) {
-      console.log("   team: forced on (--team)");
+      console.log(
+        localize(
+          locale,
+          "   \u56E2\u961F\u6A21\u5F0F\uFF1A\u5F3A\u5236\u5F00\u542F\uFF08--team\uFF09",
+          "   team: forced on (--team)"
+        )
+      );
     } else if (options.team === false) {
-      console.log("   team: forced off (--no-team)");
+      console.log(
+        localize(
+          locale,
+          "   \u56E2\u961F\u6A21\u5F0F\uFF1A\u5F3A\u5236\u5173\u95ED\uFF08--no-team\uFF09",
+          "   team: forced off (--no-team)"
+        )
+      );
     } else if (team.isTeam) {
       console.log(
-        `   team: ${team.contributors} contributors (/manteam available)`
+        localize(
+          locale,
+          `   \u56E2\u961F\u6A21\u5F0F\uFF1A${team.contributors} \u4F4D\u8D21\u732E\u8005\uFF08\u53EF\u4F7F\u7528 /manteam\uFF09`,
+          `   team: ${team.contributors} contributors (/manteam available)`
+        )
       );
     }
     const state = {
       version: VERSION,
       currentMode: "solo",
       lastMode: "solo",
-      platform: installer.name,
+      platform: primaryPlatform,
       initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
       techStack: techStackStr,
       uiLibrary: uiLibraryStr,
@@ -3762,18 +4050,19 @@ async function init(rootDir = process4.cwd(), options = {}) {
       currentWorkflowMode: null,
       skippedSteps: [],
       teamModeAutoDetected: teamModeEnabled,
-      contributors: team.contributors
+      contributors: team.contributors,
+      projectMode: isGenericProject ? "generic" : "detected"
     };
-    if (installer.name === "claude-code") {
+    if (selectedPlatforms.includes("claude-code")) {
       await validateClaudeCodeSettings(rootDir);
     }
     await installMancodeCore(rootDir);
-    await fs2.mkdir(mancodeDir, { recursive: true });
+    await fs3.mkdir(mancodeDir, { recursive: true });
     const stateContent = `${JSON.stringify(state, null, 2)}
 `;
-    await fs2.writeFile(stateFile, stateContent, "utf-8");
-    await fs2.writeFile(
-      path13.join(mancodeDir, "project-profile.json"),
+    await fs3.writeFile(stateFile, stateContent, "utf-8");
+    await fs3.writeFile(
+      path14.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -3782,24 +4071,40 @@ async function init(rootDir = process4.cwd(), options = {}) {
       mancodeDir,
       {
         forceTeamMode: options.team === void 0 && wasInitialized ? void 0 : options.team === true,
+        teamMode: options.team === void 0 && wasInitialized ? void 0 : options.team === true ? "on" : options.team === false ? "off" : "auto",
         defaultStyle: options.style === void 0 && wasInitialized ? void 0 : options.style ?? null,
-        platforms: [installer.name],
+        platforms: selectedPlatforms,
         platformOptions: {
-          [installer.name]: { minimal: initialMinimal }
+          ...Object.fromEntries(
+            selectedPlatforms.map((platform) => [
+              platform,
+              { minimal: initialMinimal }
+            ])
+          )
         }
       },
       wasInitialized
     );
-    let styleLine = "  .mancode/aesthetics/        # style-tokens.json (\u7A7A)";
+    let styleLine = localize(
+      locale,
+      "  .mancode/aesthetics/        # style-tokens.json\uFF08\u7A7A\uFF09",
+      "  .mancode/aesthetics/        # style-tokens.json (empty)"
+    );
     if (profile.uiAssets === "detected") {
-      console.log("\u2713  \u626B\u63CF\u5BA1\u7F8E token...");
+      console.log(
+        localize(
+          locale,
+          "\u2713  \u626B\u63CF\u5BA1\u7F8E token...",
+          "\u2713  Scanning design tokens..."
+        )
+      );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path13.join(
+      const tokensPath = path14.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
       );
-      await fs2.writeFile(
+      await fs3.writeFile(
         tokensPath,
         `${JSON.stringify(tokens, null, 2)}
 `,
@@ -3809,70 +4114,146 @@ async function init(rootDir = process4.cwd(), options = {}) {
         const colorCount = Object.keys(tokens.colors).length;
         const fontCount = Object.keys(tokens.fonts).length;
         console.log(
-          `   ${colorCount} colors, ${fontCount} fonts (match: high)`
+          localize(
+            locale,
+            `   ${colorCount} \u4E2A\u989C\u8272\uFF0C${fontCount} \u4E2A\u5B57\u4F53\uFF08\u5339\u914D\u5EA6\uFF1A\u9AD8\uFF09`,
+            `   ${colorCount} colors, ${fontCount} fonts (match: high)`
+          )
+        );
+        styleLine = localize(
+          locale,
+          `  .mancode/aesthetics/        # style-tokens.json\uFF08${colorCount} \u4E2A\u989C\u8272\uFF09`,
+          `  .mancode/aesthetics/        # style-tokens.json (${colorCount} colors)`
         );
-        styleLine = `  .mancode/aesthetics/        # style-tokens.json (${colorCount} colors)`;
       } else if (tokens.matchLevel === "low") {
         console.log(
-          "   UI assets detected, no reusable tokens found (match: low)"
+          localize(
+            locale,
+            "   \u5DF2\u68C0\u6D4B\u5230 UI \u8D44\u6E90\uFF0C\u672A\u627E\u5230\u53EF\u590D\u7528 token\uFF08\u5339\u914D\u5EA6\uFF1A\u4F4E\uFF09",
+            "   UI assets detected; no reusable tokens found (match: low)"
+          )
+        );
+        styleLine = localize(
+          locale,
+          "  .mancode/aesthetics/        # style-tokens.json\uFF08\u4F4E\u5339\u914D\uFF09",
+          "  .mancode/aesthetics/        # style-tokens.json (low match)"
         );
-        styleLine = "  .mancode/aesthetics/        # style-tokens.json (low match)";
       } else {
-        console.log("   No design tokens found (match: none)");
-        styleLine = "  .mancode/aesthetics/        # style-tokens.json (no tokens)";
+        console.log(
+          localize(
+            locale,
+            "   \u672A\u627E\u5230\u8BBE\u8BA1 token\uFF08\u65E0\u5339\u914D\uFF09",
+            "   No design tokens found (match: none)"
+          )
+        );
+        styleLine = localize(
+          locale,
+          "  .mancode/aesthetics/        # style-tokens.json\uFF08\u65E0 token\uFF09",
+          "  .mancode/aesthetics/        # style-tokens.json (no tokens)"
+        );
       }
     }
-    console.log(`\u2713  \u5B89\u88C5 ${installer.displayName} \u9002\u914D...`);
-    await installer.install(rootDir, {
-      techStack: profileStack,
-      uiLibrary,
-      projectProfile: profile,
-      minimal: initialMinimal,
-      force: options.force
-    });
+    for (const installer of typedInstallers) {
+      console.log(
+        localize(
+          locale,
+          `\u2713  \u5B89\u88C5 ${installer.displayName} \u9002\u914D\u5668...`,
+          `\u2713  Installing ${installer.displayName} adapter...`
+        )
+      );
+      await installer.install(rootDir, {
+        techStack: profileStack,
+        uiLibrary,
+        projectProfile: profile,
+        minimal: initialMinimal,
+        force: options.force
+      });
+    }
     console.log("");
-    console.log("\u2713  mancode initialized.");
+    console.log(
+      localize(locale, "\u2713  mancode \u521D\u59CB\u5316\u5B8C\u6210\u3002", "\u2713  mancode initialized.")
+    );
     console.log("");
-    console.log("Created:");
-    console.log("  .mancode/state.json         # \u9879\u76EE\u72B6\u6001");
-    console.log("  .mancode/project-profile.json # \u68C0\u6D4B\u5230\u7684\u9879\u76EE\u4E8B\u5B9E");
-    console.log("  .mancode/config.json        # \u914D\u7F6E");
+    console.log(localize(locale, "\u5DF2\u521B\u5EFA\uFF1A", "Created:"));
     console.log(
-      "  .mancode/hooks/             # SessionStart + UserPromptSubmit"
+      localize(
+        locale,
+        "  .mancode/state.json         # \u9879\u76EE\u72B6\u6001",
+        "  .mancode/state.json         # project state"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .mancode/project-profile.json # \u68C0\u6D4B\u5230\u7684\u9879\u76EE\u4E8B\u5B9E",
+        "  .mancode/project-profile.json # detected project facts"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .mancode/config.json        # \u914D\u7F6E",
+        "  .mancode/config.json        # configuration"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .mancode/hooks/             # SessionStart + UserPromptSubmit",
+        "  .mancode/hooks/             # SessionStart + UserPromptSubmit"
+      )
     );
     console.log(styleLine);
     console.log("  .mancode/logs/              # hooks.log");
-    printPlatformCreatedFiles(installer.name);
+    for (const platform of selectedPlatforms)
+      printPlatformCreatedFiles(platform, locale);
     console.log("");
-    console.log("Next:");
-    console.log("  mancode status              # Show project state");
-    if (installer.name === "claude-code") {
-      console.log("  (Restart Claude Code to load hooks)");
-    } else if (installer.name === "codex") {
+    console.log(localize(locale, "\u4E0B\u4E00\u6B65\uFF1A", "Next:"));
+    console.log(
+      localize(
+        locale,
+        "  mancode status              # \u663E\u793A\u9879\u76EE\u72B6\u6001",
+        "  mancode status              # Show project state"
+      )
+    );
+    if (selectedPlatforms.includes("claude-code")) {
       console.log(
-        "  (If skills do not appear, restart the ChatGPT desktop app or Codex session)"
+        localize(
+          locale,
+          "  \uFF08\u91CD\u542F Claude Code \u4EE5\u52A0\u8F7D hooks\uFF09",
+          "  (Restart Claude Code to load hooks)"
+        )
+      );
+    }
+    if (selectedPlatforms.includes("codex")) {
+      console.log(
+        localize(
+          locale,
+          "  \uFF08\u5982\u679C skills \u672A\u51FA\u73B0\uFF0C\u8BF7\u91CD\u542F ChatGPT \u684C\u9762\u5E94\u7528\u6216 Codex \u4F1A\u8BDD\uFF09",
+          "  (If skills do not appear, restart the ChatGPT desktop app or Codex session)"
+        )
       );
     }
     return EXIT_OK;
   } catch (err) {
-    if (wasInitialized) {
-      await restoreFiles(reinstallSnapshots);
-    } else {
-      await fs2.rm(stateFile, { force: true });
-      await fs2.rm(path13.join(mancodeDir, "project-profile.json"), {
-        force: true
-      });
-    }
+    await restoreFiles(mutationSnapshots);
+    await removeNewEmptyDirectories(directorySnapshots);
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`\u2717  mancode init failed: ${msg}`);
+    console.error(
+      localize(
+        locale,
+        `\u2717  mancode \u521D\u59CB\u5316\u5931\u8D25\uFF1A${msg}`,
+        `\u2717  mancode init failed: ${msg}`
+      )
+    );
     return EXIT_INIT_FAILED;
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path13.join(mancodeDir, "config.json");
+  const configPath = path14.join(mancodeDir, "config.json");
   let config = {};
   try {
-    config = JSON.parse(await fs2.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs3.readFile(configPath, "utf-8"));
   } catch {
   }
   const existingPlatforms = Array.isArray(config.platforms) ? config.platforms.filter(
@@ -3892,7 +4273,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
       ...patch.platformOptions
     }
   } : definedPatch;
-  await fs2.writeFile(
+  await fs3.writeFile(
     configPath,
     `${JSON.stringify({ ...config, ...mergedPatch }, null, 2)}
 `,
@@ -3902,36 +4283,182 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir, platform) {
   try {
     const config = JSON.parse(
-      await fs2.readFile(path13.join(mancodeDir, "config.json"), "utf-8")
+      await fs3.readFile(path14.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {};
     if (typeof config.forceTeamMode === "boolean") {
       preferences.forceTeamMode = config.forceTeamMode;
     }
-    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 (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;
+      }
+    }
+    return preferences;
+  } catch {
+    return {};
+  }
+}
+async function readExistingInitPlatform(stateFile) {
+  try {
+    const state = JSON.parse(await fs3.readFile(stateFile, "utf-8"));
+    return typeof state.platform === "string" && getPlatformInstaller(state.platform) ? state.platform : null;
+  } catch {
+    return null;
+  }
+}
+async function selectInitPlatforms(input) {
+  if (input.option !== void 0) {
+    return parsePlatformSelection(input.option);
+  }
+  if (input.existingPlatform) return [input.existingPlatform];
+  if (input.yes && input.interactive !== void 0) {
+    return input.hints.length === 1 ? input.hints : null;
+  }
+  if (input.interactive) {
+    const prompter = input.prompter ?? createTerminalPrompter();
+    return prompter.selectPlatforms({
+      locale: input.locale,
+      detected: input.hints
+    });
+  }
+  if (input.interactive === false) {
+    return input.hints.length === 1 ? input.hints : null;
+  }
+  return [DEFAULT_INIT_PLATFORM];
+}
+async function hasProjectManifest(rootDir) {
+  for (const name of PROJECT_MANIFESTS) {
+    if (await pathExists3(path14.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())) {
+    return { ok: false, reason: "unsafe" };
+  }
+  try {
+    const entries = await fs3.readdir(resolved);
+    const meaningfulEntries = entries.filter(
+      (entry) => ![".DS_Store", "Thumbs.db", ".gitkeep"].includes(entry)
+    );
+    return meaningfulEntries.length === 0 ? { ok: true } : { ok: false, reason: "nonempty" };
+  } catch {
+    return { ok: false, reason: "unsafe" };
+  }
+}
+function printNotProjectDirectory(rootDir, locale, reason) {
+  if (locale === "zh-CN") {
+    console.error(`\u2717  \u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u53EF\u521D\u59CB\u5316\u7684\u9879\u76EE\u76EE\u5F55\uFF1A${rootDir}`);
+    if (reason === "unsafe") {
+      console.error("   \u4E3A\u907F\u514D\u8BEF\u5199\uFF0C\u4E0D\u80FD\u5728 Home \u76EE\u5F55\u6216\u78C1\u76D8\u6839\u76EE\u5F55\u521D\u59CB\u5316\u3002");
+    } else if (reason === "nonempty") {
+      console.error(
+        "   \u672A\u8BC6\u522B\u5230\u9879\u76EE\u6587\u4EF6\uFF0C\u4E14\u76EE\u5F55\u4E2D\u5DF2\u6709\u6587\u4EF6\u3002\u8BF7\u5148\u8FDB\u5165\u9879\u76EE\u76EE\u5F55\u3002"
+      );
+    } else {
+      console.error(
+        "   \u672A\u53D1\u73B0 .git \u6216\u9879\u76EE\u6587\u4EF6\u3002\u4EA4\u4E92\u7EC8\u7AEF\u4E2D\u53EF\u786E\u8BA4\u901A\u7528\u9879\u76EE\uFF0C\u6216\u4F7F\u7528 --empty\u3002"
+      );
+    }
+    return;
+  }
+  console.error(`\u2717  Not a project directory: ${rootDir}`);
+  if (reason === "unsafe") {
+    console.error(
+      "   Refusing to initialize a home directory or filesystem root."
+    );
+  } else if (reason === "nonempty") {
+    console.error(
+      "   No project files were detected and the directory is not empty."
+    );
+  } else {
+    console.error(
+      "   No .git or recognized project manifest found. Use an interactive terminal or --empty for a new project."
+    );
+  }
+}
+function getInitManagedFilePaths(rootDir, platforms) {
+  const files = [
+    ".mancode/state.json",
+    ".mancode/config.json",
+    ".mancode/project-profile.json",
+    ".mancode/aesthetics/style-tokens.json",
+    ".mancode/hooks/session-start.mjs",
+    ".mancode/hooks/user-prompt-submit.mjs",
+    ".mancode/logs/hooks.log",
+    ".mancode/memory/prd.md",
+    ".mancode/memory/spec.md",
+    ".mancode/memory/decisions.md"
+  ];
+  if (platforms.includes("claude-code")) {
+    files.push(
+      ".mancode/hooks/session-start.sh",
+      ".mancode/hooks/user-prompt-submit.sh",
+      ".claude/settings.json",
+      ".claude/skills/man8/SKILL.md",
+      ".claude/skills/solo/SKILL.md",
+      ".claude/skills/mancode-solo.md",
+      ".claude/skills/mancode-man8.md"
+    );
+    for (const mode of MODE_NAMES) {
+      files.push(
+        `.claude/skills/${mode}/SKILL.md`,
+        `.claude/skills/mancode-${mode}.md`
+      );
+    }
+    for (const agent of ALL_AGENTS) {
+      files.push(`.claude/agents/${agent.name}.md`);
     }
-    return preferences;
-  } catch {
-    return {};
   }
-}
-async function readExistingInitPlatform(stateFile) {
-  try {
-    const state = JSON.parse(await fs2.readFile(stateFile, "utf-8"));
-    return typeof state.platform === "string" && getPlatformInstaller(state.platform) ? state.platform : null;
-  } catch {
-    return null;
+  if (platforms.includes("cursor")) {
+    files.push(".cursor/rules/mancode-man8.mdc", ".cursor/commands/man8.md");
+    for (const fileName of MANCODE_CURSOR_RULE_FILES) {
+      files.push(`.cursor/rules/${fileName}`);
+    }
+    for (const mode of MODE_NAMES) {
+      files.push(`.cursor/commands/${mode}.md`);
+    }
+  }
+  if (platforms.includes("codex") || platforms.includes("zcode")) {
+    files.push("AGENTS.md", ".agents/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.agents/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("codex")) {
+    files.push(".codex/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.codex/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("zcode")) {
+    files.push(".zcode/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.zcode/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("copilot")) {
+    files.push(
+      ".github/copilot-instructions.md",
+      ".github/prompts/man8.prompt.md"
+    );
+    for (const mode of MODE_NAMES) {
+      files.push(`.github/prompts/${mode}.prompt.md`);
+    }
   }
+  return [...new Set(files.map((file) => path14.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
     filePaths.map(async (filePath) => {
       try {
-        return { filePath, content: await fs2.readFile(filePath, "utf-8") };
+        return { filePath, content: await fs3.readFile(filePath, "utf-8") };
       } catch (error) {
         if (isNodeError3(error) && error.code === "ENOENT") {
           return { filePath, content: null };
@@ -3941,14 +4468,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)) {
+      directories.add(current);
+      current = path14.dirname(current);
+    }
+  }
+  return Promise.all(
+    [...directories].map(async (dirPath) => ({
+      dirPath,
+      existed: await pathExists3(dirPath)
+    }))
+  );
+}
 async function restoreFiles(snapshots) {
   for (const snapshot of snapshots) {
     if (snapshot.content === null) {
-      await fs2.rm(snapshot.filePath, { force: true });
+      await fs3.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs2.mkdir(path13.dirname(snapshot.filePath), { recursive: true });
-    await fs2.writeFile(snapshot.filePath, snapshot.content, "utf-8");
+    await fs3.mkdir(path14.dirname(snapshot.filePath), { recursive: true });
+    await fs3.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);
+    } catch {
+    }
   }
 }
 function isRecord3(value) {
@@ -3957,10 +4509,22 @@ function isRecord3(value) {
 function isNodeError3(error) {
   return error instanceof Error && "code" in error;
 }
-function printPlatformCreatedFiles(platform) {
+function printPlatformCreatedFiles(platform, locale) {
   if (platform === "claude-code") {
-    console.log("  .claude/settings.json       # hook \u6CE8\u518C");
-    console.log("  .claude/skills/             # solo + MVP-2 slash skills");
+    console.log(
+      localize(
+        locale,
+        "  .claude/settings.json       # hook \u6CE8\u518C",
+        "  .claude/settings.json       # hook registration"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .claude/skills/             # solo + MVP-2 slash skills",
+        "  .claude/skills/             # solo + MVP-2 slash skills"
+      )
+    );
     return;
   }
   if (platform === "cursor") {
@@ -3979,9 +4543,12 @@ function printPlatformCreatedFiles(platform) {
   }
   console.log("  .github/copilot-instructions.md # Copilot instructions");
 }
+function localize(locale, chinese, english) {
+  return locale === "zh-CN" ? chinese : english;
+}
 async function pathExists3(p) {
   try {
-    await fs2.access(p);
+    await fs3.access(p);
     return true;
   } catch {
     return false;
@@ -3989,13 +4556,13 @@ async function pathExists3(p) {
 }
 
 // src/commands/install.ts
-import { promises as fs4 } from "fs";
-import path15 from "path";
-import process5 from "process";
+import { promises as fs5 } from "fs";
+import path16 from "path";
+import process6 from "process";
 
 // src/installers/platform-status.ts
-import { promises as fs3 } from "fs";
-import path14 from "path";
+import { promises as fs4 } from "fs";
+import path15 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -4009,13 +4576,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path14.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path15.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path14.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path14.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path15.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path15.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -4031,7 +4598,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path14.join(rootDir, ".cursor", "rules", file)
+        (file) => path15.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -4046,13 +4613,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path14.join(rootDir, ".cursor", "rules", file)
+          (file) => path15.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path14.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path15.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -4065,7 +4632,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path14.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path15.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -4082,9 +4649,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path14.join(rootDir, ".agents", "skills");
+    const skillsDir = path15.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -4096,7 +4663,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path14.join(rootDir, "AGENTS.md"),
+      path15.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -4116,9 +4683,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path14.join(rootDir, ".agents", "skills");
+    const skillsDir = path15.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -4129,7 +4696,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path14.join(rootDir, ".github", "copilot-instructions.md")
+    path15.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -4140,9 +4707,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path14.join(rootDir, ".github", "prompts");
+    const promptsDir = path15.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path15.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -4175,13 +4742,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path14.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path15.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path14.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path15.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -4190,7 +4757,7 @@ async function claudeFullContentReady(rootDir) {
 }
 async function fileMatches(filePath, predicate) {
   try {
-    return predicate(await fs3.readFile(filePath, "utf-8"));
+    return predicate(await fs4.readFile(filePath, "utf-8"));
   } catch {
     return false;
   }
@@ -4200,7 +4767,7 @@ async function pathsExist(paths) {
 }
 async function fileHasAnyMarker(filePath, needles) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return needles.some((needle) => content.includes(needle));
   } catch {
     return false;
@@ -4208,8 +4775,8 @@ async function fileHasAnyMarker(filePath, needles) {
 }
 async function isPlatformMinimal(rootDir, platform) {
   try {
-    const raw = await fs3.readFile(
-      path14.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs4.readFile(
+      path15.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -4222,7 +4789,7 @@ async function isPlatformMinimal(rootDir, platform) {
 }
 async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return hasManagedBlock(content, startMarker, endMarker);
   } catch {
     return false;
@@ -4230,8 +4797,8 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 }
 async function claudeHooksRegistered(rootDir) {
   try {
-    const raw = await fs3.readFile(
-      path14.join(rootDir, ".claude", "settings.json"),
+    const raw = await fs4.readFile(
+      path15.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -4261,7 +4828,7 @@ function hasHookCommand(value, needle) {
 }
 async function pathExists4(p) {
   try {
-    await fs3.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
@@ -4276,8 +4843,8 @@ var EXIT_OK2 = 0;
 var EXIT_NOT_INITIALIZED = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
-async function install(rootDir = process5.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path15.join(rootDir, ".mancode", "state.json");
+async function install(rootDir = process6.cwd(), platform = "claude-code", options = {}) {
+  const stateFile = path16.join(rootDir, ".mancode", "state.json");
   if (!await pathExists5(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
@@ -4363,9 +4930,9 @@ async function install(rootDir = process5.cwd(), platform = "claude-code", optio
   return EXIT_OK2;
 }
 async function readConfig(rootDir) {
-  const configPath = path15.join(rootDir, ".mancode", "config.json");
+  const configPath = path16.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await fs4.readFile(configPath, "utf-8");
+    const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
   } catch (err) {
     if (isNodeError4(err) && err.code === "ENOENT") {
@@ -4378,10 +4945,10 @@ function isNodeError4(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path15.join(rootDir, ".mancode", "config.json");
+  const configPath = path16.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
-  await fs4.writeFile(configPath, content, "utf-8");
+  await fs5.writeFile(configPath, content, "utf-8");
 }
 function withDefaultConfig(config, fallbackPlatform) {
   const fallback = fallbackPlatform ?? DEFAULT_CONFIG.platforms[0];
@@ -4413,8 +4980,8 @@ function readConfiguredMinimal(value, platform) {
 }
 async function readStatePlatform(rootDir) {
   try {
-    const raw = await fs4.readFile(
-      path15.join(rootDir, ".mancode", "state.json"),
+    const raw = await fs5.readFile(
+      path16.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -4425,7 +4992,7 @@ async function readStatePlatform(rootDir) {
 }
 async function pathExists5(p) {
   try {
-    await fs4.access(p);
+    await fs5.access(p);
     return true;
   } catch {
     return false;
@@ -4436,11 +5003,11 @@ function isRecord5(value) {
 }
 
 // src/commands/list-platforms.ts
-import { promises as fs5 } from "fs";
-import path16 from "path";
-import process6 from "process";
+import { promises as fs6 } from "fs";
+import path17 from "path";
+import process7 from "process";
 var EXIT_OK3 = 0;
-async function listPlatforms(rootDir = process6.cwd()) {
+async function listPlatforms(rootDir = process7.cwd()) {
   const installed = new Set(await readInstalledPlatforms(rootDir));
   const platforms = getPlatformInstallers();
   console.log("");
@@ -4453,8 +5020,8 @@ async function listPlatforms(rootDir = process6.cwd()) {
 }
 async function readInstalledPlatforms(rootDir) {
   try {
-    const raw = await fs5.readFile(
-      path16.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs6.readFile(
+      path17.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -4479,8 +5046,8 @@ function describePlatform(platform) {
 
 // src/commands/manps.ts
 import { access as access4 } from "fs/promises";
-import path18 from "path";
-import { createInterface } from "readline/promises";
+import path19 from "path";
+import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
 import { execFile as execFile3 } from "child_process";
@@ -4495,7 +5062,7 @@ import {
   rename,
   writeFile as writeFile9
 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -4575,9 +5142,9 @@ async function runPreseasonScan(projectRoot, area = "all") {
   const needsFiles = normalizedArea === "all" || normalizedArea === "dead-code" || normalizedArea === "config";
   const files = needsFiles ? await listProjectFiles(projectRoot) : [];
   const issues = (await scanArea(projectRoot, normalizedArea, pkg, files)).slice(0, 20);
-  const reportDir = path17.join(projectRoot, ".mancode", "preseason-reports");
+  const reportDir = path18.join(projectRoot, ".mancode", "preseason-reports");
   await mkdir7(reportDir, { recursive: true });
-  const issueDbPath = path17.join(
+  const issueDbPath = path18.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -4597,7 +5164,7 @@ async function runPreseasonScan(projectRoot, area = "all") {
   const database = await buildIssueDatabase(projectRoot, report);
   await writeFile9(reportPath, renderPreseasonReport(report), "utf-8");
   await writeFile9(
-    path17.join(projectRoot, ".mancode", "preseason-report.md"),
+    path18.join(projectRoot, ".mancode", "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -4605,7 +5172,7 @@ async function runPreseasonScan(projectRoot, area = "all") {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = path17.join(
+  const issueDbPath = path18.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -4719,7 +5286,7 @@ async function scanArea(projectRoot, area, pkg, files) {
 async function allocateReportPath(reportDir, baseName) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
-    const candidate = path17.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path18.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -4768,8 +5335,8 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path17.join(current, entry);
-    const rel = path17.relative(root, abs);
+    const abs = path18.join(current, entry);
+    const rel = path18.relative(root, abs);
     let info;
     try {
       info = await lstat(abs);
@@ -4779,7 +5346,7 @@ async function walk(root, current, results, depth) {
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path17.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path18.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -4787,7 +5354,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile8(path17.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile8(path18.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -4880,7 +5447,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path17.join(projectRoot, file);
+    const abs = path18.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -4917,7 +5484,7 @@ function scanTestGaps(files) {
   if (sourceFiles.length === 0) return [];
   const tests = new Set(files.filter((file) => file.startsWith("tests/")));
   const missing = sourceFiles.filter((file) => {
-    const base = path17.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path18.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -4926,13 +5493,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path17.basename(file)}.`,
+    detail: `No matching test file was found for ${path18.basename(file)}.`,
     recommendation: "Add focused coverage for the public behavior or document why this module is exercised indirectly."
   }));
 }
 function scanConfig(projectRoot, files) {
   const issues = [];
-  if (!files.includes(".gitignore") && !pathExistsSync(path17.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path18.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -4943,7 +5510,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path17.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path18.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -4962,7 +5529,7 @@ function scanAestheticDrift(projectRoot, files) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path17.join(projectRoot, file));
+      content = readFileSyncSafe(path18.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -4982,7 +5549,7 @@ function scanAestheticDrift(projectRoot, files) {
   return issues;
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path17.join(
+  const localBinary = path18.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -5030,7 +5597,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists6(path17.join(projectRoot, file)))
+    files.map((file) => pathExists6(path18.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -5056,11 +5623,11 @@ function runDepcruise(binary, projectRoot) {
         maxBuffer: DEPCRUISE_MAX_BUFFER,
         shell: needsShell
       },
-      (error, stdout, stderr) => {
+      (error, stdout2, stderr) => {
         if (!error) {
           resolve({
             status: "ok",
-            stdout,
+            stdout: stdout2,
             stderr,
             exitCode: 0,
             timedOut: false
@@ -5080,7 +5647,7 @@ function runDepcruise(binary, projectRoot) {
         }
         resolve({
           status: "failed",
-          stdout: nodeError.stdout ?? stdout,
+          stdout: nodeError.stdout ?? stdout2,
           stderr: nodeError.stderr ?? stderr,
           exitCode: typeof nodeError.code === "number" ? nodeError.code : null,
           timedOut: Boolean(nodeError.killed || nodeError.signal === "SIGTERM")
@@ -5136,9 +5703,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path17.relative(projectRoot, report.reportPath);
+  const reportRef = path18.relative(projectRoot, report.reportPath);
   const run = {
-    id: path17.basename(report.reportPath, ".md"),
+    id: path18.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -5244,7 +5811,7 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path17.join(projectRoot, ".gitignore");
+    const gitignorePath = path18.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
@@ -5253,7 +5820,7 @@ async function applySafeRemediation(projectRoot, issue) {
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path17.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path18.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
@@ -5293,7 +5860,7 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path17.join(projectRoot, "package.json");
+  const packagePath = path18.join(projectRoot, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile8(packagePath, "utf-8"));
@@ -5406,7 +5973,7 @@ var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  if (!await pathExists7(path18.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists7(path19.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
@@ -5485,8 +6052,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path18.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path18.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path19.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path19.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -5502,7 +6069,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path18.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path19.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK4;
@@ -5528,7 +6095,7 @@ async function runRemediation(rootDir, report, options, silent = false) {
       write
     });
   }
-  const rl = createInterface({
+  const rl = createInterface2({
     input: process.stdin,
     output: process.stdout
   });
@@ -5557,23 +6124,246 @@ async function pathExists7(p) {
   }
 }
 
-// src/commands/refresh-style.ts
-import { promises as fs6 } from "fs";
-import path19 from "path";
-import process7 from "process";
+// src/commands/refresh-project.ts
+import { randomUUID } from "crypto";
+import { promises as fs7 } from "fs";
+import path20 from "path";
+import process8 from "process";
 var EXIT_OK5 = 0;
 var EXIT_NOT_INITIALIZED3 = 1;
-async function refreshStyle(rootDir = process7.cwd()) {
-  const stateFile = path19.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists8(stateFile)) {
+var EXIT_CORRUPT_STATE = 2;
+var EXIT_REFRESH_FAILED = 3;
+async function refreshProject(rootDir = process8.cwd()) {
+  const mancodeDir = path20.join(rootDir, ".mancode");
+  const statePath = path20.join(mancodeDir, "state.json");
+  if (!await pathExists8(statePath)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
     return EXIT_NOT_INITIALIZED3;
   }
+  const state = await readRequiredState(statePath);
+  if (!state) {
+    console.error("\u2717  .mancode/state.json is corrupt or incomplete.");
+    console.error("   Run `mancode init --force` to repair it.");
+    return EXIT_CORRUPT_STATE;
+  }
+  let factsWritten = false;
+  try {
+    const [profile, team, hasGit, hasManifest] = await Promise.all([
+      detectProjectProfile(rootDir),
+      detectTeamStatus(rootDir),
+      pathExists8(path20.join(rootDir, ".git")),
+      hasProjectManifest2(rootDir)
+    ]);
+    const uiLibrary = primaryUiLibrary(profile);
+    const stack = [...profile.languages, ...profile.frameworks];
+    const config = await readJson3(path20.join(mancodeDir, "config.json"));
+    const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
+    const nextState = {
+      ...state,
+      techStack: stack.join(" + ") || profile.projectKind,
+      uiLibrary: uiLibrary ?? "None",
+      projectMode: hasGit || hasManifest ? "detected" : "generic",
+      teamModeAutoDetected: configuredTeam,
+      contributors: team.contributors
+    };
+    await writeProjectFacts(
+      statePath,
+      path20.join(mancodeDir, "project-profile.json"),
+      `${JSON.stringify(nextState, null, 2)}
+`,
+      `${JSON.stringify(profile, null, 2)}
+`
+    );
+    factsWritten = true;
+    const refreshedPlatforms = await refreshStaticPlatforms(
+      rootDir,
+      config,
+      state.platform,
+      stack,
+      uiLibrary,
+      profile
+    );
+    console.log("\u2713  Project facts refreshed.");
+    console.log(
+      `   ${hasGit ? "Git detected" : "No Git repository"} | ${hasManifest ? "project manifest detected" : "generic project"}`
+    );
+    console.log(
+      `   Stack: ${nextState.techStack} | UI: ${nextState.uiLibrary}`
+    );
+    if (refreshedPlatforms.length > 0) {
+      console.log(`   Refreshed adapters: ${refreshedPlatforms.join(", ")}`);
+    }
+    console.log(
+      "   Run `mancode refresh-style` if UI files or dependencies changed."
+    );
+    return EXIT_OK5;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`\u2717  Project refresh failed: ${message}`);
+    if (factsWritten) {
+      console.error(
+        "   Project facts were saved, but one or more static adapters remain stale."
+      );
+    }
+    return EXIT_REFRESH_FAILED;
+  }
+}
+async function hasProjectManifest2(rootDir) {
+  for (const manifest of PROJECT_MANIFESTS) {
+    if (await pathExists8(path20.join(rootDir, manifest))) return true;
+  }
+  return false;
+}
+async function writeProjectFacts(statePath, profilePath, stateContent, profileContent) {
+  await Promise.all([
+    ensureReplaceableFile(statePath),
+    ensureReplaceableFile(profilePath)
+  ]);
+  const previousProfile = await readOptionalText(profilePath);
+  const stateTemp = temporaryPath(statePath);
+  const profileTemp = temporaryPath(profilePath);
+  let profileReplaced = false;
+  try {
+    await Promise.all([
+      fs7.writeFile(stateTemp, stateContent, "utf-8"),
+      fs7.writeFile(profileTemp, profileContent, "utf-8")
+    ]);
+    await fs7.rename(profileTemp, profilePath);
+    profileReplaced = true;
+    await fs7.rename(stateTemp, statePath);
+  } catch (error) {
+    if (profileReplaced) {
+      if (previousProfile === null) {
+        await fs7.rm(profilePath, { force: true });
+      } else {
+        await replaceTextFile(profilePath, previousProfile);
+      }
+    }
+    throw error;
+  } finally {
+    await Promise.all([
+      fs7.rm(stateTemp, { force: true }),
+      fs7.rm(profileTemp, { force: true })
+    ]);
+  }
+}
+async function ensureReplaceableFile(filePath) {
+  try {
+    const entry = await fs7.lstat(filePath);
+    if (!entry.isFile()) {
+      throw new Error(`cannot replace non-file path: ${filePath}`);
+    }
+  } catch (error) {
+    if (isNodeError6(error) && error.code === "ENOENT") return;
+    throw error;
+  }
+}
+async function replaceTextFile(filePath, content) {
+  const tempPath = temporaryPath(filePath);
+  try {
+    await fs7.writeFile(tempPath, content, "utf-8");
+    await fs7.rename(tempPath, filePath);
+  } finally {
+    await fs7.rm(tempPath, { force: true });
+  }
+}
+async function readOptionalText(filePath) {
+  try {
+    return await fs7.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError6(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function temporaryPath(filePath) {
+  return path20.join(
+    path20.dirname(filePath),
+    `.${path20.basename(filePath)}.${process8.pid}.${randomUUID()}.tmp`
+  );
+}
+async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
+  const platforms = configuredPlatforms(config, fallbackPlatform).filter(
+    (platform) => platform !== "claude-code"
+  );
+  const refreshed = [];
+  for (const platform of platforms) {
+    const installer = getPlatformInstaller(platform);
+    if (!installer) continue;
+    await installer.install(rootDir, {
+      techStack: stack,
+      uiLibrary,
+      projectProfile: profile,
+      minimal: platformIsMinimal(config, platform),
+      force: true
+    });
+    refreshed.push(installer.displayName);
+  }
+  return refreshed;
+}
+function configuredPlatforms(config, fallbackPlatform) {
+  const configured = Array.isArray(config.platforms) ? config.platforms : [fallbackPlatform];
+  return configured.filter(
+    (platform) => typeof platform === "string" && getPlatformInstaller(platform) !== null
+  );
+}
+function platformIsMinimal(config, platform) {
+  if (!isRecord7(config.platformOptions)) return false;
+  const options = config.platformOptions[platform];
+  return isRecord7(options) && options.minimal === true;
+}
+async function readJson3(filePath) {
+  try {
+    const value = JSON.parse(await fs7.readFile(filePath, "utf-8"));
+    return isRecord7(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+async function readRequiredState(filePath) {
+  let state;
+  try {
+    const raw = await fs7.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord7(parsed)) return null;
+    state = parsed;
+  } catch {
+    return null;
+  }
+  return typeof state.version === "string" && typeof state.currentMode === "string" && typeof state.platform === "string" ? state : null;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError6(error) {
+  return error instanceof Error && "code" in error;
+}
+async function pathExists8(filePath) {
+  try {
+    await fs7.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/refresh-style.ts
+import { promises as fs8 } from "fs";
+import path21 from "path";
+import process9 from "process";
+var EXIT_OK6 = 0;
+var EXIT_NOT_INITIALIZED4 = 1;
+async function refreshStyle(rootDir = process9.cwd()) {
+  const stateFile = path21.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists9(stateFile)) {
+    console.error("\u2717  mancode not initialized.");
+    console.error("   Run `mancode init` first.");
+    return EXIT_NOT_INITIALIZED4;
+  }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path19.join(rootDir, ".mancode", "project-profile.json");
-  await fs6.writeFile(
+  const profilePath = path21.join(rootDir, ".mancode", "project-profile.json");
+  await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
 `,
@@ -5590,18 +6380,18 @@ async function refreshStyle(rootDir = process7.cwd()) {
     );
     console.log("   Updated .mancode/project-profile.json.");
     await printStaticPlatformRefreshHint(rootDir);
-    return EXIT_OK5;
+    return EXIT_OK6;
   }
   console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
   const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-  const tokensPath = path19.join(
+  const tokensPath = path21.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs6.mkdir(path19.dirname(tokensPath), { recursive: true });
-  await fs6.writeFile(
+  await fs8.mkdir(path21.dirname(tokensPath), { recursive: true });
+  await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
 `,
@@ -5649,7 +6439,7 @@ async function refreshStyle(rootDir = process7.cwd()) {
     "\u5DF2\u66F4\u65B0 .mancode/project-profile.json \u548C .mancode/aesthetics/style-tokens.json"
   );
   await printStaticPlatformRefreshHint(rootDir);
-  return EXIT_OK5;
+  return EXIT_OK6;
 }
 async function printStaticPlatformRefreshHint(rootDir) {
   const platforms = await readInstalledPlatforms2(rootDir);
@@ -5666,11 +6456,11 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path19.join(rootDir, ".mancode", "state.json");
+  const statePath = path21.join(rootDir, ".mancode", "state.json");
   try {
-    const state = JSON.parse(await fs6.readFile(statePath, "utf-8"));
+    const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
-    await fs6.writeFile(
+    await fs8.writeFile(
       statePath,
       `${JSON.stringify(
         {
@@ -5689,8 +6479,8 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 }
 async function readInstalledPlatforms2(rootDir) {
   try {
-    const raw = await fs6.readFile(
-      path19.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs8.readFile(
+      path21.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -5701,9 +6491,9 @@ async function readInstalledPlatforms2(rootDir) {
     return [];
   }
 }
-async function pathExists8(p) {
+async function pathExists9(p) {
   try {
-    await fs6.access(p);
+    await fs8.access(p);
     return true;
   } catch {
     return false;
@@ -5712,9 +6502,9 @@ async function pathExists8(p) {
 
 // src/commands/status.ts
 import { spawn } from "child_process";
-import { promises as fs7 } from "fs";
-import path22 from "path";
-import process8 from "process";
+import { promises as fs9 } from "fs";
+import path24 from "path";
+import process10 from "process";
 
 // src/system/workflow.ts
 import {
@@ -5725,11 +6515,11 @@ import {
   stat as stat4,
   writeFile as writeFile11
 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 
 // src/system/review-ledger.ts
 import { mkdir as mkdir8, readFile as readFile9, stat as stat3, writeFile as writeFile10 } from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 var REVIEW_FILE = "review-ledger.json";
 var TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
 var BLOCKER_ID_PATTERN = /^[A-Z][A-Z0-9-]{0,31}$/;
@@ -5845,8 +6635,8 @@ async function readReviewLedger(projectRoot, taskId) {
   }
 }
 function isReviewLedger(value) {
-  if (!isRecord7(value)) return false;
-  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord7(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
+  if (!isRecord8(value)) return false;
+  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord8(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
     return false;
   }
   const requiredDomains = value.requiredDomains;
@@ -5862,13 +6652,13 @@ function isReviewLedger(value) {
   }
   const blockerIds = /* @__PURE__ */ new Set();
   return blockers.every(
-    (blocker) => isRecord7(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
+    (blocker) => isRecord8(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
   );
 }
 function isDomainArray(value) {
   return Array.isArray(value) && value.every(isReviewDomain);
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function requireReviewLedger(projectRoot, taskId) {
@@ -5878,17 +6668,17 @@ async function requireReviewLedger(projectRoot, taskId) {
   return ledger;
 }
 async function writeReviewLedger(projectRoot, taskId, ledger) {
-  const dir = path20.join(projectRoot, ".mancode", "workflows", taskId);
+  const dir = path22.join(projectRoot, ".mancode", "workflows", taskId);
   await mkdir8(dir, { recursive: true });
   await writeFile10(
-    path20.join(dir, REVIEW_FILE),
+    path22.join(dir, REVIEW_FILE),
     `${JSON.stringify(ledger, null, 2)}
 `,
     "utf-8"
   );
 }
 function reviewPath(projectRoot, taskId) {
-  return path20.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
+  return path22.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
 }
 function assertValidTaskId(taskId) {
   if (!TASK_ID_PATTERN.test(taskId)) {
@@ -5901,7 +6691,7 @@ function assertSafeReportPath(report) {
   }
 }
 async function assertReportExists(projectRoot, taskId, report) {
-  const reportPath = path20.join(
+  const reportPath = path22.join(
     projectRoot,
     ".mancode",
     "workflows",
@@ -5915,9 +6705,9 @@ async function assertReportExists(projectRoot, taskId, report) {
   throw new Error(`review report not found: ${report}`);
 }
 function isSafeReportPath(report) {
-  const normalized = path20.posix.normalize(report.replaceAll("\\", "/"));
+  const normalized = path22.posix.normalize(report.replaceAll("\\", "/"));
   return Boolean(
-    report.trim() && !path20.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
+    report.trim() && !path22.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
   );
 }
 
@@ -5965,7 +6755,7 @@ async function allocateTaskId(projectRoot, baseTaskId) {
       await mkdir9(workflowDir(projectRoot, taskId));
       return taskId;
     } catch (err) {
-      if (isNodeError6(err) && err.code === "EEXIST") {
+      if (isNodeError7(err) && err.code === "EEXIST") {
         continue;
       }
       throw err;
@@ -6041,19 +6831,19 @@ async function deleteWorkflow(projectRoot, taskId) {
   return true;
 }
 function workflowsRoot(projectRoot) {
-  return path21.join(projectRoot, ".mancode", "workflows");
+  return path23.join(projectRoot, ".mancode", "workflows");
 }
 function workflowDir(projectRoot, taskId) {
   assertValidTaskId2(taskId);
-  return path21.join(workflowsRoot(projectRoot), taskId);
+  return path23.join(workflowsRoot(projectRoot), taskId);
 }
 function metadataPath(projectRoot, taskId) {
-  return path21.join(workflowDir(projectRoot, taskId), METADATA_FILE);
+  return path23.join(workflowDir(projectRoot, taskId), METADATA_FILE);
 }
 async function writeMetadata(dir, meta) {
   const content = `${JSON.stringify(meta, null, 2)}
 `;
-  await writeFile11(path21.join(dir, METADATA_FILE), content, "utf-8");
+  await writeFile11(path23.join(dir, METADATA_FILE), content, "utf-8");
 }
 function parseWorkflowMeta(raw, taskId) {
   try {
@@ -6259,7 +7049,7 @@ async function propagateChildStatus(projectRoot, child) {
     });
   }
 }
-function isNodeError6(err) {
+function isNodeError7(err) {
   return err instanceof Error && "code" in err;
 }
 function assertValidTaskId2(taskId) {
@@ -6270,19 +7060,19 @@ function assertValidTaskId2(taskId) {
 
 // src/commands/status.ts
 var HOOK_ESTIMATE_TIMEOUT_MS = 2e3;
-var EXIT_OK6 = 0;
-var EXIT_NOT_INITIALIZED4 = 1;
-var EXIT_CORRUPT_STATE = 2;
-async function status(rootDir = process8.cwd(), options = {}) {
-  const stateFile = path22.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists9(stateFile)) {
+var EXIT_OK7 = 0;
+var EXIT_NOT_INITIALIZED5 = 1;
+var EXIT_CORRUPT_STATE2 = 2;
+async function status(rootDir = process10.cwd(), options = {}) {
+  const stateFile = path24.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists10(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` to get started.");
-    return EXIT_NOT_INITIALIZED4;
+    return EXIT_NOT_INITIALIZED5;
   }
   let state;
   try {
-    const raw = await fs7.readFile(stateFile, "utf-8");
+    const raw = await fs9.readFile(stateFile, "utf-8");
     state = JSON.parse(raw);
   } catch (err) {
     if (err instanceof SyntaxError) {
@@ -6293,7 +7083,7 @@ async function status(rootDir = process8.cwd(), options = {}) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`\u2717  Failed to read .mancode/state.json: ${msg}`);
     }
-    return EXIT_CORRUPT_STATE;
+    return EXIT_CORRUPT_STATE2;
   }
   const [
     project,
@@ -6301,14 +7091,16 @@ async function status(rootDir = process8.cwd(), options = {}) {
     config,
     hookInjection,
     teamStatus,
-    currentWorkflow
+    currentWorkflow,
+    projectRefreshRecommended
   ] = await Promise.all([
     getProjectName(rootDir),
     checkHooks(rootDir),
     readConfig2(rootDir),
     estimateHookInjection(rootDir),
     detectTeamStatus(rootDir),
-    getCurrentWorkflow(rootDir, state.currentTask ?? null)
+    getCurrentWorkflow(rootDir, state.currentTask ?? null),
+    shouldRefreshProject(rootDir, state)
   ]);
   const effectiveTeam = getEffectiveTeamStatus(state, config, teamStatus);
   const result = {
@@ -6323,7 +7115,8 @@ async function status(rootDir = process8.cwd(), options = {}) {
     hookInjection,
     team: effectiveTeam,
     currentWorkflow,
-    platformStatus: {}
+    platformStatus: {},
+    projectRefreshRecommended
   };
   result.platformStatus = await checkPlatformStatus2(rootDir, result.platforms);
   if (options.json) {
@@ -6331,7 +7124,16 @@ async function status(rootDir = process8.cwd(), options = {}) {
   } else {
     printText(result);
   }
-  return EXIT_OK6;
+  return EXIT_OK7;
+}
+async function shouldRefreshProject(rootDir, state) {
+  if (state.projectMode !== "generic") return false;
+  const hasGit = await pathExists10(path24.join(rootDir, ".git"));
+  if (hasGit) return true;
+  for (const manifest of PROJECT_MANIFESTS) {
+    if (await pathExists10(path24.join(rootDir, manifest))) return true;
+  }
+  return false;
 }
 async function checkPlatformStatus2(rootDir, installedPlatforms) {
   const installed = new Set(installedPlatforms);
@@ -6373,19 +7175,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs7.readFile(path22.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path24.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path22.basename(rootDir);
+  return path24.basename(rootDir);
 }
 async function readConfig2(rootDir) {
   try {
-    const raw = await fs7.readFile(
-      path22.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs9.readFile(
+      path24.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -6400,21 +7202,22 @@ function getInstalledPlatforms(config, fallback) {
   return fallback ? [fallback] : [];
 }
 function getEffectiveTeamStatus(state, config, detected) {
-  const configuredTeam = config.forceTeamMode === true ? true : state.teamModeAutoDetected ?? detected.isTeam;
-  const forced = config.forceTeamMode === true;
+  const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : state.teamModeAutoDetected ?? detected.isTeam;
+  const forced = config.teamMode === "on" || config.forceTeamMode === true;
+  const autoDetected = config.forceTeamMode === true || config.teamMode === "on" || config.teamMode === "off" ? false : state.teamModeAutoDetected ?? detected.isTeam;
   return {
     ...detected,
     isTeam: configuredTeam,
     contributors: Math.max(detected.contributors, state.contributors ?? 0, 1),
-    autoDetected: forced ? false : state.teamModeAutoDetected ?? detected.isTeam,
+    autoDetected,
     forced
   };
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists9(path22.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
-    pathExists9(
-      path22.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+    pathExists10(path24.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists10(
+      path24.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -6422,8 +7225,8 @@ async function checkHooks(rootDir) {
 }
 async function isRegistered(rootDir) {
   try {
-    const raw = await fs7.readFile(
-      path22.join(rootDir, ".claude", "settings.json"),
+    const raw = await fs9.readFile(
+      path24.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -6433,9 +7236,9 @@ async function isRegistered(rootDir) {
   }
 }
 function hooksRegistered2(settings) {
-  if (!isRecord8(settings)) return false;
+  if (!isRecord9(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord8(hooks)) return false;
+  if (!isRecord9(hooks)) return false;
   return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand2(
     hooks.UserPromptSubmit,
     ".mancode/hooks/user-prompt-submit.mjs"
@@ -6444,21 +7247,21 @@ function hooksRegistered2(settings) {
 function hasHookCommand2(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord8(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord9(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord8(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord9(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path22.join(
+  const hookPath = path24.join(
     rootDir,
     ".mancode",
     "hooks",
     "user-prompt-submit.mjs"
   );
-  if (!await pathExists9(hookPath)) {
+  if (!await pathExists10(hookPath)) {
     return { tokens: 0, cap: 800 };
   }
   try {
@@ -6473,7 +7276,7 @@ async function estimateHookInjection(rootDir) {
 }
 function runHookEstimate(rootDir, hookPath) {
   return new Promise((resolve, reject) => {
-    const child = spawn(process8.execPath, [hookPath], {
+    const child = spawn(process10.execPath, [hookPath], {
       cwd: rootDir,
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -6488,15 +7291,15 @@ function runHookEstimate(rootDir, hookPath) {
       child.kill();
       finish(() => reject(new Error("hook estimate timed out")));
     }, HOOK_ESTIMATE_TIMEOUT_MS);
-    let stdout = "";
+    let stdout2 = "";
     child.stdout.setEncoding("utf-8");
     child.stdout.on("data", (chunk) => {
-      stdout += chunk;
+      stdout2 += chunk;
     });
     child.on("error", (err) => finish(() => reject(err)));
     child.on("close", (code) => {
       finish(() => {
-        if (code === 0) resolve(stdout);
+        if (code === 0) resolve(stdout2);
         else reject(new Error(`hook exited with ${code}`));
       });
     });
@@ -6515,6 +7318,11 @@ function printText(r) {
   console.log(`Style:       ${r.uiLibrary}`);
   console.log(`Initialized: ${r.initializedAt}`);
   console.log(`Team:        ${formatTeamStatus(r.team)}`);
+  if (r.projectRefreshRecommended) {
+    console.log(
+      "Project:     new Git or project files detected; run `mancode refresh-project`."
+    );
+  }
   if (r.currentWorkflow) {
     const stepMax = workflowStepMax(r.currentWorkflow.mode);
     console.log(
@@ -6578,12 +7386,12 @@ function formatTeamStatus(team) {
 function workflowStepMax(mode) {
   return maxWorkflowStep(mode);
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null;
 }
-async function pathExists9(p) {
+async function pathExists10(p) {
   try {
-    await fs7.access(p);
+    await fs9.access(p);
     return true;
   } catch {
     return false;
@@ -6592,17 +7400,17 @@ async function pathExists9(p) {
 
 // src/commands/uninstall.ts
 import { access as access5, readFile as readFile11, rm as rm5, writeFile as writeFile12 } from "fs/promises";
-import path23 from "path";
-import process9 from "process";
-var EXIT_OK7 = 0;
-var EXIT_NOT_INITIALIZED5 = 1;
+import path25 from "path";
+import process11 from "process";
+var EXIT_OK8 = 0;
+var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
-async function uninstall(rootDir = process9.cwd(), platform, options = {}) {
-  const stateFile = path23.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists10(stateFile)) {
+async function uninstall(rootDir = process11.cwd(), platform, options = {}) {
+  const stateFile = path25.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists11(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED5;
+    return EXIT_NOT_INITIALIZED6;
   }
   const removeAll = !platform || options.all;
   if (platform) {
@@ -6627,7 +7435,7 @@ async function uninstall(rootDir = process9.cwd(), platform, options = {}) {
     await uninstallPlatform(rootDir, platform ?? "claude-code");
   }
   console.log("\u2713  Uninstall complete.");
-  return EXIT_OK7;
+  return EXIT_OK8;
 }
 async function uninstallPlatform(rootDir, platform) {
   console.log(`\u2713  Removing ${formatPlatformName(platform)} adapter...`);
@@ -6650,7 +7458,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm5(path23.join(rootDir, ".mancode"), {
+  await rm5(path25.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -6660,7 +7468,7 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path23.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path25.join(rootDir, ".claude", "settings.json");
   let content;
   try {
     content = await readFile11(settingsPath, "utf-8");
@@ -6674,14 +7482,14 @@ async function cleanClaudeSettings(rootDir) {
     return;
   }
   const cleanedHooks = {};
-  if (isRecord9(settings.hooks)) {
+  if (isRecord10(settings.hooks)) {
     for (const [event, value] of Object.entries(settings.hooks)) {
       const cleaned = cleanClaudeHookValue(value);
       if (cleaned !== void 0) cleanedHooks[event] = cleaned;
     }
     settings.hooks = Object.keys(cleanedHooks).length > 0 ? cleanedHooks : void 0;
   }
-  if (isRecord9(settings.skills)) {
+  if (isRecord10(settings.skills)) {
     const retainedSkills = Object.fromEntries(
       Object.entries(settings.skills).filter(
         ([name, value]) => LEGACY_CLAUDE_SKILL_SETTINGS[name] !== value
@@ -6701,7 +7509,7 @@ function cleanClaudeHookValue(value) {
     const entries2 = value.flatMap(cleanClaudeHookEntry);
     return entries2.length > 0 ? entries2 : void 0;
   }
-  if (!isRecord9(value)) return value;
+  if (!isRecord10(value)) return value;
   if (Array.isArray(value.hooks) || typeof value.command === "string") {
     const entries2 = cleanClaudeHookEntry(value);
     return entries2.length > 0 ? entries2 : void 0;
@@ -6715,7 +7523,7 @@ function cleanClaudeHookValue(value) {
 }
 function cleanClaudeHookEntry(entry) {
   if (Array.isArray(entry)) return entry.flatMap(cleanClaudeHookEntry);
-  if (!isRecord9(entry)) return [entry];
+  if (!isRecord10(entry)) return [entry];
   if (Array.isArray(entry.hooks)) {
     const hooks = entry.hooks.filter((hook) => !isMancodeHookEntry(hook));
     return hooks.length > 0 ? [{ ...entry, hooks }] : [];
@@ -6723,11 +7531,11 @@ function cleanClaudeHookEntry(entry) {
   return isMancodeHookEntry(entry) ? [] : [entry];
 }
 function isMancodeHookEntry(value) {
-  return isRecord9(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
+  return isRecord10(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
 }
 function containsLegacyMancodeHookPath2(value) {
   if (Array.isArray(value)) return value.some(containsLegacyMancodeHookPath2);
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   if (typeof value.command === "string" && value.command.includes(".mancode/hooks/")) {
     return true;
   }
@@ -6738,7 +7546,7 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path23.join(rootDir, "AGENTS.md");
+  const agentsPath = path25.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile11(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
@@ -6753,7 +7561,7 @@ async function uninstallCodex(rootDir) {
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path23.join(
+  const instructionsPath = path25.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
@@ -6772,7 +7580,7 @@ async function uninstallCopilot(rootDir) {
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path23.join(rootDir, "AGENTS.md");
+  const agentsPath = path25.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile11(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -6791,13 +7599,13 @@ async function uninstallZcode(rootDir) {
   await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path23.join(rootDir, ".mancode", "config.json");
+  const configPath = path25.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await readFile11(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
-      if (isRecord9(config.platformOptions)) {
+      if (isRecord10(config.platformOptions)) {
         const platformOptions = Object.fromEntries(
           Object.entries(config.platformOptions).filter(
             ([name]) => name !== platform
@@ -6815,10 +7623,10 @@ async function removeFromConfig(rootDir, platform) {
   } catch {
   }
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function pathExists10(p) {
+async function pathExists11(p) {
   try {
     await access5(p);
     return true;
@@ -6828,10 +7636,10 @@ async function pathExists10(p) {
 }
 
 // src/commands/version.ts
-import process10 from "process";
+import process12 from "process";
 function version() {
-  const nodeVersion = process10.version;
-  const platform = `${process10.platform}/${process10.arch}`;
+  const nodeVersion = process12.version;
+  const platform = `${process12.platform}/${process12.arch}`;
   console.log(`mancode/${VERSION}`);
   console.log(`node/${nodeVersion.replace("v", "")}`);
   console.log(platform);
@@ -6839,19 +7647,19 @@ function version() {
 
 // src/commands/workflow.ts
 import { access as access6 } from "fs/promises";
-import path24 from "path";
-var EXIT_OK8 = 0;
-var EXIT_NOT_INITIALIZED6 = 1;
+import path26 from "path";
+var EXIT_OK9 = 0;
+var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_INVALID_ARG2 = 2;
 async function workflow(rootDir, subcommand, args = [], options = {}) {
-  if (!await pathExists11(path24.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists12(path26.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
       console.error("\u2717  mancode not initialized.");
       console.error("   Run `mancode init` to get started.");
     }
-    return EXIT_NOT_INITIALIZED6;
+    return EXIT_NOT_INITIALIZED7;
   }
   switch (subcommand) {
     case "create":
@@ -6900,7 +7708,7 @@ async function workflowReview(rootDir, args, options) {
     if (!ledger)
       return invalidArg(options, `review not initialized: ${taskId}`);
     outputReviewLedger(ledger, options);
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   if (meta.status !== "in_progress" || meta.currentStep < 6) {
     return invalidArg(
@@ -6957,7 +7765,7 @@ async function workflowReview(rootDir, args, options) {
       );
     }
     outputReviewLedger(ledger, options);
-    return EXIT_OK8;
+    return EXIT_OK9;
   } catch (error) {
     return invalidArg(
       options,
@@ -7013,7 +7821,7 @@ async function workflowCreate(rootDir, args, options) {
       error instanceof Error ? error.message : "unable to create workflow"
     );
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowUpdate(rootDir, taskId, options) {
   if (!taskId) {
@@ -7111,18 +7919,18 @@ async function workflowUpdate(rootDir, taskId, options) {
   } else {
     console.log(`Updated workflow: ${taskId}`);
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowList(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
   const views = attachActiveChildren(workflows);
   if (options.json) {
     console.log(JSON.stringify(views, null, 2));
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   if (workflows.length === 0) {
     console.log("No workflows.");
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   const inProgress = workflows.filter((w) => w.status === "in_progress").length;
   console.log(
@@ -7132,7 +7940,7 @@ async function workflowList(rootDir, options) {
   for (const meta of views) {
     console.log(formatWorkflowRow(meta));
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowShow(rootDir, taskId, options) {
   if (!taskId) {
@@ -7169,7 +7977,7 @@ async function workflowShow(rootDir, taskId, options) {
         2
       )
     );
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   console.log(`Workflow:    ${meta.taskId}`);
   console.log(`Task:        ${meta.task}`);
@@ -7196,7 +8004,7 @@ async function workflowShow(rootDir, taskId, options) {
       }
     }
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowClean(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
@@ -7264,7 +8072,7 @@ async function workflowClean(rootDir, options) {
   } else {
     console.log(`Removed ${removed.length} workflow(s).`);
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 function formatWorkflowRow(meta) {
   const stepMax = maxWorkflowStep(meta.mode);
@@ -7323,7 +8131,7 @@ function ago(iso) {
   if (hours < 24) return `${hours}h ago`;
   return `${Math.floor(hours / 24)}d ago`;
 }
-async function pathExists11(p) {
+async function pathExists12(p) {
   try {
     await access6(p);
     return true;
@@ -7336,8 +8144,11 @@ async function pathExists11(p) {
 program.name("mancode").description(
   "AI coding agent harness. Modes: solo, man, mamba, manteam, manps."
 ).version(VERSION);
-program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platform>", "Initial adapter platform (MVP-3)").action(async (options) => {
-  const code = await init(process.cwd(), options);
+program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
+  const code = await init(process.cwd(), {
+    ...options,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  });
   process.exitCode = code;
 });
 program.command("install [platform]").description(
@@ -7383,6 +8194,12 @@ program.command("refresh-style").description("Refresh project profile and rescan
   const code = await refreshStyle(process.cwd());
   process.exitCode = code;
 });
+program.command("refresh-project").description(
+  "Refresh detected project facts after adding Git or project files"
+).action(async () => {
+  const code = await refreshProject(process.cwd());
+  process.exitCode = code;
+});
 program.command("version").description("Show version, node version, and platform").action(() => {
   version();
 });