mancode 0.1.0 → 0.2.0

package/dist/cli.js

@@ -8,11 +8,11 @@ import { program } from "commander";
 
 // src/commands/init.ts
 import { promises as fs2 } from "fs";
-import path11 from "path";
+import path13 from "path";
 import process3 from "process";
 
 // src/installers/claude-code.ts
-import { mkdir as mkdir3, readFile as readFile3, rm, writeFile as writeFile3 } from "fs/promises";
+import { access, mkdir as mkdir3, readFile as readFile2, rm, writeFile as writeFile3 } from "fs/promises";
 import path3 from "path";
 
 // src/templates/agents/scout.ts
@@ -836,6 +836,15 @@ AskUserQuestion({
 \u6536\u5230 \`/man8\` \u6216\u81EA\u52A8\u89E6\u53D1\u540E\u7ACB\u5373\u5F00\u59CB Step 1\uFF0C\u4E0D\u8981\u7B49\u7528\u6237\u786E\u8BA4\u3002`
 };
 
+// src/templates/skills/principles.ts
+var CORE_CODING_PRINCIPLES = `## \u94C1\u5F8B\uFF08\u6C38\u4E0D\u8FDD\u53CD\uFF09
+
+1. **\u4E0D\u505A\u65E0\u5173\u4FEE\u6539** \u2014 \u53EA\u6539 plan \u8303\u56F4\u5185\u7684
+2. **\u5148\u9A8C\u8BC1\u518D\u58F0\u79F0\u5B8C\u6210** \u2014 build/lint/test \u5FC5\u987B\u5B9E\u9645\u8DD1
+3. **\u5931\u8D25\u4E24\u6B21\u5FC5\u987B\u505C\u4E0B** \u2014 \u4E0D\u76F2\u8BD5
+4. **\u4E0D\u53EF\u9006\u64CD\u4F5C\u5148\u95EE** \u2014 \u5220\u9664\u3001force push\u3001worktree \u5408\u5E76
+5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD`;
+
 // src/templates/skills/man.ts
 var MAN_SKILL = {
   name: "man",
@@ -987,13 +996,7 @@ metadata.json\uFF1A\`currentStep: 8\`
 - diff \u5927\u65F6\u53EA\u8D34 hunk \u6458\u8981\uFF0C\u8BA9 agent \u81EA\u5DF1\u7528 Read \u770B\u5B8C\u6574 diff
 - \u4E0D\u8981 dump \u6574\u4E2A\u6E90\u6587\u4EF6\u5230\u5BF9\u8BDD
 
-## \u94C1\u5F8B\uFF08\u6C38\u4E0D\u8FDD\u53CD\uFF09
-
-1. **\u4E0D\u505A\u65E0\u5173\u4FEE\u6539** \u2014 \u53EA\u6539 plan \u8303\u56F4\u5185\u7684
-2. **\u5148\u9A8C\u8BC1\u518D\u58F0\u79F0\u5B8C\u6210** \u2014 build/lint/test \u5FC5\u987B\u5B9E\u9645\u8DD1
-3. **\u5931\u8D25\u4E24\u6B21\u5FC5\u987B\u505C\u4E0B** \u2014 \u4E0D\u76F2\u8BD5
-4. **\u4E0D\u53EF\u9006\u64CD\u4F5C\u5148\u95EE** \u2014 \u5220\u9664\u3001force push\u3001worktree \u5408\u5E76
-5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD
+${CORE_CODING_PRINCIPLES}
 
 \u6536\u5230 \`/man\` \u89E6\u53D1\u540E\u7ACB\u5373\u5F00\u59CB Step 1\u3002`
 };
@@ -1234,7 +1237,6 @@ var MANTEAM_SKILL = {
    - \`.mancode/memory/spec.md\`
    - \`.mancode/memory/decisions.md\`
    - \`.mancode/team/commit-template.txt\`
-   - \`.mancode/team/commit-msg.sh\`\uFF08\u4EC5\u5F53\u56E2\u961F\u542F\u7528 \`mancode install claude-code --commit-hook\`\uFF09
    - \`.github/PULL_REQUEST_TEMPLATE.md\`
 2. \u5982\u679C memory \u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5148\u521B\u5EFA\u4E0A\u8FF0 3 \u4E2A\u6587\u4EF6\uFF0C\u4F7F\u7528\u7B80\u77ED\u6807\u9898\u548C\u7A7A\u6A21\u677F\uFF0C\u4E0D\u8981\u8986\u76D6\u5DF2\u6709\u5185\u5BB9\u3002
 3. \u6536\u96C6\u56E2\u961F\u4E0A\u4E0B\u6587\uFF1A
@@ -1296,16 +1298,16 @@ var MANTEAM_SKILL = {
    - workflow: <taskId>
    - validation: <commands>
    \`\`\`
-4. \u5982\u679C\u56E2\u961F\u9700\u8981\u5F3A\u5236 commit \u89C4\u8303\uFF0C\u63D0\u9192\u53EF\u8FD0\u884C \`mancode install claude-code --commit-hook\` \u5B89\u88C5\u53EF\u9009 Git hook\uFF1B\u4E0D\u8981\u8986\u76D6\u5DF2\u6709\u81EA\u5B9A\u4E49 hook\u3002
+4. \u5982\u679C\u56E2\u961F\u9700\u8981\u5F3A\u5236 commit \u89C4\u8303\uFF0C\u5EFA\u8BAE\u5728\u9879\u76EE\u5C42\u9762\u914D\u7F6E Git hooks\uFF08\u5982 husky \u6216 native git hooks\uFF09\uFF1B\u4E0D\u8981\u8986\u76D6\u5DF2\u6709\u81EA\u5B9A\u4E49 hook\u3002
 5. \u5982\u679C\u7528\u6237\u8981\u5F00 PR\uFF0C\u53C2\u8003 \`.github/PULL_REQUEST_TEMPLATE.md\` \u8F93\u51FA PR \u63CF\u8FF0\u3002
 
-## \u94C1\u5F8B
+${CORE_CODING_PRINCIPLES}
+
+## \u56E2\u961F\u6269\u5C55\u7EAA\u5F8B
 
-1. \u4E0D\u8986\u76D6\u672A\u786E\u8BA4\u7684\u7528\u6237/\u961F\u53CB\u6539\u52A8
-2. \u4E0D\u6539 plan \u5916\u6587\u4EF6
-3. \u5171\u4EAB\u63A5\u53E3\u53D8\u66F4\u5FC5\u987B\u5199\u517C\u5BB9\u6027\u8BF4\u660E
-4. \u5931\u8D25\u4E24\u6B21\u505C\u4E0B\u8BCA\u65AD
-5. \u4E0D\u81EA\u52A8 commit / merge / push
+1. **\u4E0D\u8986\u76D6\u672A\u786E\u8BA4\u7684\u7528\u6237/\u961F\u53CB\u6539\u52A8** \u2014 \u6539\u52A8\u524D\u540E\u90FD\u68C0\u67E5\u5DE5\u4F5C\u533A\u72B6\u6001
+2. **\u5171\u4EAB\u63A5\u53E3\u53D8\u66F4\u5FC5\u987B\u5199\u517C\u5BB9\u6027\u8BF4\u660E** \u2014 \u5305\u542B\u8FC1\u79FB\u3001\u56DE\u6EDA\u548C\u8C03\u7528\u65B9\u5F71\u54CD
+3. **\u4E0D\u81EA\u52A8 commit / merge / push** \u2014 \u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42
 
 \u6536\u5230 \`/manteam\` \u89E6\u53D1\u540E\u7ACB\u5373\u5F00\u59CB Step 0\u3002`
 };
@@ -1329,11 +1331,11 @@ ${spec.body}
 }
 
 // src/installers/common.ts
-import { chmod, mkdir as mkdir2, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
+import { chmod, mkdir as mkdir2, readFile, stat, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
 
 // src/system/team-memory.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { appendFile, mkdir, writeFile } from "fs/promises";
 import path from "path";
 var MEMORY_FILES = {
   prd: {
@@ -1384,9 +1386,9 @@ function memoryDir(projectRoot) {
 }
 async function writeIfMissing(file, content) {
   try {
-    await readFile(file, "utf-8");
-  } catch {
-    await writeFile(file, content, "utf-8");
+    await writeFile(file, content, { flag: "wx" });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
   }
 }
 function renderMemoryFile(title, body) {
@@ -1461,7 +1463,7 @@ async function installMancodeCore(projectRoot) {
 }
 async function readTextIfExists(filePath) {
   try {
-    return await readFile2(filePath, "utf-8");
+    return await readFile(filePath, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") return "";
     throw err;
@@ -1494,18 +1496,19 @@ async function validateClaudeCodeSettings(projectRoot) {
 async function installClaudeCode(projectRoot, options) {
   const claudeDir = path3.join(projectRoot, ".claude");
   const settings = await readClaudeSettings(claudeDir);
+  const force = options.force ?? false;
   await installMancodeCore(projectRoot);
   await mkdir3(path3.join(claudeDir, "skills"), { recursive: true });
   await installSoloSkill(path3.join(claudeDir, "skills"));
   if (options.minimal) {
     await uninstallMvp2Skills(path3.join(claudeDir, "skills"));
   } else {
-    await installMvp2Skills(path3.join(claudeDir, "skills"));
+    await installMvp2Skills(path3.join(claudeDir, "skills"), force);
   }
   if (options.minimal) {
     await uninstallAgents(path3.join(claudeDir, "agents"));
   } else {
-    await installAgents(path3.join(claudeDir, "agents"));
+    await installAgents(path3.join(claudeDir, "agents"), force);
   }
   await updateClaudeSettings(claudeDir, settings);
 }
@@ -1517,9 +1520,9 @@ async function installSoloSkill(skillsDir) {
   });
   await removeLegacyFlatSkill(skillsDir, "mancode-solo");
 }
-async function installMvp2Skills(skillsDir) {
+async function installMvp2Skills(skillsDir, force) {
   for (const skill of MVP2_SKILLS) {
-    await installProjectSkill(skillsDir, skill);
+    await installProjectSkill(skillsDir, skill, force);
     await removeLegacyFlatSkill(skillsDir, `mancode-${skill.name}`);
   }
 }
@@ -1532,19 +1535,35 @@ async function uninstallMvp2Skills(skillsDir) {
     await removeLegacyFlatSkill(skillsDir, `mancode-${skill.name}`);
   }
 }
-async function installProjectSkill(skillsDir, skill) {
+async function installProjectSkill(skillsDir, skill, force = true) {
   const skillDir = path3.join(skillsDir, skill.name);
+  const skillPath = path3.join(skillDir, "SKILL.md");
+  if (!force) {
+    try {
+      await access(skillPath);
+      return;
+    } catch {
+    }
+  }
   await mkdir3(skillDir, { recursive: true });
-  await writeFile3(path3.join(skillDir, "SKILL.md"), renderSkill(skill), "utf-8");
+  await writeFile3(skillPath, renderSkill(skill), "utf-8");
 }
 async function removeLegacyFlatSkill(skillsDir, legacyName) {
   await rm(path3.join(skillsDir, `${legacyName}.md`), { force: true });
 }
-async function installAgents(agentsDir) {
+async function installAgents(agentsDir, force) {
   await mkdir3(agentsDir, { recursive: true });
   for (const agent of ALL_AGENTS) {
+    const agentPath = path3.join(agentsDir, `${agent.name}.md`);
+    if (!force) {
+      try {
+        await access(agentPath);
+        continue;
+      } catch {
+      }
+    }
     const content = renderAgent(agent);
-    await writeFile3(path3.join(agentsDir, `${agent.name}.md`), content, "utf-8");
+    await writeFile3(agentPath, content, "utf-8");
   }
 }
 async function uninstallAgents(agentsDir) {
@@ -1555,7 +1574,7 @@ async function uninstallAgents(agentsDir) {
 async function readClaudeSettings(claudeDir) {
   const settingsPath = path3.join(claudeDir, "settings.json");
   try {
-    const raw = await readFile3(settingsPath, "utf-8");
+    const raw = await readFile2(settingsPath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     if (isNodeError2(err) && err.code === "ENOENT") {
@@ -1610,19 +1629,20 @@ function createCommandGroup(command) {
 }
 function normalizeHookGroups(value) {
   if (Array.isArray(value)) {
-    return value.flatMap((entry) => {
-      const group = normalizeMatcherGroup(entry);
-      if (group) return [group];
-      const hook = normalizeHookItem(entry);
-      if (hook && !isMancodeHook(hook)) return [{ hooks: [hook] }];
-      return [];
-    });
+    return value.flatMap(normalizeHookGroupEntry);
   }
   if (isRecord(value)) {
-    return Object.values(value).flatMap((entry) => {
-      const group = normalizeMatcherGroup(entry);
-      return group ? [group] : [];
-    });
+    return Object.values(value).flatMap(normalizeHookGroupEntry);
+  }
+  return [];
+}
+function normalizeHookGroupEntry(entry) {
+  const group = normalizeMatcherGroup(entry);
+  if (group) return [group];
+  const hook = normalizeHookItem(entry);
+  if (hook && !isMancodeHook(hook)) return [{ hooks: [hook] }];
+  if (Array.isArray(entry)) {
+    return entry.flatMap(normalizeHookGroupEntry);
   }
   return [];
 }
@@ -1660,8 +1680,8 @@ function isNodeError2(err) {
 }
 
 // src/installers/codex.ts
-import { writeFile as writeFile4 } from "fs/promises";
-import path5 from "path";
+import { writeFile as writeFile5 } from "fs/promises";
+import path6 from "path";
 
 // src/installers/managed-block.ts
 var DEFAULT_MANCODE_START_MARKER = "<!-- mancode:start -->";
@@ -1677,6 +1697,11 @@ function removeManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER
   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 || "";
@@ -1748,16 +1773,322 @@ function findMarkerLine(content, marker) {
   return null;
 }
 
+// src/installers/mode-skills.ts
+import { mkdir as mkdir4, readFile as readFile3, readdir, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import path4 from "path";
+var MODE_NAMES = [
+  "man8",
+  "man",
+  "manteam",
+  "manps",
+  "mansolo"
+];
+var CODEX_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:codex-skill. Do not edit this file manually. -->";
+var ZCODE_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:zcode-skill. Do not edit this file manually. -->";
+function renderModeSkill(mode, commandPrefix = "$") {
+  const meta = MODE_META[mode];
+  const stateMode = mode === "mansolo" ? "solo" : mode;
+  const modesList = MODE_NAMES.map((m) => `${commandPrefix}${m}`).join(", ");
+  return [
+    meta.intro,
+    "",
+    "## Mode Persistence",
+    "",
+    "Continue following these instructions for ALL subsequent tasks in this",
+    `conversation until the user switches modes (${modesList}).`,
+    "",
+    "When entering this mode, update `.mancode/state.json` and set",
+    `"currentMode" to "${stateMode}" so the mode persists across session restarts.`,
+    "If unsure whether a mode is active, read `.mancode/state.json` to verify.",
+    "",
+    "## Practice",
+    "",
+    "Before writing new code, check the YAGNI ladder:",
+    "",
+    "1. Reuse existing project code.",
+    "2. Use the standard library.",
+    "3. Use platform-native behavior.",
+    "4. Use already installed dependencies.",
+    "5. Prefer a one-line fix when it is enough.",
+    "6. Only then write the smallest new implementation.",
+    "",
+    "For every task, consider: why this change, what already exists, and what",
+    "is the smallest useful diff?",
+    "",
+    "For UI tasks, read `.mancode/aesthetics/style-tokens.json` for current",
+    "design tokens before inventing new styles.",
+    "",
+    meta.workflow
+  ].join("\n");
+}
+async function installCodexSkills(projectRoot, minimal) {
+  if (minimal) {
+    await removeCodexSkills(projectRoot);
+    return;
+  }
+  const skillsDir = path4.join(projectRoot, ".codex", "skills");
+  for (const mode of MODE_NAMES) {
+    const modeDir = path4.join(skillsDir, mode);
+    await mkdir4(modeDir, { recursive: true });
+    const meta = MODE_META[mode];
+    const content = [
+      "---",
+      `name: ${mode}`,
+      `description: ${JSON.stringify(meta.description)}`,
+      "---",
+      "",
+      CODEX_SKILL_MANAGED_MARKER,
+      "",
+      renderModeSkill(mode, "$"),
+      ""
+    ].join("\n");
+    await writeManagedSkill(
+      path4.join(modeDir, "SKILL.md"),
+      content,
+      CODEX_SKILL_MANAGED_MARKER,
+      "Codex"
+    );
+  }
+}
+async function installZcodeSkills(projectRoot, minimal) {
+  if (minimal) {
+    await removeZcodeSkills(projectRoot);
+    return;
+  }
+  const skillsDir = path4.join(projectRoot, ".zcode", "skills");
+  for (const mode of MODE_NAMES) {
+    const modeDir = path4.join(skillsDir, mode);
+    await mkdir4(modeDir, { recursive: true });
+    const meta = MODE_META[mode];
+    const content = [
+      "---",
+      `name: ${mode}`,
+      `description: ${JSON.stringify(meta.description)}`,
+      "---",
+      "",
+      ZCODE_SKILL_MANAGED_MARKER,
+      "",
+      renderModeSkill(mode, "$"),
+      ""
+    ].join("\n");
+    await writeManagedSkill(
+      path4.join(modeDir, "SKILL.md"),
+      content,
+      ZCODE_SKILL_MANAGED_MARKER,
+      "ZCode"
+    );
+  }
+}
+async function installCursorCommands(projectRoot, minimal) {
+  if (minimal) {
+    await removeCursorCommands(projectRoot);
+    return;
+  }
+  const commandsDir = path4.join(projectRoot, ".cursor", "commands");
+  await mkdir4(commandsDir, { recursive: true });
+  for (const mode of MODE_NAMES) {
+    const meta = MODE_META[mode];
+    const content = [
+      "---",
+      `description: ${JSON.stringify(meta.description)}`,
+      "---",
+      "",
+      renderModeSkill(mode, "/"),
+      ""
+    ].join("\n");
+    await writeFile4(path4.join(commandsDir, `${mode}.md`), content, "utf-8");
+  }
+}
+async function installCopilotPrompts(projectRoot, minimal) {
+  if (minimal) {
+    await removeCopilotPrompts(projectRoot);
+    return;
+  }
+  const promptsDir = path4.join(projectRoot, ".github", "prompts");
+  await mkdir4(promptsDir, { recursive: true });
+  for (const mode of MODE_NAMES) {
+    const meta = MODE_META[mode];
+    const content = [
+      "---",
+      "agent: 'agent'",
+      `description: ${JSON.stringify(meta.description)}`,
+      "---",
+      "",
+      renderModeSkill(mode, ""),
+      ""
+    ].join("\n");
+    await writeFile4(
+      path4.join(promptsDir, `${mode}.prompt.md`),
+      content,
+      "utf-8"
+    );
+  }
+}
+async function removeCodexSkills(projectRoot) {
+  const skillsDir = path4.join(projectRoot, ".codex", "skills");
+  for (const mode of MODE_NAMES) {
+    const modeDir = path4.join(skillsDir, mode);
+    const skillPath = path4.join(modeDir, "SKILL.md");
+    if (await isManagedSkillFile(skillPath, CODEX_SKILL_MANAGED_MARKER)) {
+      await rm2(skillPath, { force: true });
+      await removeIfEmpty(modeDir);
+    }
+  }
+  await removeIfEmpty(skillsDir);
+}
+async function removeZcodeSkills(projectRoot) {
+  const skillsDir = path4.join(projectRoot, ".zcode", "skills");
+  for (const mode of MODE_NAMES) {
+    const modeDir = path4.join(skillsDir, mode);
+    const skillPath = path4.join(modeDir, "SKILL.md");
+    if (await isManagedSkillFile(skillPath, ZCODE_SKILL_MANAGED_MARKER)) {
+      await rm2(skillPath, { force: true });
+      await removeIfEmpty(modeDir);
+    }
+  }
+  await removeIfEmpty(skillsDir);
+}
+async function removeCursorCommands(projectRoot) {
+  for (const mode of MODE_NAMES) {
+    await rm2(path4.join(projectRoot, ".cursor", "commands", `${mode}.md`), {
+      force: true
+    });
+  }
+}
+async function removeCopilotPrompts(projectRoot) {
+  for (const mode of MODE_NAMES) {
+    await rm2(
+      path4.join(projectRoot, ".github", "prompts", `${mode}.prompt.md`),
+      { force: true }
+    );
+  }
+}
+async function removeIfEmpty(dir) {
+  try {
+    const entries = await readdir(dir);
+    if (entries.length === 0) {
+      await rm2(dir, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+async function writeManagedSkill(skillPath, content, marker, platformLabel) {
+  const existing = await readTextIfExists2(skillPath);
+  if (existing !== null && !existing.includes(marker)) {
+    throw new Error(
+      `refusing to overwrite user-authored ${platformLabel} skill: ${skillPath}`
+    );
+  }
+  await writeFile4(skillPath, content, "utf-8");
+}
+async function isManagedSkillFile(skillPath, marker) {
+  const content = await readTextIfExists2(skillPath);
+  return content?.includes(marker) ?? false;
+}
+async function readTextIfExists2(filePath) {
+  try {
+    return await readFile3(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var MODE_META = {
+  man8: {
+    description: "Investigate first, then produce a plan before implementation. Use when the user asks for man8, planning, architecture, migration, integration, or risk assessment.",
+    intro: "# mancode man8 \u2014 Investigate and Plan",
+    workflow: [
+      "## Workflow (simulate in single conversation)",
+      "",
+      "This platform does not provide isolated subagents. Simulate the coaching",
+      "staff in sequence:",
+      "",
+      "1. **Scout**: Investigate the relevant code and summarize constraints,",
+      "   existing patterns, and dependencies.",
+      "2. **Head Coach**: Write a concrete implementation plan based on the",
+      "   Scout findings.",
+      "3. **Stop for user approval** before implementing. Do not write code",
+      "   until the user confirms.",
+      "",
+      "After user approval, switch to solo mode (update state.json currentMode",
+      'to "solo") and implement the plan.'
+    ].join("\n")
+  },
+  man: {
+    description: "Full high-risk workflow with plan, implementation, verification, and review. Use when the user asks for man or a high-risk production change.",
+    intro: "# mancode man \u2014 Full Review Workflow",
+    workflow: [
+      "## Workflow (simulate in single conversation)",
+      "",
+      "This platform does not provide isolated subagents. Simulate the full",
+      "coaching staff workflow in sequence:",
+      "",
+      "1. **Scout**: Investigate the codebase and summarize constraints.",
+      "2. **Head Coach**: Propose a concrete implementation plan.",
+      "3. **Wait for approval** when the task is high-risk.",
+      "4. **Implement** the plan and self-test.",
+      "5. **Film Analyst Offense**: Review readability, DRY, and YAGNI.",
+      "6. **Fix** review findings.",
+      "7. **Film Analyst Defense**: Review auth, injection, concurrency, and",
+      "   resource risks.",
+      "8. **Summarize** verification results and remaining risk."
+    ].join("\n")
+  },
+  manteam: {
+    description: "Team-aware workflow with handoff-friendly summaries. Use when the user asks for manteam or when the task affects shared team context.",
+    intro: "# mancode manteam \u2014 Team Workflow",
+    workflow: [
+      "## Workflow",
+      "",
+      "1. Read `.mancode/memory/prd.md`, `.mancode/memory/spec.md`, and",
+      "   `.mancode/memory/decisions.md` when relevant.",
+      "2. Preserve decisions and leave handoff-friendly summaries.",
+      "3. Prefer Conventional Commit style when suggesting commits.",
+      "4. Simulate the coaching staff in sequence (same as man mode) but",
+      "   with extra emphasis on documentation and handoff clarity."
+    ].join("\n")
+  },
+  manps: {
+    description: "Run project health and cleanup scans before remediation. Use when the user asks for manps or project health cleanup.",
+    intro: "# mancode manps \u2014 Project Health Scan",
+    workflow: [
+      "## Workflow",
+      "",
+      "1. Run `mancode manps [area]` to scan for tech debt, unused dependencies,",
+      "   security issues, dead code, and config drift.",
+      "2. Supported areas: all, deps, security, dead-code, config.",
+      "3. Treat scan output as triage data \u2014 do not remediate without clear",
+      "   user approval for each item.",
+      "4. Present findings as a prioritized list with severity and recommendation."
+    ].join("\n")
+  },
+  mansolo: {
+    description: "Exit any active mancode mode and return to default solo behavior.",
+    intro: "# mancode mansolo \u2014 Return to Solo",
+    workflow: [
+      "## Solo Behavior",
+      "",
+      "You are now in solo (default) mode.",
+      "",
+      'Update `.mancode/state.json` and set `currentMode` to "solo".',
+      "",
+      "- Keep the diff narrow.",
+      "- Reuse existing functions, components, styles, and dependencies.",
+      "- For UI work, read `.mancode/aesthetics/style-tokens.json`.",
+      "- Verify with the narrowest meaningful test, lint, build, or smoke check."
+    ].join("\n")
+  }
+};
+
 // src/installers/shared-content.ts
 import { readFile as readFile4 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 async function generateSharedContent(projectRoot, options) {
   const [state, tokens] = await Promise.all([
     readJson(
-      path4.join(projectRoot, ".mancode", "state.json")
+      path5.join(projectRoot, ".mancode", "state.json")
     ),
     readJson(
-      path4.join(projectRoot, ".mancode", "aesthetics", "style-tokens.json")
+      path5.join(projectRoot, ".mancode", "aesthetics", "style-tokens.json")
     )
   ]);
   const sections = [
@@ -1833,7 +2164,14 @@ function renderAesthetics(tokens) {
   return lines.join("\n");
 }
 function renderModes(options) {
-  const commandLabel = options.capabilities.slashCommands === "native" ? "Use the named commands directly when available." : "Treat these as prompt conventions when native commands are unavailable.";
+  let commandLabel;
+  if (options.capabilities.skills === "agents-skills") {
+    commandLabel = "Invoke mode skills with `$man8`, `$man`, `$manteam`, `$manps`, `$mansolo`.";
+  } else if (options.capabilities.slashCommands === "native") {
+    commandLabel = "Use the named commands directly when available.";
+  } else {
+    commandLabel = "Treat these as prompt conventions when native commands are unavailable.";
+  }
   return [
     "## mancode Modes",
     "",
@@ -1897,7 +2235,7 @@ function formatValue(value) {
 // src/installers/codex.ts
 async function installCodex(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path5.join(projectRoot, "AGENTS.md");
+  const agentsPath = path6.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "codex",
@@ -1906,7 +2244,7 @@ async function installCodex(projectRoot, options) {
       slashCommands: "partial",
       subagents: false,
       hooks: false,
-      skills: "single-file"
+      skills: "agents-skills"
     },
     minimal: options.minimal,
     techStack: options.techStack,
@@ -1921,17 +2259,18 @@ async function installCodex(projectRoot, options) {
     sharedContent.trim(),
     DEFAULT_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile4(agentsPath, replaceManagedBlock(existing, block), "utf-8");
+  await writeFile5(agentsPath, replaceManagedBlock(existing, block), "utf-8");
+  await installCodexSkills(projectRoot, options.minimal ?? false);
 }
 
 // src/installers/copilot.ts
-import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import path6 from "path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import path7 from "path";
 async function installCopilot(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const githubDir = path6.join(projectRoot, ".github");
-  await mkdir4(githubDir, { recursive: true });
-  const instructionsPath = path6.join(githubDir, "copilot-instructions.md");
+  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",
@@ -1958,11 +2297,12 @@ async function installCopilot(projectRoot, options) {
     sections.push("", renderCopilotPromptConventions());
   }
   sections.push(DEFAULT_MANCODE_END_MARKER);
-  await writeFile5(
+  await writeFile6(
     instructionsPath,
     replaceManagedBlock(existing, sections.join("\n")),
     "utf-8"
   );
+  await installCopilotPrompts(projectRoot, options.minimal ?? false);
 }
 function renderCopilotPromptConventions() {
   return [
@@ -1973,13 +2313,16 @@ function renderCopilotPromptConventions() {
     "- man8: investigate first and produce a plan before implementation.",
     "- man: use a careful plan, implementation, verification, and review loop.",
     "- manteam: read team memory and write handoff-friendly summaries.",
-    "- manps: prefer `mancode manps [area]` before cleanup."
+    "- 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 mkdir5, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir6, 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",
@@ -1997,8 +2340,8 @@ var MANCODE_CURSOR_RULE_FILES = [
 ];
 async function installCursor(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const rulesDir = path7.join(projectRoot, ".cursor", "rules");
-  await mkdir5(rulesDir, { recursive: true });
+  const rulesDir = path8.join(projectRoot, ".cursor", "rules");
+  await mkdir6(rulesDir, { recursive: true });
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "cursor",
     displayName: "Cursor",
@@ -2037,6 +2380,7 @@ async function installCursor(projectRoot, options) {
   );
   if (options.minimal) {
     await removeAdvancedRules(rulesDir);
+    await installCursorCommands(projectRoot, true);
     return;
   }
   await writeRule(
@@ -2067,6 +2411,7 @@ async function installCursor(projectRoot, options) {
     false,
     renderManpsRule()
   );
+  await installCursorCommands(projectRoot, options.minimal ?? false);
 }
 async function writeRule(rulesDir, fileName, description, alwaysApply, body) {
   const frontmatter = [
@@ -2082,11 +2427,11 @@ async function writeRule(rulesDir, fileName, description, alwaysApply, body) {
 
 ${body.trim()}
 `;
-  await writeFile6(path7.join(rulesDir, fileName), content, "utf-8");
+  await writeFile7(path8.join(rulesDir, fileName), content, "utf-8");
 }
 async function removeAdvancedRules(rulesDir) {
   for (const fileName of MANCODE_CURSOR_ADVANCED_RULE_FILES) {
-    await rm2(path7.join(rulesDir, fileName), { force: true });
+    await rm3(path8.join(rulesDir, fileName), { force: true });
   }
 }
 function renderPracticeRule() {
@@ -2118,57 +2463,60 @@ function renderSoloRule() {
   ].join("\n");
 }
 function renderMan8Rule() {
-  return [
-    "# mancode man8",
-    "",
-    "Use this when the user asks for /man8, planning, investigation, architecture, migration, integration, or risk assessment.",
-    "",
-    "Cursor does not provide isolated mancode subagents. Simulate the flow in sequence:",
-    "",
-    "1. Scout: inspect the relevant code and summarize constraints.",
-    "2. Head Coach: write a concrete implementation plan.",
-    "3. Stop for user approval when the user asked for planning only."
-  ].join("\n");
+  return renderModeSkill("man8", "/");
 }
 function renderManRule() {
-  return [
-    "# mancode man",
-    "",
-    "Use this when the user asks for /man or a high-risk production change.",
-    "",
-    "Simulate the full workflow in one conversation:",
-    "",
-    "1. Scout investigates the codebase.",
-    "2. Head Coach proposes the plan.",
-    "3. Wait for approval when required.",
-    "4. Implement and self-test.",
-    "5. Film Analyst Offense reviews readability, DRY, and YAGNI.",
-    "6. Fix review findings.",
-    "7. Film Analyst Defense reviews auth, injection, concurrency, and resource risks.",
-    "8. Summarize verification and remaining risk."
-  ].join("\n");
+  return renderModeSkill("man", "/");
 }
 function renderManteamRule() {
-  return [
-    "# mancode manteam",
-    "",
-    "Use this when the user asks for /manteam or when the task affects shared team context.",
-    "",
-    "- Read `.mancode/memory/prd.md`, `.mancode/memory/spec.md`, and `.mancode/memory/decisions.md` when relevant.",
-    "- Preserve decisions and leave handoff-friendly summaries.",
-    "- Prefer Conventional Commit style when suggesting commits."
-  ].join("\n");
+  return renderModeSkill("manteam", "/");
 }
 function renderManpsRule() {
-  return [
-    "# mancode manps",
+  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
+  });
+  const block = [
+    ZCODE_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
     "",
-    "Use this when the user asks for /manps or project health cleanup.",
+    "# mancode Configuration",
     "",
-    "- Prefer `mancode manps [area]` before manual cleanup.",
-    "- Supported areas: all, deps, security, dead-code, config.",
-    "- Treat scan output as triage data; do not remediate without clear user approval."
+    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
@@ -2202,7 +2550,7 @@ var PLATFORM_INSTALLERS = {
       slashCommands: "partial",
       subagents: false,
       hooks: false,
-      skills: "single-file"
+      skills: "agents-skills"
     },
     install: installCodex
   },
@@ -2216,6 +2564,17 @@ var PLATFORM_INSTALLERS = {
       skills: "instructions"
     },
     install: installCopilot
+  },
+  zcode: {
+    name: "zcode",
+    displayName: "ZCode",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    install: installZcode
   }
 };
 function getPlatformInstaller(platform) {
@@ -2234,7 +2593,7 @@ function isPlatformName(platform) {
 
 // src/system/detect-team.ts
 import { exec } from "child_process";
-import path8 from "path";
+import path10 from "path";
 import process2 from "process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -2256,7 +2615,7 @@ var EXEC_OPTS = {
   }
 };
 async function detectTeamStatus(projectRoot) {
-  const gitDir = path8.join(projectRoot, ".git");
+  const gitDir = path10.join(projectRoot, ".git");
   try {
     await execAsync("git rev-parse --is-inside-work-tree", {
       cwd: projectRoot,
@@ -2318,8 +2677,8 @@ async function checkRemote(cwd) {
 
 // src/system/detect.ts
 import { exec as exec2 } from "child_process";
-import { access, readFile as readFile5 } from "fs/promises";
-import path9 from "path";
+import { access as access2, readFile as readFile5 } from "fs/promises";
+import path11 from "path";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
 async function detectSystemDeps() {
@@ -2344,9 +2703,9 @@ async function detectSystemDeps() {
   return { bash, git, jq, node };
 }
 async function detectProjectType(projectRoot) {
-  const pkgPath = path9.join(projectRoot, "package.json");
+  const pkgPath = path11.join(projectRoot, "package.json");
   try {
-    await access(pkgPath);
+    await access2(pkgPath);
   } catch (err) {
     if (err.code === "ENOENT") {
       return {
@@ -2378,7 +2737,7 @@ async function detectProjectType(projectRoot) {
   if (deps.includes("tailwindcss")) techStack.push("Tailwind CSS");
   let uiLibrary = null;
   const hasRadix = deps.some((d) => d.startsWith("@radix-ui/"));
-  const uiDir = path9.join(projectRoot, "src", "components", "ui");
+  const uiDir = path11.join(projectRoot, "src", "components", "ui");
   const hasUiDir = await pathExists2(uiDir);
   if (hasRadix && hasUiDir) {
     uiLibrary = "shadcn/ui";
@@ -2393,7 +2752,7 @@ async function detectProjectType(projectRoot) {
 }
 async function pathExists2(p) {
   try {
-    await access(p);
+    await access2(p);
     return true;
   } catch {
     return false;
@@ -2402,7 +2761,7 @@ async function pathExists2(p) {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs } from "fs";
-import path10 from "path";
+import path12 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null) {
@@ -2462,7 +2821,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path10.join(projectRoot, name);
+    const absPath = path12.join(projectRoot, name);
     if (await pathExists3(absPath)) {
       return { absPath, relPath: name };
     }
@@ -2682,7 +3041,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path10.join(projectRoot, relRoot);
+    const absRoot = path12.join(projectRoot, relRoot);
     if (!await pathExists3(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -2702,7 +3061,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path10.join(dir, entry);
+    const abs = path12.join(dir, entry);
     let info;
     try {
       info = await fs.lstat(abs);
@@ -2719,7 +3078,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
     if (isNonComponentFile(entry)) continue;
     let base = entry.replace(/\.(tsx|jsx|ts|js|vue|svelte)$/, "");
     if (base === "index") {
-      base = path10.basename(dir);
+      base = path12.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -2741,7 +3100,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path10.join(projectRoot, relPath);
+    const absPath = path12.join(projectRoot, relPath);
     if (!await pathExists3(absPath)) continue;
     const content = await fs.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -2787,7 +3146,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs.readFile(
-      path10.join(projectRoot, "package.json"),
+      path12.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -2817,8 +3176,8 @@ var EXIT_NOT_A_PROJECT_DIR = 2;
 var EXIT_INIT_FAILED = 5;
 var DEFAULT_INIT_PLATFORM = "claude-code";
 async function init(rootDir = process3.cwd(), options = {}) {
-  const mancodeDir = path11.join(rootDir, ".mancode");
-  const stateFile = path11.join(mancodeDir, "state.json");
+  const mancodeDir = path13.join(rootDir, ".mancode");
+  const stateFile = path13.join(mancodeDir, "state.json");
   const wasInitialized = await pathExists4(stateFile);
   if (wasInitialized) {
     if (!options.force) {
@@ -2833,8 +3192,8 @@ async function init(rootDir = process3.cwd(), options = {}) {
     console.error(`\u2717  Target directory does not exist: ${rootDir}`);
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  const isGitRepo = await pathExists4(path11.join(rootDir, ".git"));
-  const hasPackageJson = await pathExists4(path11.join(rootDir, "package.json"));
+  const isGitRepo = await pathExists4(path13.join(rootDir, ".git"));
+  const hasPackageJson = await pathExists4(path13.join(rootDir, "package.json"));
   if (!isGitRepo && !hasPackageJson) {
     console.error(`\u2717  Not a project directory: ${rootDir}`);
     console.error("   (No .git or package.json found)");
@@ -2918,13 +3277,16 @@ async function init(rootDir = process3.cwd(), options = {}) {
     await updateConfigOptions(mancodeDir, {
       forceTeamMode: options.team === true,
       defaultStyle: options.style ?? null,
-      platforms: [installer.name]
+      platforms: [installer.name],
+      platformOptions: {
+        [installer.name]: { minimal: false }
+      }
     });
     let styleLine = "  .mancode/aesthetics/        # style-tokens.json (\u7A7A)";
     if (project.hasFrontend) {
       console.log("\u2713  \u626B\u63CF\u5BA1\u7F8E token...");
       const tokens = await scanAesthetics(rootDir, project.uiLibrary);
-      const tokensPath = path11.join(
+      const tokensPath = path13.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -2984,7 +3346,7 @@ async function init(rootDir = process3.cwd(), options = {}) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch) {
-  const configPath = path11.join(mancodeDir, "config.json");
+  const configPath = path13.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs2.readFile(configPath, "utf-8"));
@@ -3009,6 +3371,12 @@ function printPlatformCreatedFiles(platform) {
   }
   if (platform === "codex") {
     console.log("  AGENTS.md                   # Codex managed block");
+    console.log("  .codex/skills/              # Codex mode skills");
+    return;
+  }
+  if (platform === "zcode") {
+    console.log("  AGENTS.md                   # ZCode managed block");
+    console.log("  .zcode/skills/              # ZCode mode skills");
     return;
   }
   console.log("  .github/copilot-instructions.md # Copilot instructions");
@@ -3024,17 +3392,17 @@ async function pathExists4(p) {
 
 // src/commands/install.ts
 import { promises as fs4 } from "fs";
-import path13 from "path";
+import path15 from "path";
 import process4 from "process";
 
 // src/installers/platform-status.ts
 import { promises as fs3 } from "fs";
-import path12 from "path";
+import path14 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
     installed,
-    ready: installed && readiness.present,
+    ready: installed && readiness.ready,
     target: readiness.target,
     detail: describeStatus(installed, readiness)
   };
@@ -3042,11 +3410,13 @@ async function checkPlatformStatus(rootDir, platform, installed) {
 async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const hasSoloSkill = await pathExists5(
-      path12.join(rootDir, ".claude", "skills", "solo", "SKILL.md")
+      path14.join(rootDir, ".claude", "skills", "solo", "SKILL.md")
     );
     const registered = await claudeHooksRegistered(rootDir);
+    const present = hasSoloSkill && registered;
     return {
-      present: hasSoloSkill && registered,
+      present,
+      ready: present,
       target: ".claude/",
       readyDetail: "skills and hooks registered"
     };
@@ -3054,26 +3424,104 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const present = await allPathsExist(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path12.join(rootDir, ".cursor", "rules", file)
+        (file) => path14.join(rootDir, ".cursor", "rules", file)
       )
     );
     return {
       present,
+      ready: present,
       target: ".cursor/rules/",
       readyDetail: "mancode rules present"
     };
   }
   if (platform === "codex") {
+    const hasBlock2 = await fileHasManagedBlock(path14.join(rootDir, "AGENTS.md"));
+    if (!hasBlock2) {
+      return {
+        present: false,
+        ready: false,
+        target: "AGENTS.md",
+        readyDetail: "managed block missing"
+      };
+    }
+    if (await isPlatformMinimal(rootDir, "codex")) {
+      return {
+        present: true,
+        ready: true,
+        target: "AGENTS.md",
+        readyDetail: "managed block present"
+      };
+    }
+    const skillsDir = path14.join(rootDir, ".codex", "skills");
+    const hasSkills = await allManagedSkills(
+      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      CODEX_SKILL_MANAGED_MARKER
+    );
     return {
-      present: await fileHasManagedBlock(path12.join(rootDir, "AGENTS.md")),
-      target: "AGENTS.md",
-      readyDetail: "managed block present"
+      present: true,
+      ready: hasSkills,
+      target: "AGENTS.md + .codex/skills/",
+      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
+    };
+  }
+  if (platform === "zcode") {
+    const hasBlock2 = await fileHasManagedBlock(
+      path14.join(rootDir, "AGENTS.md"),
+      ZCODE_MANCODE_START_MARKER,
+      ZCODE_MANCODE_END_MARKER
+    );
+    if (!hasBlock2) {
+      return {
+        present: false,
+        ready: false,
+        target: "AGENTS.md",
+        readyDetail: "managed block missing"
+      };
+    }
+    if (await isPlatformMinimal(rootDir, "zcode")) {
+      return {
+        present: true,
+        ready: true,
+        target: "AGENTS.md",
+        readyDetail: "managed block present"
+      };
+    }
+    const skillsDir = path14.join(rootDir, ".zcode", "skills");
+    const hasSkills = await allManagedSkills(
+      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      ZCODE_SKILL_MANAGED_MARKER
+    );
+    return {
+      present: true,
+      ready: hasSkills,
+      target: "AGENTS.md + .zcode/skills/",
+      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
+    };
+  }
+  const hasBlock = await fileHasManagedBlock(
+    path14.join(rootDir, ".github", "copilot-instructions.md")
+  );
+  if (!hasBlock) {
+    return {
+      present: false,
+      ready: false,
+      target: ".github/copilot-instructions.md",
+      readyDetail: "managed block missing"
+    };
+  }
+  const promptsDir = path14.join(rootDir, ".github", "prompts");
+  if (await pathExists5(promptsDir)) {
+    const hasPrompt = await pathExists5(path14.join(promptsDir, "man8.prompt.md"));
+    return {
+      present: hasPrompt,
+      ready: hasPrompt,
+      target: ".github/copilot-instructions.md + .github/prompts/",
+      readyDetail: hasPrompt ? "managed block and prompts present" : "prompts directory exists but man8 prompt missing"
     };
   }
   return {
-    present: await fileHasManagedBlock(
-      path12.join(rootDir, ".github", "copilot-instructions.md")
-    ),
+    present: true,
+    ready: true,
     target: ".github/copilot-instructions.md",
     readyDetail: "managed block present"
   };
@@ -3089,10 +3537,38 @@ async function allPathsExist(paths) {
   const results = await Promise.all(paths.map(pathExists5));
   return results.every(Boolean);
 }
-async function fileHasManagedBlock(filePath) {
+async function allManagedSkills(paths, marker) {
+  const results = await Promise.all(
+    paths.map((filePath) => fileHasText(filePath, marker))
+  );
+  return results.every(Boolean);
+}
+async function fileHasText(filePath, needle) {
   try {
     const content = await fs3.readFile(filePath, "utf-8");
-    return content.includes(DEFAULT_MANCODE_START_MARKER) && content.includes(DEFAULT_MANCODE_END_MARKER);
+    return content.includes(needle);
+  } catch {
+    return false;
+  }
+}
+async function isPlatformMinimal(rootDir, platform) {
+  try {
+    const raw = await fs3.readFile(
+      path14.join(rootDir, ".mancode", "config.json"),
+      "utf-8"
+    );
+    const config = JSON.parse(raw);
+    if (!isRecord2(config.platformOptions)) return false;
+    const options = config.platformOptions[platform];
+    return isRecord2(options) && options.minimal === true;
+  } catch {
+    return false;
+  }
+}
+async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  try {
+    const content = await fs3.readFile(filePath, "utf-8");
+    return hasManagedBlock(content, startMarker, endMarker);
   } catch {
     return false;
   }
@@ -3100,7 +3576,7 @@ async function fileHasManagedBlock(filePath) {
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs3.readFile(
-      path12.join(rootDir, ".claude", "settings.json"),
+      path14.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -3146,7 +3622,7 @@ var EXIT_NOT_INITIALIZED = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
 async function install(rootDir = process4.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path13.join(rootDir, ".mancode", "state.json");
+  const stateFile = path15.join(rootDir, ".mancode", "state.json");
   if (!await pathExists6(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
@@ -3177,15 +3653,22 @@ async function install(rootDir = process4.cwd(), platform = "claude-code", optio
   if (alreadyInstalled && !options.force) {
     const status2 = await checkPlatformStatus(rootDir, platform, true);
     if (status2.ready) {
+      if (!options.minimal) {
+        console.log(
+          `\u2139\uFE0F  ${formatPlatformName(platform)} adapter already installed.`
+        );
+        console.log("   Run with --force to reinstall.");
+        return EXIT_OK2;
+      }
+      console.log(
+        `\u2139\uFE0F  ${formatPlatformName(platform)} adapter already installed; switching to minimal install.`
+      );
+      console.log("   Run with --force to fully reinstall.");
+    } else {
       console.log(
-        `\u2139\uFE0F  ${formatPlatformName(platform)} adapter already installed.`
+        `\u2139\uFE0F  ${formatPlatformName(platform)} is recorded in config but not ready; repairing generated files.`
       );
-      console.log("   Run with --force to reinstall.");
-      return EXIT_OK2;
     }
-    console.log(
-      `\u2139\uFE0F  ${formatPlatformName(platform)} is recorded in config but not ready; repairing generated files.`
-    );
   }
   console.log(`\u2713  Installing ${formatPlatformName(platform)} adapter...`);
   const project = await detectProjectType(rootDir);
@@ -3193,7 +3676,8 @@ async function install(rootDir = process4.cwd(), platform = "claude-code", optio
     await installer.install(rootDir, {
       techStack: project.techStack,
       uiLibrary: project.uiLibrary,
-      minimal: options.minimal
+      minimal: options.minimal,
+      force: options.force
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -3206,12 +3690,20 @@ async function install(rootDir = process4.cwd(), platform = "claude-code", optio
   if (!platforms.includes(platform)) {
     platforms.push(platform);
   }
-  await updateConfig(rootDir, { ...config, platforms });
+  await updateConfig(rootDir, {
+    ...config,
+    platforms,
+    platformOptions: updatePlatformOptions(
+      config.platformOptions,
+      platform,
+      options
+    )
+  });
   console.log(`\u2713  ${formatPlatformName(platform)} adapter installed.`);
   return EXIT_OK2;
 }
 async function readConfig(rootDir) {
-  const configPath = path13.join(rootDir, ".mancode", "config.json");
+  const configPath = path15.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs4.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
@@ -3226,7 +3718,7 @@ function isNodeError3(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path13.join(rootDir, ".mancode", "config.json");
+  const configPath = path15.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs4.writeFile(configPath, content, "utf-8");
@@ -3245,10 +3737,19 @@ function withDefaultConfig(config, fallbackPlatform) {
     logging: isRecord3(config.logging) ? config.logging : DEFAULT_CONFIG.logging
   };
 }
+function updatePlatformOptions(value, platform, options) {
+  const platformOptions = isRecord3(value) ? { ...value } : {};
+  const existing = platformOptions[platform];
+  platformOptions[platform] = {
+    ...isRecord3(existing) ? existing : {},
+    minimal: options.minimal === true
+  };
+  return platformOptions;
+}
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs4.readFile(
-      path13.join(rootDir, ".mancode", "state.json"),
+      path15.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -3271,7 +3772,7 @@ function isRecord3(value) {
 
 // src/commands/list-platforms.ts
 import { promises as fs5 } from "fs";
-import path14 from "path";
+import path16 from "path";
 import process5 from "process";
 var EXIT_OK3 = 0;
 async function listPlatforms(rootDir = process5.cwd()) {
@@ -3288,7 +3789,7 @@ async function listPlatforms(rootDir = process5.cwd()) {
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path14.join(rootDir, ".mancode", "config.json"),
+      path16.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -3312,22 +3813,24 @@ function describePlatform(platform) {
 }
 
 // src/commands/manps.ts
-import { access as access2 } from "fs/promises";
-import path16 from "path";
+import { access as access4 } from "fs/promises";
+import path18 from "path";
 import { createInterface } from "readline/promises";
 
 // src/system/preseason.ts
+import { execFile } from "child_process";
 import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
+  access as access3,
   lstat,
-  mkdir as mkdir6,
+  mkdir as mkdir7,
   readFile as readFile6,
-  readdir,
+  readdir as readdir2,
   rename,
-  writeFile as writeFile7
+  writeFile as writeFile9
 } from "fs/promises";
-import path15 from "path";
+import path17 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -3356,16 +3859,60 @@ var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 var MAX_SCAN_DEPTH = 20;
 var MAX_PROJECT_FILES = 5e3;
+var DEPCRUISE_TIMEOUT_MS = 15e3;
+var DEPCRUISE_MAX_BUFFER = 4 * 1024 * 1024;
+var SCANNERS = [
+  {
+    name: "scripts",
+    areas: ["all", "config"],
+    scan: ({ pkg }) => scanScripts(pkg)
+  },
+  {
+    name: "dependency-overlap",
+    areas: ["all", "deps"],
+    scan: ({ pkg }) => scanDependencyOverlap(pkg)
+  },
+  {
+    name: "security",
+    areas: ["all", "security"],
+    scan: ({ pkg }) => scanSecurity(pkg)
+  },
+  {
+    name: "todos",
+    areas: ["all", "dead-code"],
+    scan: ({ projectRoot, files }) => scanTodos(projectRoot, files)
+  },
+  {
+    name: "test-gaps",
+    areas: ["all", "dead-code"],
+    scan: ({ files }) => scanTestGaps(files)
+  },
+  {
+    name: "config",
+    areas: ["all", "config"],
+    scan: ({ projectRoot, files }) => scanConfig(projectRoot, files)
+  },
+  {
+    name: "aesthetic-drift",
+    areas: ["all"],
+    scan: ({ projectRoot, files }) => scanAestheticDrift(projectRoot, files)
+  },
+  {
+    name: "architecture",
+    areas: ["all"],
+    scan: ({ projectRoot }) => scanArchitecture(projectRoot)
+  }
+];
 async function runPreseasonScan(projectRoot, area = "all") {
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const normalizedArea = normalizeArea(area);
   const pkg = await readPackageJson(projectRoot);
   const needsFiles = normalizedArea === "all" || normalizedArea === "dead-code" || normalizedArea === "config";
   const files = needsFiles ? await listProjectFiles(projectRoot) : [];
-  const issues = scanArea(projectRoot, normalizedArea, pkg, files).slice(0, 20);
-  const reportDir = path15.join(projectRoot, ".mancode", "preseason-reports");
-  await mkdir6(reportDir, { recursive: true });
-  const issueDbPath = path15.join(
+  const issues = (await scanArea(projectRoot, normalizedArea, pkg, files)).slice(0, 20);
+  const reportDir = path17.join(projectRoot, ".mancode", "preseason-reports");
+  await mkdir7(reportDir, { recursive: true });
+  const issueDbPath = path17.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -3383,9 +3930,9 @@ async function runPreseasonScan(projectRoot, area = "all") {
     issueDbPath
   };
   const database = await buildIssueDatabase(projectRoot, report);
-  await writeFile7(reportPath, renderPreseasonReport(report), "utf-8");
-  await writeFile7(
-    path15.join(projectRoot, ".mancode", "preseason-report.md"),
+  await writeFile9(reportPath, renderPreseasonReport(report), "utf-8");
+  await writeFile9(
+    path17.join(projectRoot, ".mancode", "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -3393,7 +3940,7 @@ async function runPreseasonScan(projectRoot, area = "all") {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = path15.join(
+  const issueDbPath = path17.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -3475,7 +4022,7 @@ async function runPreseasonRemediation(projectRoot, issues, options = {}) {
     write("   Decision: skipped.");
   }
   database.updatedAt = now;
-  await writeFile7(
+  await writeFile9(
     issueDbPath,
     `${JSON.stringify(database, null, 2)}
 `,
@@ -3498,32 +4045,16 @@ function normalizeArea(area) {
     `invalid area: ${area}. Supported areas: ${PRESEASON_AREAS.join(", ")}`
   );
 }
-function scanArea(projectRoot, area, pkg, files) {
-  switch (area) {
-    case "deps":
-      return scanDependencyOverlap(pkg);
-    case "security":
-      return scanSecurity(pkg);
-    case "dead-code":
-      return [...scanTodos(projectRoot, files), ...scanTestGaps(files)];
-    case "config":
-      return [...scanScripts(pkg), ...scanConfig(projectRoot, files)];
-    case "all":
-      return [
-        ...scanScripts(pkg),
-        ...scanDependencyOverlap(pkg),
-        ...scanSecurity(pkg),
-        ...scanTodos(projectRoot, files),
-        ...scanTestGaps(files),
-        ...scanConfig(projectRoot, files),
-        ...scanAestheticDrift(projectRoot, files)
-      ];
-  }
+async function scanArea(projectRoot, area, pkg, files) {
+  const ctx = { projectRoot, area, pkg, files };
+  const active = SCANNERS.filter((scanner) => scanner.areas.includes(area));
+  const chunks = await Promise.all(active.map((scanner) => scanner.scan(ctx)));
+  return chunks.flat();
 }
 async function allocateReportPath(reportDir, baseName) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
-    const candidate = path15.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path17.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -3566,14 +4097,14 @@ async function walk(root, current, results, depth) {
   if (depth > MAX_SCAN_DEPTH || results.length >= MAX_PROJECT_FILES) return;
   let entries;
   try {
-    entries = await readdir(current);
+    entries = await readdir2(current);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path15.join(current, entry);
-    const rel = path15.relative(root, abs);
+    const abs = path17.join(current, entry);
+    const rel = path17.relative(root, abs);
     let info;
     try {
       info = await lstat(abs);
@@ -3583,7 +4114,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(path15.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path17.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -3591,7 +4122,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile6(path15.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile6(path17.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3684,7 +4215,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path15.join(projectRoot, file);
+    const abs = path17.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -3721,7 +4252,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 = path15.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path17.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -3730,13 +4261,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path15.basename(file)}.`,
+    detail: `No matching test file was found for ${path17.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(path15.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path17.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -3747,7 +4278,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path15.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path17.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -3766,7 +4297,7 @@ function scanAestheticDrift(projectRoot, files) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path15.join(projectRoot, file));
+      content = readFileSyncSafe(path17.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -3785,6 +4316,151 @@ function scanAestheticDrift(projectRoot, files) {
   }
   return issues;
 }
+async function scanArchitecture(projectRoot) {
+  const localBinary = path17.join(
+    projectRoot,
+    "node_modules",
+    ".bin",
+    process.platform === "win32" ? "depcruise.cmd" : "depcruise"
+  );
+  const binary = pathExistsSync(localBinary) ? localBinary : "depcruise";
+  const result = await runDepcruise(binary, projectRoot);
+  if (result.status === "not-found") {
+    if (!await hasDependencyCruiserConfig(projectRoot)) return [];
+    return [architectureScannerUnavailableIssue()];
+  }
+  const parsed = parseDepcruiseJson(result.stdout);
+  if (!parsed) {
+    return [
+      {
+        id: "architecture-scan-skipped",
+        severity: "P2",
+        type: "architecture",
+        title: "Architecture scan skipped",
+        detail: summarizeProcessFailure(result),
+        recommendation: "Check the dependency-cruiser configuration or run depcruise manually to inspect the failure."
+      }
+    ];
+  }
+  const violations = extractDepcruiseViolations(parsed);
+  if (violations.length === 0) return [];
+  return violations.slice(0, 5).map((violation, index) => ({
+    id: `architecture-${index + 1}`,
+    severity: depcruiseSeverityToPreseason(violation.severity),
+    type: "architecture",
+    title: `Architecture rule violation: ${violation.ruleName}`,
+    file: violation.from,
+    detail: `${violation.from}${violation.to ? ` -> ${violation.to}` : ""}${violation.comment ? `: ${violation.comment}` : ""}`,
+    recommendation: "Respect the configured dependency boundary or update the dependency-cruiser rule if the architecture decision changed."
+  }));
+}
+async function hasDependencyCruiserConfig(projectRoot) {
+  const files = [
+    ".dependency-cruiser.js",
+    ".dependency-cruiser.cjs",
+    ".dependency-cruiser.mjs",
+    ".dependency-cruiser.json",
+    "dependency-cruiser.config.js",
+    "dependency-cruiser.config.cjs",
+    "dependency-cruiser.config.mjs"
+  ];
+  const results = await Promise.all(
+    files.map((file) => pathExists7(path17.join(projectRoot, file)))
+  );
+  return results.some(Boolean);
+}
+function architectureScannerUnavailableIssue() {
+  return {
+    id: "architecture-scanner-unavailable",
+    severity: "P2",
+    type: "architecture",
+    title: "Architecture scanner not installed",
+    detail: "dependency-cruiser config was found, but dependency-cruiser was not found in node_modules/.bin or on PATH. Architecture dependency rules cannot be checked.",
+    recommendation: "Install dependency-cruiser (npm i -D dependency-cruiser) to enable architecture scanning."
+  };
+}
+function runDepcruise(binary, projectRoot) {
+  return new Promise((resolve) => {
+    const needsShell = process.platform === "win32";
+    execFile(
+      binary,
+      ["--output-type", "json", "."],
+      {
+        cwd: projectRoot,
+        timeout: DEPCRUISE_TIMEOUT_MS,
+        maxBuffer: DEPCRUISE_MAX_BUFFER,
+        shell: needsShell
+      },
+      (error, stdout, stderr) => {
+        if (!error) {
+          resolve({
+            status: "ok",
+            stdout,
+            stderr,
+            exitCode: 0,
+            timedOut: false
+          });
+          return;
+        }
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+          resolve({
+            status: "not-found",
+            stdout: "",
+            stderr: "",
+            exitCode: null,
+            timedOut: false
+          });
+          return;
+        }
+        resolve({
+          status: "failed",
+          stdout: nodeError.stdout ?? stdout,
+          stderr: nodeError.stderr ?? stderr,
+          exitCode: typeof nodeError.code === "number" ? nodeError.code : null,
+          timedOut: Boolean(nodeError.killed || nodeError.signal === "SIGTERM")
+        });
+      }
+    );
+  });
+}
+function parseDepcruiseJson(output) {
+  if (!output.trim()) return null;
+  try {
+    return JSON.parse(output);
+  } catch {
+    return null;
+  }
+}
+function extractDepcruiseViolations(value) {
+  if (!isRecord4(value)) return [];
+  const rawViolations = Array.isArray(value.violations) ? value.violations : isRecord4(value.summary) && Array.isArray(value.summary.violations) ? value.summary.violations : [];
+  return rawViolations.map((violation) => normalizeDepcruiseViolation(violation)).filter(
+    (violation) => violation !== null
+  );
+}
+function normalizeDepcruiseViolation(value) {
+  if (!isRecord4(value)) return null;
+  const rule = isRecord4(value.rule) ? value.rule : {};
+  const from = typeof value.from === "string" ? value.from : "";
+  const to = typeof value.to === "string" ? value.to : void 0;
+  const ruleName = typeof rule.name === "string" ? rule.name : typeof value.name === "string" ? value.name : "unnamed-rule";
+  const severity = typeof rule.severity === "string" ? rule.severity : typeof value.severity === "string" ? value.severity : "warn";
+  const comment = typeof value.comment === "string" ? value.comment : void 0;
+  if (!from) return null;
+  return { ruleName, severity, from, to, comment };
+}
+function depcruiseSeverityToPreseason(severity) {
+  return severity.toLowerCase() === "error" ? "P1" : "P2";
+}
+function summarizeProcessFailure(result) {
+  if (result.timedOut) {
+    return `dependency-cruiser timed out after ${DEPCRUISE_TIMEOUT_MS}ms.`;
+  }
+  const output = `${result.stderr || result.stdout}`.trim();
+  const summary = output.length > 0 ? output.slice(0, 240) : "No output.";
+  return `dependency-cruiser exited with ${result.exitCode ?? "unknown"}: ${summary}`;
+}
 function containsHardcodedColor(content) {
   return content.split("\n").some(
     (line) => /#[0-9a-fA-F]{3,8}\b/.test(line) && !/^\s*--[a-zA-Z0-9-_]+\s*:/.test(line)
@@ -3795,9 +4471,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path15.relative(projectRoot, report.reportPath);
+  const reportRef = path17.relative(projectRoot, report.reportPath);
   const run = {
-    id: path15.basename(report.reportPath, ".md"),
+    id: path17.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -3860,7 +4536,7 @@ async function readIssueDatabase(issueDbPath) {
 }
 async function writeJsonAtomic(file, value) {
   const tmp = `${file}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await writeFile7(tmp, `${JSON.stringify(value, null, 2)}
+  await writeFile9(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
   await rename(tmp, file);
 }
@@ -3903,20 +4579,20 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path15.join(projectRoot, ".gitignore");
+    const gitignorePath = path17.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
-    await writeFile7(gitignorePath, `${DEFAULT_GITIGNORE}
+    await writeFile9(gitignorePath, `${DEFAULT_GITIGNORE}
 `, "utf-8");
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path15.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path17.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
-    await writeFile7(editorconfigPath, `${DEFAULT_EDITORCONFIG}
+    await writeFile9(editorconfigPath, `${DEFAULT_EDITORCONFIG}
 `, "utf-8");
     return { applied: true, action: "created .editorconfig" };
   }
@@ -3952,7 +4628,7 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path15.join(projectRoot, "package.json");
+  const packagePath = path17.join(projectRoot, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile6(packagePath, "utf-8"));
@@ -3965,7 +4641,7 @@ async function addPackageScript(projectRoot, scriptName, script) {
     ...scripts,
     [scriptName]: script
   };
-  await writeFile7(packagePath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile9(packagePath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
   return true;
 }
@@ -4044,9 +4720,20 @@ function readFileSyncSafe(file) {
 function pathExistsSync(file) {
   return existsSync(file);
 }
+async function pathExists7(file) {
+  try {
+    await access3(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isNodeError4(err) {
   return err instanceof Error && "code" in err;
 }
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
 
 // src/commands/manps.ts
 var EXIT_OK4 = 0;
@@ -4054,7 +4741,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(path16.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists8(path18.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
@@ -4133,8 +4820,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path16.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path16.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path18.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path18.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -4150,7 +4837,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path16.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path18.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK4;
@@ -4196,9 +4883,9 @@ async function readStdinLines() {
   }
   return Buffer.concat(chunks).toString("utf-8").split(/\r?\n/).filter((line) => line.length > 0);
 }
-async function pathExists7(p) {
+async function pathExists8(p) {
   try {
-    await access2(p);
+    await access4(p);
     return true;
   } catch {
     return false;
@@ -4207,13 +4894,13 @@ async function pathExists7(p) {
 
 // src/commands/refresh-style.ts
 import { promises as fs6 } from "fs";
-import path17 from "path";
+import path19 from "path";
 import process6 from "process";
 var EXIT_OK5 = 0;
 var EXIT_NOT_INITIALIZED3 = 1;
 async function refreshStyle(rootDir = process6.cwd()) {
-  const stateFile = path17.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists8(stateFile)) {
+  const stateFile = path19.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists9(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
     return EXIT_NOT_INITIALIZED3;
@@ -4225,13 +4912,13 @@ async function refreshStyle(rootDir = process6.cwd()) {
   }
   console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
   const tokens = await scanAesthetics(rootDir, project.uiLibrary);
-  const tokensPath = path17.join(
+  const tokensPath = path19.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs6.mkdir(path17.dirname(tokensPath), { recursive: true });
+  await fs6.mkdir(path19.dirname(tokensPath), { recursive: true });
   await fs6.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -4295,7 +4982,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path17.join(rootDir, ".mancode", "config.json"),
+      path19.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -4306,7 +4993,7 @@ async function readInstalledPlatforms2(rootDir) {
     return [];
   }
 }
-async function pathExists8(p) {
+async function pathExists9(p) {
   try {
     await fs6.access(p);
     return true;
@@ -4318,19 +5005,19 @@ async function pathExists8(p) {
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs7 } from "fs";
-import path19 from "path";
+import path21 from "path";
 import process7 from "process";
 
 // src/system/workflow.ts
 import {
-  mkdir as mkdir7,
+  mkdir as mkdir8,
   readFile as readFile7,
-  readdir as readdir2,
-  rm as rm3,
+  readdir as readdir3,
+  rm as rm4,
   stat as stat2,
-  writeFile as writeFile8
+  writeFile as writeFile10
 } from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 var METADATA_FILE = "metadata.json";
 var SLUG_MAX = 30;
 var TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
@@ -4347,7 +5034,7 @@ function slugify(text) {
   return text.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 async function createWorkflow(projectRoot, task, mode) {
-  await mkdir7(workflowsRoot(projectRoot), { recursive: true });
+  await mkdir8(workflowsRoot(projectRoot), { recursive: true });
   const taskId = await allocateTaskId(projectRoot, generateTaskId(task));
   const dir = workflowDir(projectRoot, taskId);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4368,7 +5055,7 @@ async function allocateTaskId(projectRoot, baseTaskId) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const taskId = attempt === 0 ? baseTaskId : `${baseTaskId}-${attempt + 1}`;
     try {
-      await mkdir7(workflowDir(projectRoot, taskId));
+      await mkdir8(workflowDir(projectRoot, taskId));
       return taskId;
     } catch (err) {
       if (isNodeError5(err) && err.code === "EEXIST") {
@@ -4408,7 +5095,7 @@ async function listWorkflows(projectRoot) {
   const root = workflowsRoot(projectRoot);
   let entries;
   try {
-    entries = await readdir2(root);
+    entries = await readdir3(root);
   } catch {
     return [];
   }
@@ -4428,23 +5115,23 @@ async function deleteWorkflow(projectRoot, taskId) {
   } catch {
     return false;
   }
-  await rm3(dir, { recursive: true, force: true });
+  await rm4(dir, { recursive: true, force: true });
   return true;
 }
 function workflowsRoot(projectRoot) {
-  return path18.join(projectRoot, ".mancode", "workflows");
+  return path20.join(projectRoot, ".mancode", "workflows");
 }
 function workflowDir(projectRoot, taskId) {
   assertValidTaskId(taskId);
-  return path18.join(workflowsRoot(projectRoot), taskId);
+  return path20.join(workflowsRoot(projectRoot), taskId);
 }
 function metadataPath(projectRoot, taskId) {
-  return path18.join(workflowDir(projectRoot, taskId), METADATA_FILE);
+  return path20.join(workflowDir(projectRoot, taskId), METADATA_FILE);
 }
 async function writeMetadata(dir, meta) {
   const content = `${JSON.stringify(meta, null, 2)}
 `;
-  await writeFile8(path18.join(dir, METADATA_FILE), content, "utf-8");
+  await writeFile10(path20.join(dir, METADATA_FILE), content, "utf-8");
 }
 function parseWorkflowMeta(raw, taskId) {
   try {
@@ -4467,12 +5154,13 @@ function assertValidTaskId(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 = process7.cwd(), options = {}) {
-  const stateFile = path19.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists9(stateFile)) {
+  const stateFile = path21.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;
@@ -4558,19 +5246,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs7.readFile(path19.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs7.readFile(path21.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path19.basename(rootDir);
+  return path21.basename(rootDir);
 }
 async function readConfig2(rootDir) {
   try {
     const raw = await fs7.readFile(
-      path19.join(rootDir, ".mancode", "config.json"),
+      path21.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4597,9 +5285,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists9(path19.join(rootDir, ".mancode", "hooks", "session-start.sh")),
-    pathExists9(
-      path19.join(rootDir, ".mancode", "hooks", "user-prompt-submit.sh")
+    pathExists10(path21.join(rootDir, ".mancode", "hooks", "session-start.sh")),
+    pathExists10(
+      path21.join(rootDir, ".mancode", "hooks", "user-prompt-submit.sh")
     ),
     isRegistered(rootDir)
   ]);
@@ -4608,7 +5296,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs7.readFile(
-      path19.join(rootDir, ".claude", "settings.json"),
+      path21.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -4618,9 +5306,9 @@ async function isRegistered(rootDir) {
   }
 }
 function hooksRegistered2(settings) {
-  if (!isRecord4(settings)) return false;
+  if (!isRecord5(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord4(hooks)) return false;
+  if (!isRecord5(hooks)) return false;
   return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.sh") && hasHookCommand2(
     hooks.UserPromptSubmit,
     ".mancode/hooks/user-prompt-submit.sh"
@@ -4629,21 +5317,21 @@ function hooksRegistered2(settings) {
 function hasHookCommand2(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord4(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord5(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord4(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord5(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path19.join(
+  const hookPath = path21.join(
     rootDir,
     ".mancode",
     "hooks",
     "user-prompt-submit.sh"
   );
-  if (!await pathExists9(hookPath)) {
+  if (!await pathExists10(hookPath)) {
     return { tokens: 0, cap: 800 };
   }
   try {
@@ -4662,15 +5350,28 @@ function runHookEstimate(rootDir, hookPath) {
       cwd: rootDir,
       stdio: ["pipe", "pipe", "ignore"]
     });
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      fn();
+    };
+    const timeout = setTimeout(() => {
+      child.kill();
+      finish(() => reject(new Error("hook estimate timed out")));
+    }, HOOK_ESTIMATE_TIMEOUT_MS);
     let stdout = "";
     child.stdout.setEncoding("utf-8");
     child.stdout.on("data", (chunk) => {
       stdout += chunk;
     });
-    child.on("error", reject);
+    child.on("error", (err) => finish(() => reject(err)));
     child.on("close", (code) => {
-      if (code === 0) resolve(stdout);
-      else reject(new Error(`hook exited with ${code}`));
+      finish(() => {
+        if (code === 0) resolve(stdout);
+        else reject(new Error(`hook exited with ${code}`));
+      });
     });
     child.stdin.end(
       JSON.stringify({ prompt: "design a button component with tailwind css" })
@@ -4733,10 +5434,10 @@ function formatTeamStatus(team) {
 function workflowStepMax(mode) {
   return mode === "man8" ? 3 : 8;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
-async function pathExists9(p) {
+async function pathExists10(p) {
   try {
     await fs7.access(p);
     return true;
@@ -4746,8 +5447,8 @@ async function pathExists9(p) {
 }
 
 // src/commands/uninstall.ts
-import { access as access3, readFile as readFile8, rm as rm4, writeFile as writeFile9 } from "fs/promises";
-import path20 from "path";
+import { access as access5, readFile as readFile8, rm as rm5, writeFile as writeFile11 } from "fs/promises";
+import path22 from "path";
 import process8 from "process";
 var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
@@ -4768,8 +5469,8 @@ var CLAUDE_AGENT_FILES = [
   "plan-coach.md"
 ];
 async function uninstall(rootDir = process8.cwd(), platform, options = {}) {
-  const stateFile = path20.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists10(stateFile)) {
+  const stateFile = path22.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;
@@ -4780,7 +5481,7 @@ async function uninstall(rootDir = process8.cwd(), platform, options = {}) {
     if (!installer) {
       console.error(`\u2717  Unsupported platform: ${platform}`);
       console.error(
-        "   Supported platforms: claude-code, cursor, codex, copilot"
+        `   Supported platforms: ${getPlatformInstallers().map((item) => item.name).join(", ")}`
       );
       return EXIT_UNSUPPORTED_PLATFORM2;
     }
@@ -4809,34 +5510,36 @@ async function uninstallPlatform(rootDir, platform) {
     await uninstallCodex(rootDir);
   } else if (platform === "copilot") {
     await uninstallCopilot(rootDir);
+  } else if (platform === "zcode") {
+    await uninstallZcode(rootDir);
   }
   await removeFromConfig(rootDir, platform);
 }
 async function uninstallAll(rootDir) {
   console.log("\u2713  Removing all platform adapters...");
-  for (const p of ["claude-code", "cursor", "codex", "copilot"]) {
+  for (const p of getPlatformInstallers().map((platform) => platform.name)) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm4(path20.join(rootDir, ".mancode"), {
+  await rm5(path22.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
 }
 async function uninstallClaudeCode(rootDir) {
-  const claudeDir = path20.join(rootDir, ".claude");
-  const skillsDir = path20.join(claudeDir, "skills");
-  const agentsDir = path20.join(claudeDir, "agents");
+  const claudeDir = path22.join(rootDir, ".claude");
+  const skillsDir = path22.join(claudeDir, "skills");
+  const agentsDir = path22.join(claudeDir, "agents");
   for (const skillDir of CLAUDE_SKILL_DIRS) {
-    await rm4(path20.join(skillsDir, skillDir), { recursive: true, force: true });
+    await rm5(path22.join(skillsDir, skillDir), { recursive: true, force: true });
   }
   for (const agentFile of CLAUDE_AGENT_FILES) {
-    await rm4(path20.join(agentsDir, agentFile), { force: true });
+    await rm5(path22.join(agentsDir, agentFile), { force: true });
   }
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path20.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path22.join(rootDir, ".claude", "settings.json");
   let content;
   try {
     content = await readFile8(settingsPath, "utf-8");
@@ -4849,18 +5552,19 @@ async function cleanClaudeSettings(rootDir) {
   } catch {
     return;
   }
-  if (!isRecord5(settings.hooks)) return;
+  if (!isRecord6(settings.hooks)) return;
   const cleanedHooks = {};
   for (const [event, groups] of Object.entries(settings.hooks)) {
     if (!Array.isArray(groups)) {
       cleanedHooks[event] = groups;
       continue;
     }
-    const filtered = groups.filter((group) => {
-      if (!isRecord5(group) || !Array.isArray(group.hooks)) return true;
-      return !group.hooks.some(
-        (hook) => isRecord5(hook) && typeof hook.command === "string" && hook.command.includes(".mancode/hooks/")
+    const filtered = groups.flatMap((group) => {
+      if (!isRecord6(group) || !Array.isArray(group.hooks)) return [group];
+      const hooks = group.hooks.filter(
+        (hook) => !(isRecord6(hook) && typeof hook.command === "string" && hook.command.includes(".mancode/hooks/"))
       );
+      return hooks.length > 0 ? [{ ...group, hooks }] : [];
     });
     if (filtered.length > 0) {
       cleanedHooks[event] = filtered;
@@ -4871,7 +5575,7 @@ async function cleanClaudeSettings(rootDir) {
   } else {
     settings.hooks = void 0;
   }
-  await writeFile9(
+  await writeFile11(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -4879,27 +5583,29 @@ async function cleanClaudeSettings(rootDir) {
   );
 }
 async function uninstallCursor(rootDir) {
-  const rulesDir = path20.join(rootDir, ".cursor", "rules");
+  const rulesDir = path22.join(rootDir, ".cursor", "rules");
   for (const file of MANCODE_CURSOR_RULE_FILES) {
-    await rm4(path20.join(rulesDir, file), { force: true });
+    await rm5(path22.join(rulesDir, file), { force: true });
   }
+  await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path20.join(rootDir, "AGENTS.md");
+  const agentsPath = path22.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile8(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile9(agentsPath, `${cleaned}
+      await writeFile11(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm4(agentsPath, { force: true });
+      await rm5(agentsPath, { force: true });
     }
   } catch {
   }
+  await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path20.join(
+  const instructionsPath = path22.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
@@ -4908,22 +5614,50 @@ async function uninstallCopilot(rootDir) {
     const content = await readFile8(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile9(instructionsPath, `${cleaned}
+      await writeFile11(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm4(instructionsPath, { force: true });
+      await rm5(instructionsPath, { force: true });
     }
   } catch {
   }
+  await removeCopilotPrompts(rootDir);
+}
+async function uninstallZcode(rootDir) {
+  const agentsPath = path22.join(rootDir, "AGENTS.md");
+  try {
+    const content = await readFile8(agentsPath, "utf-8");
+    const cleaned = removeManagedBlock(
+      content,
+      ZCODE_MANCODE_START_MARKER,
+      ZCODE_MANCODE_END_MARKER
+    );
+    if (cleaned.trim()) {
+      await writeFile11(agentsPath, `${cleaned}
+`, "utf-8");
+    } else {
+      await rm5(agentsPath, { force: true });
+    }
+  } catch {
+  }
+  await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path20.join(rootDir, ".mancode", "config.json");
+  const configPath = path22.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await readFile8(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
-      await writeFile9(
+      if (isRecord6(config.platformOptions)) {
+        const platformOptions = Object.fromEntries(
+          Object.entries(config.platformOptions).filter(
+            ([name]) => name !== platform
+          )
+        );
+        config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
+      }
+      await writeFile11(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -4933,12 +5667,12 @@ async function removeFromConfig(rootDir, platform) {
   } catch {
   }
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function pathExists10(p) {
+async function pathExists11(p) {
   try {
-    await access3(p);
+    await access5(p);
     return true;
   } catch {
     return false;
@@ -4956,13 +5690,13 @@ function version() {
 }
 
 // src/commands/workflow.ts
-import { access as access4 } from "fs/promises";
-import path21 from "path";
+import { access as access6 } from "fs/promises";
+import path23 from "path";
 var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_INVALID_ARG2 = 2;
 async function workflow(rootDir, subcommand, args = [], options = {}) {
-  if (!await pathExists11(path21.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists12(path23.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
@@ -5219,9 +5953,9 @@ 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 access4(p);
+    await access6(p);
     return true;
   } catch {
     return false;
@@ -5234,10 +5968,9 @@ program.command("init").description("Initialize mancode in the current project")
   const code = await init(process.cwd(), options);
   process.exitCode = code;
 });
-program.command("install [platform]").description("Install platform adapter (claude-code, cursor, codex, copilot)").option("--force", "Reinstall even if already installed").option("--minimal", "Minimal install (MVP-2)").option(
-  "--commit-hook",
-  "Install optional /manteam Conventional Commit enforcement hook"
-).action(async (platform, options) => {
+program.command("install [platform]").description(
+  "Install platform adapter (claude-code, cursor, codex, copilot, zcode)"
+).option("--force", "Reinstall even if already installed").option("--minimal", "Minimal install (MVP-2)").action(async (platform, options) => {
   const code = await install(
     process.cwd(),
     platform ?? "claude-code",