mancode 0.3.2 → 0.3.4

package/dist/cli.js

@@ -7,9 +7,10 @@ import {
 import { program } from "commander";
 
 // src/commands/init.ts
-import { promises as fs2 } from "fs";
-import path13 from "path";
-import process3 from "process";
+import { promises as fs3 } from "fs";
+import os from "os";
+import path14 from "path";
+import process5 from "process";
 
 // src/installers/claude-code.ts
 import {
@@ -510,215 +511,229 @@ function yamlString(s) {
 }
 
 // src/templates/inline.ts
-var SESSION_START_HOOK = `#!/bin/bash
-# .mancode/hooks/session-start.sh
-# mancode SessionStart hook - \u52A0\u8F7D\u9879\u76EE\u4E0A\u4E0B\u6587
-# \u7CFB\u7EDF\u4F9D\u8D56\uFF1Abash\u3001git\u3001\uFF08\u53EF\u9009\uFF09jq
-set -uo pipefail
-
-PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo "$PWD")"
-STATE_FILE="$PROJECT_ROOT/.mancode/state.json"
-PROFILE_FILE="$PROJECT_ROOT/.mancode/project-profile.json"
-
-HAS_JQ=0
-if [ "\${MANCODE_DISABLE_JQ:-0}" != "1" ]; then
-    command -v jq >/dev/null 2>&1 && HAS_JQ=1
-fi
-
-json_get() {
-    local key="$1"
-    local file="$2"
-    if [ "$HAS_JQ" = "1" ]; then
-        jq -r ".$key // empty" "$file" 2>/dev/null || true
-    else
-        grep "\\"$key\\"" "$file" 2>/dev/null | sed -E 's/.*: *"([^"]*)".*/\\1/' || true
-    fi
-}
-
-json_any_get() {
-    local key="$1"
-    local file="$2"
-    if [ "$HAS_JQ" = "1" ]; then
-        jq -r ".$key // empty" "$file" 2>/dev/null || true
-    else
-        grep "\\"$key\\"" "$file" 2>/dev/null | head -n 1 | sed -E 's/.*: *"?([^",}]*)"?[,]?.*/\\1/' || true
-    fi
-}
-
-if [ ! -f "$STATE_FILE" ]; then
-    echo "\u2139\uFE0F mancode \u672A\u521D\u59CB\u5316\u3002\u8FD0\u884C \\\`mancode init\\\` \u5F00\u59CB\u3002"
-    exit 0
-fi
-
-# \u6E05\u6D17\u51FD\u6570\uFF1A\u53BB\u6362\u884C\u3001\u9650\u5236\u957F\u5EA6\uFF08\u9632\u6B62\u810F\u6570\u636E\u6C61\u67D3 prompt\uFF09
-sanitize() {
-    printf '%s' "$1" | tr '\\n\\r' ' ' | head -c 200
-}
-
-MODE=$(json_get "currentMode" "$STATE_FILE")
-TECH_STACK=$(json_get "techStack" "$STATE_FILE")
-UI_LIBRARY=$(json_get "uiLibrary" "$STATE_FILE")
-TEAM_AUTO=$(json_any_get "teamModeAutoDetected" "$STATE_FILE")
-CONTRIBUTORS=$(json_any_get "contributors" "$STATE_FILE")
-
-echo "mancode_mode: \${MODE:-solo}"
-echo "project_type: $(sanitize "$TECH_STACK")"
-echo "ui_library: $(sanitize "$UI_LIBRARY")"
-echo ""
-
-echo "## mancode \xB7 \${MODE:-solo} mode"
-echo ""
-echo "\u4F60\u6B63\u5728\u4F7F\u7528 mancode \${MODE:-solo} \u6A21\u5F0F\u3002"
-echo ""
-echo "### \u6838\u5FC3\u539F\u5219"
-echo "1. **\u4F18\u5148\u590D\u7528\u9879\u76EE\u5DF2\u6709\u4EE3\u7801**"
-echo "   - \u68C0\u67E5\u5DF2\u68C0\u6D4B\u5230\u7684\u6E90\u7801\u76EE\u5F55\u548C\u5DF2\u6709\u7C7B\u4F3C\u5B9E\u73B0"
-echo "   - \u590D\u7528\u73B0\u6709\u7EC4\u4EF6\u3001\u51FD\u6570\u3001\u6837\u5F0F"
-echo ""
-if [ "$(json_get "uiAssets" "$PROFILE_FILE")" = "detected" ]; then
-    echo "2. **\u5E94\u7528\u9879\u76EE\u5BA1\u7F8E token**\uFF08\u4EC5\u5728\u9879\u76EE profile \u786E\u8BA4\u6709 UI \u8D44\u4EA7\u4E14\u4EFB\u52A1\u6D89\u53CA UI \u65F6\uFF09"
-    echo "   - UI library: $(sanitize "$UI_LIBRARY")"
-    echo "   - \u4F7F\u7528\u9879\u76EE\u5DF2\u6709\u7684\u8BBE\u8BA1 token"
-else
-    echo "2. **\u6309\u9879\u76EE\u80FD\u529B\u5DE5\u4F5C**"
-    echo "   - \u4E0D\u5047\u5B9A\u5B58\u5728 UI\u3001\u6D4F\u89C8\u5668\u6216\u7279\u5B9A\u6280\u672F\u6808"
-    echo "   - \u5148\u8BFB\u53D6 project-profile \u4E0E\u9879\u76EE\u73B0\u6709\u9A8C\u8BC1\u65B9\u5F0F"
-fi
-echo ""
-echo "3. **\u6700\u5C0F\u6539\u52A8**"
-echo "   - \u53EA\u6539\u7528\u6237\u8981\u6C42\u7684\u90E8\u5206"
-echo "   - \u4E0D\u91CD\u6784\u65E0\u5173\u4EE3\u7801"
-
-if [ "$TEAM_AUTO" = "true" ] && [ "\${MODE:-solo}" = "solo" ]; then
-    echo ""
-    echo "### \u56E2\u961F\u534F\u4F5C\u63D0\u9192"
-    echo "\u68C0\u6D4B\u5230\u56E2\u961F\u9879\u76EE\uFF08contributors: \${CONTRIBUTORS:-2}\uFF09\u3002"
-    echo '- \u6D89\u53CA\u591A\u4EBA\u534F\u4F5C\u3001\u4EA4\u63A5\u3001PR\u3001\u5171\u4EAB\u6A21\u5757\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528 /manteam <task>\u3002'
-    echo '- \u53EA\u505A\u4E2A\u4EBA\u5C0F\u6539\u52A8\u65F6\uFF0C\u53EF\u4EE5\u7EE7\u7EED solo\uFF1B\u9700\u8981\u9000\u51FA\u6D41\u7A0B\u7528 /mansolo\u3002'
-fi
+var SESSION_START_HOOK = String.raw`#!/usr/bin/env node
+// .mancode/hooks/session-start.mjs
+// mancode SessionStart hook - cross-platform project context
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const projectRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../..',
+);
+const state = readJson(path.join(projectRoot, '.mancode', 'state.json'));
+const profile =
+  readJson(path.join(projectRoot, '.mancode', 'project-profile.json')) || {};
+
+if (!state) {
+  console.log('ℹ️ mancode 未初始化。运行 mancode init 开始。');
+  process.exit(0);
+}
+
+const mode = text(state.currentMode) || 'solo';
+const techStack = sanitize(state.techStack);
+const uiLibrary = sanitize(state.uiLibrary);
+const output = [
+  'mancode_mode: ' + mode,
+  'project_type: ' + techStack,
+  'ui_library: ' + uiLibrary,
+  '',
+  '## mancode · ' + mode + ' mode',
+  '',
+  '你正在使用 mancode ' + mode + ' 模式。',
+  '',
+  '### 核心原则',
+  '1. **优先复用项目已有代码**',
+  '   - 检查已检测到的源码目录和已有类似实现',
+  '   - 复用现有组件、函数、样式',
+  '',
+];
+
+if (profile.uiAssets === 'detected') {
+  output.push(
+    '2. **应用项目审美 token**（仅在项目 profile 确认有 UI 资产且任务涉及 UI 时）',
+    '   - UI library: ' + uiLibrary,
+    '   - 使用项目已有的设计 token',
+  );
+} else {
+  output.push(
+    '2. **按项目能力工作**',
+    '   - 不假定存在 UI、浏览器或特定技术栈',
+    '   - 先读取 project-profile 与项目现有验证方式',
+  );
+}
+
+output.push(
+  '',
+  '3. **最小改动**',
+  '   - 只改用户要求的部分',
+  '   - 不重构无关代码',
+);
+
+if (state.teamModeAutoDetected === true && mode === 'solo') {
+  output.push(
+    '',
+    '### 团队协作提醒',
+    '检测到团队项目（contributors: ' +
+      (Number.isFinite(state.contributors) ? state.contributors : 2) +
+      '）。',
+    '- 涉及多人协作、交接、PR、共享模块时，优先使用 /manteam <task>。',
+    '- 只做个人小改动时，可以继续 solo；需要退出流程用 /mansolo。',
+  );
+}
+
+console.log(output.join('\n'));
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function text(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function sanitize(value) {
+  return String(value ?? '').replace(/[\r\n]/g, ' ').slice(0, 200);
+}
 `;
-var USER_PROMPT_SUBMIT_HOOK = `#!/bin/bash
-# .mancode/hooks/user-prompt-submit.sh
-# mancode UserPromptSubmit hook - \u6CE8\u5165 6 \u95EE\u8FFD\u95EE + \u5BA1\u7F8E token
-set -uo pipefail
-
-PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo "$PWD")"
-STATE_FILE="$PROJECT_ROOT/.mancode/state.json"
-AESTHETICS_FILE="$PROJECT_ROOT/.mancode/aesthetics/style-tokens.json"
-
-HAS_JQ=0
-if [ "\${MANCODE_DISABLE_JQ:-0}" != "1" ]; then
-    command -v jq >/dev/null 2>&1 && HAS_JQ=1
-fi
-
-json_get() {
-    local key="$1"
-    local file="$2"
-    if [ "$HAS_JQ" = "1" ]; then
-        jq -r ".$key // empty" "$file" 2>/dev/null || true
-    else
-        grep "\\"$key\\"" "$file" 2>/dev/null | sed -E 's/.*: *"([^"]*)".*/\\1/' || true
-    fi
-}
-
-# \u6E05\u6D17\u6CE8\u5165\u5230 prompt \u7684\u52A8\u6001\u503C\uFF1A\u53BB\u6362\u884C\u3001\u9650\u5236\u957F\u5EA6\uFF0C\u907F\u514D\u810F token \u6C61\u67D3\u4E0A\u4E0B\u6587\u7ED3\u6784
-sanitize() {
-    printf '%s' "$1" | tr '\\n\\r' ' ' | head -c 200
-}
-
-MODE=$(json_get "currentMode" "$STATE_FILE")
-
-# \u53EA\u5728 solo \u6A21\u5F0F\u4E0B\u8F93\u51FA 6 \u95EE
-if [ "$MODE" = "solo" ]; then
-    echo "## \u52A8\u624B\u524D\uFF0C\u5148\u60F3\u516D\u4E2A\u95EE\u9898\uFF1A"
-    echo ""
-    echo "1. **\u4E3A\u4EC0\u4E48\u505A\uFF1F**"
-    echo "   - \u8FD9\u4E2A\u6539\u52A8\u89E3\u51B3\u4EC0\u4E48\u95EE\u9898\uFF1F"
-    echo ""
-    echo "2. **\u5DF2\u7ECF\u6709\u4EC0\u4E48\uFF1F**"
-    echo "   - \u9879\u76EE\u91CC\u6709\u6CA1\u6709\u7C7B\u4F3C\u7684\u5B9E\u73B0\u53EF\u4EE5\u590D\u7528\uFF1F"
-    echo ""
-    echo "3. **\u6700\u5C11\u6539\u591A\u5C11\uFF1F**"
-    echo "   - \u80FD\u7528\u4E00\u884C\u89E3\u51B3\u5417\uFF1F\u80FD\u590D\u7528\u73B0\u6709\u4EE3\u7801\u5417\uFF1F"
-    echo ""
-    echo "4. **\u80FD\u4E0D\u80FD\u4E0D\u62C6\u65B0\u7CFB\u7EDF\uFF1F**"
-    echo "   - \u4E0D\u65B0\u5EFA\u6587\u4EF6\u6216\u6A21\u5757\u80FD\u5B8C\u6210\u5417\uFF1F"
-    echo ""
-    echo "5. **\u975E\u5E73\u51E1\u903B\u8F91\u600E\u6837\u6700\u5C0F\u8FD0\u884C\u9A8C\u8BC1\uFF1F**"
-    echo ""
-    echo "6. **\u6709\u4EC0\u4E48\u6CA1\u628A\u63E1\u7684\uFF1F**"
-    echo "   - \u5148\u81EA\u884C\u67E5\u4EE3\u7801\u6216\u6587\u6863\uFF0C\u6700\u591A 2 \u6B21\u5DE5\u5177\u8C03\u7528\uFF1B\u4ECD\u4E0D\u786E\u5B9A\u518D\u95EE\u7528\u6237\u3002"
-    echo ""
-fi
-
-# Claude Code \u901A\u8FC7 stdin \u4F20\u5165 JSON: {"prompt": "...", ...}
-# \u5148\u8BFB\u53D6\u5B8C\u6574\u8F93\u5165\uFF0C\u518D\u89E3\u6790
-INPUT=$(cat)
-
-if [ "$HAS_JQ" = "1" ]; then
-    USER_PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""' 2>/dev/null)
-    # jq \u5931\u8D25\u6216\u8FD4\u56DE\u7A7A\uFF0Cfallback \u5230\u539F\u59CB\u8F93\u5165
-    if [ -z "$USER_PROMPT" ]; then
-        USER_PROMPT="$INPUT"
-    fi
-else
-    # \u65E0 jq: \u4F7F\u7528 sed \u63D0\u53D6 JSON \u4E2D\u7684 prompt \u5B57\u6BB5
-    USER_PROMPT=$(echo "$INPUT" | sed -n 's/.*"prompt"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')
-    # sed \u5931\u8D25\uFF0Cfallback \u5230\u539F\u59CB\u8F93\u5165
-    if [ -z "$USER_PROMPT" ]; then
-        USER_PROMPT="$INPUT"
-    fi
-fi
-
-if [ "$MODE" = "solo" ] && echo "$USER_PROMPT" | grep -qiE "\u5148(\u522B|\u4E0D\u8981|\u770B|\u770B\u770B|\u8C03\u7814|\u5206\u6790|\u8BC4\u4F30)|\u7ED9.*\u65B9\u6848|\u7ED9.*\u8BA1\u5212|\u600E\u4E48.*\u505A|\u5982\u4F55.*\u505A|\u600E\u4E48.*\u5B9E\u73B0|\u5982\u4F55.*\u5B9E\u73B0|\u5E94\u8BE5\u600E\u4E48|\u600E\u4E48.*\u62C6|\u62C6\u5206|\u53EA\u7ED9.*\u8BA1\u5212|\u4E0D\u8981.*\u6539\u4EE3\u7801|\u522B.*\u6539\u4EE3\u7801|\u4E0D\u8981.*\u52A8\u4EE3\u7801|\u522B.*\u52A8\u4EE3\u7801|\u8BC4\u4F30.*\u98CE\u9669|\u98CE\u9669.*\u8BC4\u4F30|\u8BBE\u8BA1.*\u65B9\u6848|\u67B6\u6784|\u8FC1\u79FB|\u96C6\u6210|\\b(plan|planning|research|investigate|approach|proposal|architecture|risk|migration|integration)\\b|how (should|would|to)|do not (edit|modify|change)|don.t (edit|modify|change)|no code changes|without changing code"; then
-    echo "## mancode \u81EA\u52A8\u8DEF\u7531"
-    echo ""
-    echo "\u8FD9\u4E2A\u8BF7\u6C42\u662F\u89C4\u5212/\u8C03\u7814\u7C7B\u4EFB\u52A1\u3002\u4E0D\u8981\u76F4\u63A5\u8FDB\u5165 solo \u5B9E\u65BD\u3002"
-    echo "\u5FC5\u987B\u5148\u8C03\u7528 Skill tool\uFF0Cskill='man'\uFF0C\u628A\u7528\u6237\u539F\u59CB\u8BF7\u6C42\u4F5C\u4E3A task\uFF0C\u6267\u884C Scout \u8C03\u7814\u3001\u6F84\u6E05\u548C Plan Coach plan\u3002"
-    echo "\u7528\u6237\u53EA\u8981\u8BA1\u5212\u65F6\uFF0C\u5728 Step 4 \u9009\u62E9\u201C\u53EA\u8981\u8BA1\u5212\u201D\uFF1B\u4E0D\u8981\u5207\u5230\u53E6\u4E00\u4E2A\u547D\u4EE4\u3002"
-    echo ""
-fi
-
-# UI token \u4EC5\u5728 profile \u786E\u8BA4\u5B58\u5728 UI \u8D44\u4EA7\u4E14\u4EFB\u52A1\u660E\u786E\u6D89\u53CA UI \u65F6\u6CE8\u5165\u3002
-PROFILE_FILE="$PROJECT_ROOT/.mancode/project-profile.json"
-UI_ASSETS=""
-if [ -f "$PROFILE_FILE" ]; then
-    UI_ASSETS=$(json_get "uiAssets" "$PROFILE_FILE")
-fi
-if [ "$UI_ASSETS" = "detected" ] && echo "$USER_PROMPT" | grep -qiE "\\b(button|component|page|style|ui|design|layout|css|color|font|theme|card|input|modal|dialog|header|footer|sidebar|dropdown|tooltip|toast|avatar|badge)\\b|\u754C\u9762|\u9875\u9762|\u6309\u94AE|\u6837\u5F0F|\u989C\u8272|\u5B57\u4F53|\u5E03\u5C40|\u7EC4\u4EF6|\u5F39\u7A97|\u5BFC\u822A|\u5361\u7247|\u8F93\u5165\u6846|\u4E3B\u9898|\u7F8E\u5316|\u4F18\u5316.*\u754C\u9762|\u8C03\u6574.*\u6837\u5F0F"; then
-    if [ -f "$AESTHETICS_FILE" ]; then
-        MATCH_LEVEL=$(json_get "matchLevel" "$AESTHETICS_FILE")
-
-        if [ "$MATCH_LEVEL" = "high" ]; then
-            if [ "$HAS_JQ" = "1" ]; then
-            # \u63D0\u53D6\u6458\u8981 + cap\uFF08docs/07 \xA74.1\uFF1Acolors \u22648, fonts \u22644, \u603B < 800 tokens\uFF09
-            UI=$(jq -r '.uiLibrary // empty' "$AESTHETICS_FILE" 2>/dev/null)
-            DARK=$(jq -r '.darkMode // empty' "$AESTHETICS_FILE" 2>/dev/null)
-            MATCH=$(jq -r '.matchLevel // empty' "$AESTHETICS_FILE" 2>/dev/null)
-            COLORS=$(jq -r '.colors | to_entries | map(select(.key | test("^[A-Za-z0-9_-]{1,80}$"))) | .[0:8] | map("\\(.key)=\\(.value)") | join(", ")' "$AESTHETICS_FILE" 2>/dev/null)
-            FONTS=$(jq -r '.fonts | to_entries | map(select(.key | test("^[A-Za-z0-9_-]{1,80}$"))) | .[0:4] | map("\\(.key)=\\(.value | first)") | join(", ")' "$AESTHETICS_FILE" 2>/dev/null)
-            COMPONENTS=$(jq -r '(.components // []) | map(select(test("^[A-Z][A-Za-z0-9]{0,79}$"))) | .[0:8] | join(", ")' "$AESTHETICS_FILE" 2>/dev/null)
-            CSS_VARS=$(jq -r '(.cssVariables // {}) | to_entries | map(select(.key | test("^[A-Za-z0-9_-]{1,80}$"))) | .[0:8] | map("--\\(.key)=\\(.value)") | join(", ")' "$AESTHETICS_FILE" 2>/dev/null)
-
-            echo "## \u5BA1\u7F8E token \u6458\u8981"
-            [ -n "$UI" ] && echo "UI: $(sanitize "$UI")"
-            [ -n "$DARK" ] && echo "Dark: $(sanitize "$DARK")"
-            [ -n "$MATCH" ] && echo "Match: $(sanitize "$MATCH")"
-            [ -n "$COLORS" ] && echo "Colors (\u524D 8): $(sanitize "$COLORS")"
-            [ -n "$FONTS" ] && echo "Fonts (\u524D 4): $(sanitize "$FONTS")"
-            [ -n "$COMPONENTS" ] && echo "Components (\u524D 8): $(sanitize "$COMPONENTS")"
-            [ -n "$CSS_VARS" ] && echo "CSS variables (\u524D 8): $(sanitize "$CSS_VARS")"
-            echo "\u5B8C\u6574 token: .mancode/aesthetics/style-tokens.json"
-            echo ""
-        else
-            # \u65E0 jq: \u53EA\u8F93\u51FA\u6307\u9488\uFF08cap \u65E0\u6CD5\u4E25\u683C\u6267\u884C\uFF09
-            echo "## \u5BA1\u7F8E token"
-            echo "\u8BFB\u53D6 .mancode/aesthetics/style-tokens.json"
-            echo ""
-        fi
-    fi
-fi
-fi
+var USER_PROMPT_SUBMIT_HOOK = String.raw`#!/usr/bin/env node
+// .mancode/hooks/user-prompt-submit.mjs
+// mancode UserPromptSubmit hook - cross-platform prompt and style context
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const projectRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../..',
+);
+const mancodeDir = path.join(projectRoot, '.mancode');
+const state = readJson(path.join(mancodeDir, 'state.json')) || {};
+const profile = readJson(path.join(mancodeDir, 'project-profile.json')) || {};
+const mode = typeof state.currentMode === 'string' ? state.currentMode : '';
+const output = [];
+
+if (mode === 'solo') {
+  output.push(
+    '## 动手前，先想六个问题：',
+    '',
+    '1. **为什么做？**',
+    '   - 这个改动解决什么问题？',
+    '',
+    '2. **已经有什么？**',
+    '   - 项目里有没有类似的实现可以复用？',
+    '',
+    '3. **最少改多少？**',
+    '   - 能用一行解决吗？能复用现有代码吗？',
+    '',
+    '4. **能不能不拆新系统？**',
+    '   - 不新建文件或模块能完成吗？',
+    '',
+    '5. **非平凡逻辑怎样最小运行验证？**',
+    '',
+    '6. **有什么没把握的？**',
+    '   - 先自行查代码或文档，最多 2 次工具调用；仍不确定再问用户。',
+    '',
+  );
+}
+
+const rawInput = readFileSync(0, 'utf8');
+const userPrompt = readPrompt(rawInput);
+const planningPattern = /先(?:别|不要|看|看看|调研|分析|评估)|给.*方案|给.*计划|怎么.*做|如何.*做|怎么.*实现|如何.*实现|应该怎么|怎么.*拆|拆分|只给.*计划|不要.*改代码|别.*改代码|不要.*动代码|别.*动代码|评估.*风险|风险.*评估|设计.*方案|架构|迁移|集成|\b(?:plan|planning|research|investigate|approach|proposal|architecture|risk|migration|integration)\b|how (?:should|would|to)|do not (?:edit|modify|change)|don.t (?:edit|modify|change)|no code changes|without changing code/iu;
+
+if (mode === 'solo' && planningPattern.test(userPrompt)) {
+  output.push(
+    '## mancode 自动路由',
+    '',
+    '这个请求是规划/调研类任务。不要直接进入 solo 实施。',
+    "必须先调用 Skill tool，skill='man'，把用户原始请求作为 task，执行 Scout 调研、澄清和 Plan Coach plan。",
+    '用户只要计划时，在 Step 4 选择“只要计划”；不要切到另一个命令。',
+    '',
+  );
+}
+
+const uiPattern = /\b(?:button|component|page|style|ui|design|layout|css|color|font|theme|card|input|modal|dialog|header|footer|sidebar|dropdown|tooltip|toast|avatar|badge)\b|界面|页面|按钮|样式|颜色|字体|布局|组件|弹窗|导航|卡片|输入框|主题|美化|优化.*界面|调整.*样式/iu;
+
+if (profile.uiAssets === 'detected' && uiPattern.test(userPrompt)) {
+  appendAestheticSummary(
+    output,
+    readJson(path.join(mancodeDir, 'aesthetics', 'style-tokens.json')),
+  );
+}
+
+if (output.length > 0) console.log(output.join('\n'));
+
+function appendAestheticSummary(lines, tokens) {
+  if (!tokens || tokens.matchLevel !== 'high') return;
+
+  const colors = safeEntries(tokens.colors, 8).map(
+    ([key, value]) => key + '=' + String(value),
+  );
+  const fonts = safeEntries(tokens.fonts, 4)
+    .filter(([, value]) => Array.isArray(value) && value.length > 0)
+    .map(([key, value]) => key + '=' + String(value[0]));
+  const components = Array.isArray(tokens.components)
+    ? tokens.components
+        .filter(
+          (value) =>
+            typeof value === 'string' && /^[A-Z][A-Za-z0-9]{0,79}$/.test(value),
+        )
+        .slice(0, 8)
+    : [];
+  const cssVariables = safeEntries(tokens.cssVariables, 8).map(
+    ([key, value]) => '--' + key + '=' + String(value),
+  );
+
+  lines.push('## 审美 token 摘要');
+  appendValue(lines, 'UI', tokens.uiLibrary);
+  appendValue(lines, 'Dark', tokens.darkMode);
+  appendValue(lines, 'Match', tokens.matchLevel);
+  appendValue(lines, 'Colors (前 8)', colors.join(', '));
+  appendValue(lines, 'Fonts (前 4)', fonts.join(', '));
+  appendValue(lines, 'Components (前 8)', components.join(', '));
+  appendValue(lines, 'CSS variables (前 8)', cssVariables.join(', '));
+  lines.push('完整 token: .mancode/aesthetics/style-tokens.json', '');
+}
+
+function safeEntries(value, limit) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return [];
+  return Object.entries(value)
+    .filter(([key]) => /^[A-Za-z0-9_-]{1,80}$/.test(key))
+    .slice(0, limit);
+}
+
+function appendValue(lines, label, value) {
+  const clean = sanitize(value);
+  if (clean) lines.push(label + ': ' + clean);
+}
+
+function readPrompt(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return typeof parsed.prompt === 'string' && parsed.prompt
+      ? parsed.prompt
+      : input;
+  } catch {
+    return input;
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function sanitize(value) {
+  return String(value ?? '').replace(/[\r\n]/g, ' ').slice(0, 200);
+}
 `;
 var SOLO_SKILL = `# mancode \xB7 solo mode
 
@@ -1247,7 +1262,7 @@ ${spec.body}
 }
 
 // src/installers/common.ts
-import { chmod, mkdir as mkdir2, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
 
 // src/system/team-memory.ts
@@ -1371,6 +1386,7 @@ var DEFAULT_CONFIG = {
   platforms: ["claude-code"],
   cliCommand: "mancode",
   cliArgs: [],
+  teamMode: "auto",
   forceTeamMode: false,
   defaultStyle: null,
   hooks: {
@@ -1437,12 +1453,10 @@ async function readTextIfExists(filePath) {
   }
 }
 async function installHooks(hooksDir) {
-  const sessionStartDst = path2.join(hooksDir, "session-start.sh");
+  const sessionStartDst = path2.join(hooksDir, "session-start.mjs");
   await writeFile2(sessionStartDst, SESSION_START_HOOK, "utf-8");
-  await chmod(sessionStartDst, 493);
-  const userPromptDst = path2.join(hooksDir, "user-prompt-submit.sh");
+  const userPromptDst = path2.join(hooksDir, "user-prompt-submit.mjs");
   await writeFile2(userPromptDst, USER_PROMPT_SUBMIT_HOOK, "utf-8");
-  await chmod(userPromptDst, 493);
 }
 async function pathExists(p) {
   try {
@@ -1460,12 +1474,18 @@ function isNodeError(err) {
 var CLAUDE_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:claude-skill. Do not edit this marker. -->";
 var CLAUDE_AGENT_MANAGED_MARKER = "<!-- Managed by mancode:claude-agent. Do not edit this marker. -->";
 var MANCODE_HOOK_COMMANDS = [
+  'node ".mancode/hooks/session-start.mjs"',
+  'node ".mancode/hooks/user-prompt-submit.mjs"'
+];
+var LEGACY_MANCODE_HOOK_COMMANDS = [
   "bash .mancode/hooks/session-start.sh",
   "bash .mancode/hooks/user-prompt-submit.sh"
 ];
 function isGeneratedMancodeHookCommand(command) {
   const normalized = command.trim();
-  return MANCODE_HOOK_COMMANDS.some((item) => item === normalized);
+  return [...MANCODE_HOOK_COMMANDS, ...LEGACY_MANCODE_HOOK_COMMANDS].some(
+    (item) => item === normalized
+  );
 }
 var LEGACY_CLAUDE_SKILL_SETTINGS = {
   solo: ".claude/skills/mancode-solo.md",
@@ -1494,6 +1514,14 @@ async function installClaudeCode(projectRoot, options) {
     await installAgents(path3.join(claudeDir, "agents"), force);
   }
   await updateClaudeSettings(claudeDir, settings);
+  await removeLegacyHookFiles(projectRoot);
+}
+async function removeLegacyHookFiles(projectRoot) {
+  const hooksDir = path3.join(projectRoot, ".mancode", "hooks");
+  await Promise.all([
+    rm(path3.join(hooksDir, "session-start.sh"), { force: true }),
+    rm(path3.join(hooksDir, "user-prompt-submit.sh"), { force: true })
+  ]);
 }
 async function installSoloSkill(skillsDir, force) {
   await installProjectSkill(
@@ -1747,100 +1775,10 @@ function isNodeError2(err) {
   return err instanceof Error && "code" in err;
 }
 
-// src/installers/codex.ts
-import { writeFile as writeFile5 } from "fs/promises";
+// src/installers/cursor.ts
+import { mkdir as mkdir5, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "fs/promises";
 import path6 from "path";
 
-// src/installers/managed-block.ts
-var DEFAULT_MANCODE_START_MARKER = "<!-- mancode:start -->";
-var DEFAULT_MANCODE_END_MARKER = "<!-- mancode:end -->";
-function removeManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
-  const start = findMarkerLine(existing, startMarker);
-  const end = findMarkerLine(existing, endMarker);
-  if (start === null && end === null) return existing;
-  if (start === null || end === null) return existing;
-  if (end.start < start.start) return existing;
-  const before = existing.slice(0, start.start);
-  const after = existing.slice(end.end);
-  const merged = `${before}${after}`;
-  return cleanUpOrphanedNewlines(merged);
-}
-function hasManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
-  const start = findMarkerLine(existing, startMarker);
-  const end = findMarkerLine(existing, endMarker);
-  return start !== null && end !== null && end.start > start.start;
-}
-function cleanUpOrphanedNewlines(content) {
-  const trimmed = content.replace(/\n{3,}/gu, "\n\n").replace(/\n+$/u, "\n");
-  return trimmed || "";
-}
-function replaceManagedBlock(existing, block, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
-  const normalizedBlock = normalizeManagedBlock(block, startMarker, endMarker);
-  const start = findMarkerLine(existing, startMarker);
-  const end = findMarkerLine(existing, endMarker);
-  if (start === null !== (end === null)) {
-    throw new Error("managed block is malformed: missing start or end marker");
-  }
-  if (start === null && end === null) {
-    const trimmedExisting = trimTrailingNewlines(existing);
-    if (!trimmedExisting) return `${normalizedBlock}
-`;
-    return `${trimmedExisting}
-
-${normalizedBlock}
-`;
-  }
-  if (!start || !end) {
-    throw new Error("managed block is malformed: missing start or end marker");
-  }
-  if (end.start < start.start) {
-    throw new Error("managed block is malformed: end marker precedes start");
-  }
-  return `${existing.slice(0, start.start)}${normalizedBlock}${existing.slice(
-    end.end
-  )}`;
-}
-function normalizeManagedBlock(block, startMarker, endMarker) {
-  const trimmedBlock = block.trim();
-  const hasStart = trimmedBlock.startsWith(startMarker);
-  const hasEnd = trimmedBlock.endsWith(endMarker);
-  if (hasStart && hasEnd) return trimmedBlock;
-  if (hasStart || hasEnd) {
-    throw new Error("managed block content includes only one marker");
-  }
-  return `${startMarker}
-${trimmedBlock}
-${endMarker}`;
-}
-function trimTrailingNewlines(value) {
-  return value.replace(/\n+$/u, "");
-}
-function findMarkerLine(content, marker) {
-  let offset = 0;
-  let inFence = null;
-  for (const lineWithBreak of content.matchAll(/[^\n]*(?:\n|$)/gu)) {
-    const rawLine = lineWithBreak[0];
-    if (!rawLine) break;
-    const line = rawLine.replace(/\n$/u, "").replace(/\r$/u, "");
-    const fence = line.match(/^(`{3,}|~{3,})/u)?.[1];
-    if (fence) {
-      const char = fence[0];
-      if (!inFence) {
-        inFence = { char, length: fence.length };
-      } else if (inFence.char === char && fence.length >= inFence.length) {
-        inFence = null;
-      }
-    } else if (!inFence && line === marker) {
-      return {
-        start: offset,
-        end: offset + marker.length
-      };
-    }
-    offset += rawLine.length;
-  }
-  return null;
-}
-
 // src/installers/mode-skills.ts
 import { mkdir as mkdir4, readFile as readFile4, readdir as readdir2, rm as rm2, writeFile as writeFile4 } from "fs/promises";
 import path4 from "path";
@@ -2426,99 +2364,7 @@ function formatValue(value) {
   return "";
 }
 
-// src/installers/codex.ts
-async function installCodex(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const agentsPath = path6.join(projectRoot, "AGENTS.md");
-  const existing = await readTextIfExists(agentsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
-    platform: "codex",
-    displayName: "Codex (ChatGPT desktop/CLI)",
-    capabilities: {
-      slashCommands: "partial",
-      subagents: false,
-      hooks: false,
-      skills: "agents-skills"
-    },
-    minimal: options.minimal,
-    techStack: options.techStack,
-    uiLibrary: options.uiLibrary,
-    projectProfile: options.projectProfile
-  });
-  const block = [
-    DEFAULT_MANCODE_START_MARKER,
-    "<!-- Managed by mancode. Do not edit this block manually. -->",
-    "",
-    "# mancode Configuration",
-    "",
-    sharedContent.trim(),
-    DEFAULT_MANCODE_END_MARKER
-  ].join("\n");
-  await writeFile5(agentsPath, replaceManagedBlock(existing, block), "utf-8");
-  await installCodexSkills(projectRoot, options.minimal ?? false);
-}
-
-// src/installers/copilot.ts
-import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import path7 from "path";
-async function installCopilot(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const githubDir = path7.join(projectRoot, ".github");
-  await mkdir5(githubDir, { recursive: true });
-  const instructionsPath = path7.join(githubDir, "copilot-instructions.md");
-  const existing = await readTextIfExists(instructionsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
-    platform: "copilot",
-    displayName: "GitHub Copilot",
-    capabilities: {
-      slashCommands: "none",
-      subagents: false,
-      hooks: false,
-      skills: "instructions"
-    },
-    minimal: true,
-    techStack: options.techStack,
-    uiLibrary: options.uiLibrary,
-    projectProfile: options.projectProfile
-  });
-  const sections = [
-    DEFAULT_MANCODE_START_MARKER,
-    "<!-- Managed by mancode. Do not edit this block manually. -->",
-    "",
-    "# mancode for GitHub Copilot",
-    "",
-    sharedContent.trim()
-  ];
-  if (!options.minimal) {
-    sections.push("", renderCopilotPromptConventions());
-  }
-  sections.push(DEFAULT_MANCODE_END_MARKER);
-  await writeFile6(
-    instructionsPath,
-    replaceManagedBlock(existing, sections.join("\n")),
-    "utf-8"
-  );
-  await installCopilotPrompts(projectRoot, options.minimal ?? false);
-}
-function renderCopilotPromptConventions() {
-  return [
-    "## mancode Prompt Conventions",
-    "",
-    "GitHub Copilot does not provide native mancode slash commands, hooks, or isolated subagents. Treat these names as user prompt conventions:",
-    "",
-    "- man: use progressive research, planning, implementation, verification, and bounded risk-based review.",
-    "- mamba: diagnose bugs and validate real user flows or regressions.",
-    "- manteam: read team memory and write handoff-friendly summaries.",
-    "- manps: prefer `mancode manps [area]` before cleanup.",
-    "- mansolo: exit any active mode and return to default solo behavior.",
-    "",
-    "These correspond to prompt files in `.github/prompts/`. Select the matching prompt to activate a mode."
-  ].join("\n");
-}
-
 // src/installers/cursor.ts
-import { mkdir as mkdir6, readFile as readFile6, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import path8 from "path";
 var MANCODE_CURSOR_CORE_RULE_FILES = [
   "mancode-context.mdc",
   "mancode-practice.mdc",
@@ -2537,8 +2383,8 @@ var MANCODE_CURSOR_RULE_FILES = [
 ];
 async function installCursor(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const rulesDir = path8.join(projectRoot, ".cursor", "rules");
-  await mkdir6(rulesDir, { recursive: true });
+  const rulesDir = path6.join(projectRoot, ".cursor", "rules");
+  await mkdir5(rulesDir, { recursive: true });
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "cursor",
     displayName: "Cursor",
@@ -2626,14 +2472,14 @@ async function writeRule(rulesDir, fileName, description, alwaysApply, body) {
 
 ${body.trim()}
 `;
-  const rulePath = path8.join(rulesDir, fileName);
+  const rulePath = path6.join(rulesDir, fileName);
   const existing = await readTextIfExists4(rulePath);
   if (existing !== null && !isGeneratedCursorRule(existing, fileName)) {
     throw new Error(
       `refusing to overwrite user-authored Cursor rule: ${rulePath}`
     );
   }
-  await writeFile7(
+  await writeFile5(
     rulePath,
     content.replace("---\n\n", `---
 
@@ -2647,17 +2493,17 @@ async function removeAdvancedRules(rulesDir) {
   for (const fileName of MANCODE_CURSOR_ADVANCED_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
-  await removeLegacyCursorRules(path8.dirname(path8.dirname(rulesDir)));
+  await removeLegacyCursorRules(path6.dirname(path6.dirname(rulesDir)));
 }
 async function removeCursorGeneratedRules(projectRoot) {
-  const rulesDir = path8.join(projectRoot, ".cursor", "rules");
+  const rulesDir = path6.join(projectRoot, ".cursor", "rules");
   for (const fileName of MANCODE_CURSOR_RULE_FILES) {
     await removeGeneratedCursorRule(rulesDir, fileName);
   }
   await removeLegacyCursorRules(projectRoot);
 }
 async function removeLegacyCursorRules(projectRoot) {
-  const legacyPath = path8.join(
+  const legacyPath = path6.join(
     projectRoot,
     ".cursor",
     "rules",
@@ -2672,7 +2518,7 @@ async function removeLegacyCursorRules(projectRoot) {
   }
 }
 async function removeGeneratedCursorRule(rulesDir, fileName) {
-  const rulePath = path8.join(rulesDir, fileName);
+  const rulePath = path6.join(rulesDir, fileName);
   const content = await readTextIfExists4(rulePath);
   if (content && isGeneratedCursorRule(content, fileName)) {
     await rm3(rulePath, { force: true });
@@ -2742,16 +2588,200 @@ function renderManpsRule() {
   return renderModeSkill("manps", "/");
 }
 
-// src/installers/zcode.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import path9 from "path";
-var ZCODE_MANCODE_START_MARKER = "<!-- mancode:zcode:start -->";
-var ZCODE_MANCODE_END_MARKER = "<!-- mancode:zcode:end -->";
-async function installZcode(projectRoot, options) {
-  await installMancodeCore(projectRoot);
-  const agentsPath = path9.join(projectRoot, "AGENTS.md");
-  const existing = await readTextIfExists(agentsPath);
-  const sharedContent = await generateSharedContent(projectRoot, {
+// src/installers/codex.ts
+import { writeFile as writeFile6 } from "fs/promises";
+import path7 from "path";
+
+// src/installers/managed-block.ts
+var DEFAULT_MANCODE_START_MARKER = "<!-- mancode:start -->";
+var DEFAULT_MANCODE_END_MARKER = "<!-- mancode:end -->";
+function removeManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  if (start === null && end === null) return existing;
+  if (start === null || end === null) return existing;
+  if (end.start < start.start) return existing;
+  const before = existing.slice(0, start.start);
+  const after = existing.slice(end.end);
+  const merged = `${before}${after}`;
+  return cleanUpOrphanedNewlines(merged);
+}
+function hasManagedBlock(existing, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  return start !== null && end !== null && end.start > start.start;
+}
+function cleanUpOrphanedNewlines(content) {
+  const trimmed = content.replace(/\n{3,}/gu, "\n\n").replace(/\n+$/u, "\n");
+  return trimmed || "";
+}
+function replaceManagedBlock(existing, block, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
+  const normalizedBlock = normalizeManagedBlock(block, startMarker, endMarker);
+  const start = findMarkerLine(existing, startMarker);
+  const end = findMarkerLine(existing, endMarker);
+  if (start === null !== (end === null)) {
+    throw new Error("managed block is malformed: missing start or end marker");
+  }
+  if (start === null && end === null) {
+    const trimmedExisting = trimTrailingNewlines(existing);
+    if (!trimmedExisting) return `${normalizedBlock}
+`;
+    return `${trimmedExisting}
+
+${normalizedBlock}
+`;
+  }
+  if (!start || !end) {
+    throw new Error("managed block is malformed: missing start or end marker");
+  }
+  if (end.start < start.start) {
+    throw new Error("managed block is malformed: end marker precedes start");
+  }
+  return `${existing.slice(0, start.start)}${normalizedBlock}${existing.slice(
+    end.end
+  )}`;
+}
+function normalizeManagedBlock(block, startMarker, endMarker) {
+  const trimmedBlock = block.trim();
+  const hasStart = trimmedBlock.startsWith(startMarker);
+  const hasEnd = trimmedBlock.endsWith(endMarker);
+  if (hasStart && hasEnd) return trimmedBlock;
+  if (hasStart || hasEnd) {
+    throw new Error("managed block content includes only one marker");
+  }
+  return `${startMarker}
+${trimmedBlock}
+${endMarker}`;
+}
+function trimTrailingNewlines(value) {
+  return value.replace(/\n+$/u, "");
+}
+function findMarkerLine(content, marker) {
+  let offset = 0;
+  let inFence = null;
+  for (const lineWithBreak of content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+    const rawLine = lineWithBreak[0];
+    if (!rawLine) break;
+    const line = rawLine.replace(/\n$/u, "").replace(/\r$/u, "");
+    const fence = line.match(/^(`{3,}|~{3,})/u)?.[1];
+    if (fence) {
+      const char = fence[0];
+      if (!inFence) {
+        inFence = { char, length: fence.length };
+      } else if (inFence.char === char && fence.length >= inFence.length) {
+        inFence = null;
+      }
+    } else if (!inFence && line === marker) {
+      return {
+        start: offset,
+        end: offset + marker.length
+      };
+    }
+    offset += rawLine.length;
+  }
+  return null;
+}
+
+// src/installers/codex.ts
+async function installCodex(projectRoot, options) {
+  await installMancodeCore(projectRoot);
+  const agentsPath = path7.join(projectRoot, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
+    platform: "codex",
+    displayName: "Codex (ChatGPT desktop/CLI)",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: false,
+      hooks: false,
+      skills: "agents-skills"
+    },
+    minimal: options.minimal,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const block = [
+    DEFAULT_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode Configuration",
+    "",
+    sharedContent.trim(),
+    DEFAULT_MANCODE_END_MARKER
+  ].join("\n");
+  await writeFile6(agentsPath, replaceManagedBlock(existing, block), "utf-8");
+  await installCodexSkills(projectRoot, options.minimal ?? false);
+}
+
+// src/installers/copilot.ts
+import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
+import path8 from "path";
+async function installCopilot(projectRoot, options) {
+  await installMancodeCore(projectRoot);
+  const githubDir = path8.join(projectRoot, ".github");
+  await mkdir6(githubDir, { recursive: true });
+  const instructionsPath = path8.join(githubDir, "copilot-instructions.md");
+  const existing = await readTextIfExists(instructionsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
+    platform: "copilot",
+    displayName: "GitHub Copilot",
+    capabilities: {
+      slashCommands: "none",
+      subagents: false,
+      hooks: false,
+      skills: "instructions"
+    },
+    minimal: true,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const sections = [
+    DEFAULT_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode for GitHub Copilot",
+    "",
+    sharedContent.trim()
+  ];
+  if (!options.minimal) {
+    sections.push("", renderCopilotPromptConventions());
+  }
+  sections.push(DEFAULT_MANCODE_END_MARKER);
+  await writeFile7(
+    instructionsPath,
+    replaceManagedBlock(existing, sections.join("\n")),
+    "utf-8"
+  );
+  await installCopilotPrompts(projectRoot, options.minimal ?? false);
+}
+function renderCopilotPromptConventions() {
+  return [
+    "## mancode Prompt Conventions",
+    "",
+    "GitHub Copilot does not provide native mancode slash commands, hooks, or isolated subagents. Treat these names as user prompt conventions:",
+    "",
+    "- man: use progressive research, planning, implementation, verification, and bounded risk-based review.",
+    "- mamba: diagnose bugs and validate real user flows or regressions.",
+    "- manteam: read team memory and write handoff-friendly summaries.",
+    "- manps: prefer `mancode manps [area]` before cleanup.",
+    "- mansolo: exit any active mode and return to default solo behavior.",
+    "",
+    "These correspond to prompt files in `.github/prompts/`. Select the matching prompt to activate a mode."
+  ].join("\n");
+}
+
+// src/installers/zcode.ts
+import { writeFile as writeFile8 } from "fs/promises";
+import path9 from "path";
+var ZCODE_MANCODE_START_MARKER = "<!-- mancode:zcode:start -->";
+var ZCODE_MANCODE_END_MARKER = "<!-- mancode:zcode:end -->";
+async function installZcode(projectRoot, options) {
+  await installMancodeCore(projectRoot);
+  const agentsPath = path9.join(projectRoot, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const sharedContent = await generateSharedContent(projectRoot, {
     platform: "zcode",
     displayName: "ZCode",
     capabilities: {
@@ -2860,11 +2890,12 @@ function isPlatformName(platform) {
 }
 
 // src/system/detect-team.ts
-import { exec } from "child_process";
+import { execFile } from "child_process";
+import { access as access2 } from "fs/promises";
 import path10 from "path";
 import process2 from "process";
 import { promisify } from "util";
-var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
 var NO_TEAM = {
   isTeam: false,
   contributors: 1,
@@ -2872,106 +2903,186 @@ var NO_TEAM = {
   hasRemote: false
 };
 var REMOTE_PATTERN = /github\.com|gitlab\.com|bitbucket\.org/;
-var EXEC_OPTS = {
-  shell: "/bin/bash",
-  encoding: "utf-8",
-  env: {
-    ...process2.env,
-    GIT_PAGER: "cat",
-    PAGER: "cat",
-    GIT_TERMINAL_PROMPT: "0"
-  }
+var GIT_ENV = {
+  ...process2.env,
+  GIT_PAGER: "cat",
+  PAGER: "cat",
+  GIT_TERMINAL_PROMPT: "0"
 };
 async function detectTeamStatus(projectRoot) {
-  const gitDir = path10.join(projectRoot, ".git");
   try {
-    await execAsync("git rev-parse --is-inside-work-tree", {
-      cwd: projectRoot,
-      ...EXEC_OPTS
-    });
-  } catch {
-    return NO_TEAM;
-  }
-  try {
-    await execAsync(`test -d ${JSON.stringify(gitDir)}`, {
-      cwd: projectRoot,
-      ...EXEC_OPTS
-    });
+    await access2(path10.join(projectRoot, ".git"));
+    const inside = await runGit(projectRoot, [
+      "rev-parse",
+      "--is-inside-work-tree"
+    ]);
+    if (inside.trim() !== "true") return NO_TEAM;
+    const [allEmails, recentEmails, remotes] = await Promise.all([
+      runGit(projectRoot, ["log", "--all", "--format=%ae"]),
+      runGit(projectRoot, ["log", "--since=30 days ago", "--format=%ae"]),
+      runGit(projectRoot, ["remote", "-v"])
+    ]);
+    const contributors = countUniqueLines(allEmails);
+    const recentActive = countUniqueLines(recentEmails);
+    const hasRemote = REMOTE_PATTERN.test(remotes);
+    return {
+      isTeam: contributors > 1 && hasRemote && recentActive > 1,
+      contributors: contributors || 1,
+      recentActive: recentActive || 1,
+      hasRemote
+    };
   } catch {
     return NO_TEAM;
   }
-  const contributors = await countUniqueEmails(
-    "git log --all --format='%ae'",
-    projectRoot
-  );
-  const recentActive = await countUniqueEmails(
-    "git log --since='30 days ago' --format='%ae'",
-    projectRoot
-  );
-  const hasRemote = await checkRemote(projectRoot);
-  const safeContributors = Number.isFinite(contributors) ? contributors : 0;
-  const safeRecent = Number.isFinite(recentActive) ? recentActive : 0;
-  const isTeam = safeContributors > 1 && hasRemote && safeRecent > 1;
-  return {
-    isTeam,
-    contributors: safeContributors || 1,
-    recentActive: safeRecent || 1,
-    hasRemote
-  };
 }
-async function countUniqueEmails(command, cwd) {
-  try {
-    const { stdout } = await execAsync(
-      `${command} 2>/dev/null | sort -u | grep -c . || true`,
-      { cwd, ...EXEC_OPTS }
-    );
-    const n = Number.parseInt(stdout.trim(), 10);
-    return Number.isFinite(n) ? n : 0;
-  } catch {
-    return 0;
-  }
+async function runGit(cwd, args) {
+  const { stdout: stdout2 } = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    env: GIT_ENV,
+    windowsHide: true
+  });
+  return stdout2;
 }
-async function checkRemote(cwd) {
+function countUniqueLines(output) {
+  return new Set(
+    output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  ).size;
+}
+
+// src/system/detect.ts
+import { execFile as execFile2 } from "child_process";
+import process3 from "process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function detectSystemDeps(env = process3.env) {
   try {
-    const { stdout } = await execAsync("git remote -v 2>/dev/null || true", {
-      cwd,
-      ...EXEC_OPTS
+    await execFileAsync2("git", ["--version"], {
+      env,
+      windowsHide: true
     });
-    return REMOTE_PATTERN.test(stdout);
+    return { git: true };
   } catch {
-    return false;
+    return { git: false };
   }
 }
 
-// src/system/detect.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-async function detectSystemDeps() {
-  const ALLOWED_COMMANDS = /* @__PURE__ */ new Set(["bash", "git", "jq", "node"]);
-  const check = async (cmd) => {
-    if (!ALLOWED_COMMANDS.has(cmd)) {
-      throw new Error(`Unsupported dependency check: ${cmd}`);
-    }
+// src/system/init-onboarding.ts
+import { promises as fs } from "fs";
+import path11 from "path";
+import process4 from "process";
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+var ALL_PLATFORMS = Object.keys(PLATFORM_INSTALLERS);
+function detectInitLocale(override, environment = process4.env, systemLocale = Intl.DateTimeFormat().resolvedOptions().locale) {
+  if (override) return parseLocale(override);
+  const environmentLocale = environment.LC_ALL ?? environment.LC_MESSAGES ?? environment.LANG;
+  return parseLocale(environmentLocale) ?? parseLocale(systemLocale) ?? "en";
+}
+function parseLocale(value) {
+  if (!value) return null;
+  const normalized = value.toLowerCase().replace("_", "-");
+  if (normalized === "zh" || normalized.startsWith("zh-")) return "zh-CN";
+  if (normalized === "en" || normalized.startsWith("en-")) return "en";
+  return null;
+}
+function parsePlatformSelection(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all" || normalized === "\u5168\u90E8") return [...ALL_PLATFORMS];
+  const choices = normalized.split(",").map((item) => item.trim()).filter(Boolean);
+  if (choices.length === 0) return null;
+  if (!choices.every((item) => item in PLATFORM_INSTALLERS)) {
+    return null;
+  }
+  return [...new Set(choices)];
+}
+async function detectPlatformHints(rootDir, environment = process4.env) {
+  const hints = /* @__PURE__ */ new Set();
+  if (environment.CLAUDECODE || environment.CLAUDE_CODE)
+    hints.add("claude-code");
+  if (environment.CODEX_HOME) hints.add("codex");
+  if (environment.CURSOR_TRACE_ID) hints.add("cursor");
+  if (environment.COPILOT_AGENT || environment.GITHUB_COPILOT)
+    hints.add("copilot");
+  const exists = async (relative) => {
     try {
-      await execAsync2(`command -v ${cmd}`, { shell: "/bin/bash" });
+      await fs.access(path11.join(rootDir, relative));
       return true;
     } catch {
       return false;
     }
   };
-  const [bash, git, jq, node] = await Promise.all([
-    check("bash"),
-    check("git"),
-    check("jq"),
-    check("node")
-  ]);
-  return { bash, git, jq, node };
+  if (await exists(".claude")) hints.add("claude-code");
+  if (await exists(".cursor")) hints.add("cursor");
+  if (await exists(".github/copilot-instructions.md")) hints.add("copilot");
+  return ALL_PLATFORMS.filter((platform) => hints.has(platform));
+}
+function createTerminalPrompter() {
+  return {
+    async confirmGenericProject({ rootDir, locale }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        if (locale === "zh-CN") {
+          console.log("\u5F53\u524D\u76EE\u5F55\u6CA1\u6709\u8BC6\u522B\u5230\u9879\u76EE\u6587\u4EF6\u3002");
+          console.log(`\u76EE\u5F55\uFF1A${rootDir}`);
+          console.log("\u8FD9\u662F\u4E00\u4E2A\u65B0\u9879\u76EE\u5417\uFF1F");
+          console.log("[y] \u521D\u59CB\u5316\u4E3A\u901A\u7528\u9879\u76EE");
+          console.log("[n] \u9000\u51FA");
+          const answer2 = await rl.question("\u8BF7\u9009\u62E9 [y/N]: ");
+          return ["y", "yes", "\u662F"].includes(answer2.trim().toLowerCase());
+        }
+        console.log("No project files were detected in the current directory.");
+        console.log(`Directory: ${rootDir}`);
+        console.log("Is this a new project?");
+        console.log("[y] Initialize as a generic project");
+        console.log("[n] Exit");
+        const answer = await rl.question("Choose [y/N]: ");
+        return ["y", "yes"].includes(answer.trim().toLowerCase());
+      } finally {
+        rl.close();
+      }
+    },
+    async selectPlatforms({ locale, detected }) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        const names = ALL_PLATFORMS.map((platform, index) => {
+          const suffix = detected.includes(platform) ? locale === "zh-CN" ? "\uFF08\u5DF2\u68C0\u6D4B\u5230\uFF09" : " (detected)" : "";
+          return `${index + 1}. ${PLATFORM_INSTALLERS[platform].displayName}${suffix}`;
+        });
+        console.log(
+          locale === "zh-CN" ? "\n\u9009\u62E9\u8981\u521D\u59CB\u5316\u7684\u5E73\u53F0\uFF1A" : "\nChoose platforms to initialize:"
+        );
+        console.log(names.join("\n"));
+        console.log(locale === "zh-CN" ? "a. \u5168\u90E8\u5E73\u53F0" : "a. All platforms");
+        console.log(
+          locale === "zh-CN" ? "\u53EF\u8F93\u5165\u7F16\u53F7\uFF08\u4F8B\u5982 1,3\uFF09\u6216 a\u3002" : "Enter numbers (for example 1,3) or a."
+        );
+        const answer = (await rl.question(locale === "zh-CN" ? "\u9009\u62E9: " : "Selection: ")).trim().toLowerCase();
+        if (answer === "a" || answer === "all" || answer === "\u5168\u90E8")
+          return [...ALL_PLATFORMS];
+        const indexes = answer.split(",").map((item) => Number(item.trim()));
+        if (!indexes.length || indexes.some(
+          (index) => !Number.isInteger(index) || index < 1 || index > ALL_PLATFORMS.length
+        )) {
+          return null;
+        }
+        const selected = [];
+        for (const index of indexes) {
+          const platform = ALL_PLATFORMS[index - 1];
+          if (!platform) return null;
+          selected.push(platform);
+        }
+        return [...new Set(selected)];
+      } finally {
+        rl.close();
+      }
+    }
+  };
 }
 
 // src/system/project-profile.ts
 import { readFile as readFile7, readdir as readdir3, stat as stat2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var PROJECT_MANIFESTS = [
   "package.json",
   "pyproject.toml",
@@ -3004,12 +3115,12 @@ async function detectProjectProfile(projectRoot) {
     "data",
     "notebooks"
   ]);
-  const packageJson = await readJson2(path11.join(projectRoot, "package.json"));
+  const packageJson = await readJson2(path12.join(projectRoot, "package.json"));
   const [pubspec, pythonManifests] = await Promise.all([
-    readText(path11.join(projectRoot, "pubspec.yaml")),
+    readText(path12.join(projectRoot, "pubspec.yaml")),
     Promise.all([
-      readText(path11.join(projectRoot, "pyproject.toml")),
-      readText(path11.join(projectRoot, "requirements.txt"))
+      readText(path12.join(projectRoot, "pyproject.toml")),
+      readText(path12.join(projectRoot, "requirements.txt"))
     ]).then((parts) => parts.filter(Boolean).join("\n"))
   ]);
   const deps = Object.keys({
@@ -3018,7 +3129,7 @@ async function detectProjectProfile(projectRoot) {
     ...packageJson?.peerDependencies
   });
   const flutter = isFlutterProject(pubspec);
-  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path11.join(projectRoot, "src", "components", "ui"));
+  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path12.join(projectRoot, "src", "components", "ui"));
   const languages = inferLanguages(manifests, entries);
   const frameworks = inferFrameworks(
     deps,
@@ -3061,7 +3172,7 @@ async function existingDirs(root, candidates) {
   const found = [];
   for (const candidate of candidates) {
     try {
-      if ((await stat2(path11.join(root, candidate))).isDirectory())
+      if ((await stat2(path12.join(root, candidate))).isDirectory())
         found.push(candidate);
     } catch {
     }
@@ -3235,8 +3346,8 @@ function isFlutterProject(pubspec) {
 }
 
 // src/system/scan-aesthetics.ts
-import { promises as fs } from "fs";
-import path12 from "path";
+import { promises as fs2 } from "fs";
+import path13 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null) {
@@ -3249,7 +3360,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   const cssScan = await scanCssVariables(projectRoot);
   if (configResult) {
     sourceFiles.push(configResult.relPath);
-    const content = await fs.readFile(configResult.absPath, "utf-8");
+    const content = await fs2.readFile(configResult.absPath, "utf-8");
     const inspectableContent = stripJsComments(content);
     const themeBlock = findKeyBlock(inspectableContent, "theme");
     if (themeBlock) {
@@ -3272,7 +3383,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists2(path12.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists2(path13.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -3297,7 +3408,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path12.join(projectRoot, name);
+    const absPath = path13.join(projectRoot, name);
     if (await pathExists2(absPath)) {
       return { absPath, relPath: name };
     }
@@ -3524,7 +3635,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path12.join(projectRoot, relRoot);
+    const absRoot = path13.join(projectRoot, relRoot);
     if (!await pathExists2(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -3538,16 +3649,16 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   let fileCount = visitedFiles;
   let entries;
   try {
-    entries = await fs.readdir(dir);
+    entries = await fs2.readdir(dir);
   } catch {
     return fileCount;
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path12.join(dir, entry);
+    const abs = path13.join(dir, entry);
     let info;
     try {
-      info = await fs.lstat(abs);
+      info = await fs2.lstat(abs);
     } catch {
       continue;
     }
@@ -3565,7 +3676,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path12.basename(dir);
+      base = path13.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -3587,9 +3698,9 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path12.join(projectRoot, relPath);
+    const absPath = path13.join(projectRoot, relPath);
     if (!await pathExists2(absPath)) continue;
-    const content = await fs.readFile(absPath, "utf-8");
+    const content = await fs2.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
     if (Object.keys(found).length === 0) continue;
     Object.assign(variables, found);
@@ -3632,8 +3743,8 @@ function toPascalCase(value) {
 }
 async function hasTailwindDep(projectRoot) {
   try {
-    const raw = await fs.readFile(
-      path12.join(projectRoot, "package.json"),
+    const raw = await fs2.readFile(
+      path13.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -3649,7 +3760,7 @@ function escapeRegex(s) {
 }
 async function pathExists2(p) {
   try {
-    await fs.access(p);
+    await fs2.access(p);
     return true;
   } catch {
     return false;
@@ -3660,73 +3771,104 @@ async function pathExists2(p) {
 var EXIT_OK = 0;
 var EXIT_ALREADY_INITIALIZED = 1;
 var EXIT_NOT_A_PROJECT_DIR = 2;
+var EXIT_USER_CANCEL = 3;
 var EXIT_INIT_FAILED = 5;
 var DEFAULT_INIT_PLATFORM = "claude-code";
-async function init(rootDir = process3.cwd(), options = {}) {
-  const mancodeDir = path13.join(rootDir, ".mancode");
-  const stateFile = path13.join(mancodeDir, "state.json");
+async function init(rootDir = process5.cwd(), options = {}) {
+  const mancodeDir = path14.join(rootDir, ".mancode");
+  const stateFile = path14.join(mancodeDir, "state.json");
   const wasInitialized = await pathExists3(stateFile);
-  let reinstallSnapshots = [];
+  let mutationSnapshots = [];
+  let directorySnapshots = [];
+  const locale = detectInitLocale(options.lang);
+  if (!locale) {
+    console.error(`\u2717  Unsupported init language: ${options.lang}`);
+    console.error("   Supported values: zh-CN, en");
+    return EXIT_INIT_FAILED;
+  }
   if (wasInitialized) {
     if (!options.force) {
-      console.log("\u2139\uFE0F  mancode already initialized.");
+      console.log(
+        localize(
+          locale,
+          "\u2139\uFE0F  mancode \u5DF2\u7ECF\u521D\u59CB\u5316\u3002",
+          "\u2139\uFE0F  mancode already initialized."
+        )
+      );
       console.log(`   ${stateFile}`);
-      console.log("   Run `mancode init --force` to reinstall.");
+      console.log(
+        localize(
+          locale,
+          "   \u8FD0\u884C `mancode init --force` \u91CD\u65B0\u5B89\u88C5\u3002",
+          "   Run `mancode init --force` to reinstall."
+        )
+      );
       return EXIT_ALREADY_INITIALIZED;
     }
-    try {
-      reinstallSnapshots = await snapshotFiles([
-        stateFile,
-        path13.join(mancodeDir, "config.json"),
-        path13.join(mancodeDir, "project-profile.json"),
-        path13.join(mancodeDir, "aesthetics", "style-tokens.json")
-      ]);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`\u2717  Cannot snapshot existing mancode state: ${message}`);
-      return EXIT_INIT_FAILED;
-    }
-    console.log("\u26A0\uFE0F  Reinstalling with --force...");
+    console.log(
+      localize(
+        locale,
+        "\u26A0\uFE0F  \u6B63\u5728\u4F7F\u7528 --force \u91CD\u65B0\u5B89\u88C5...",
+        "\u26A0\uFE0F  Reinstalling with --force..."
+      )
+    );
   }
   if (!await pathExists3(rootDir)) {
-    console.error(`\u2717  Target directory does not exist: ${rootDir}`);
-    return EXIT_NOT_A_PROJECT_DIR;
-  }
-  const isGitRepo = await pathExists3(path13.join(rootDir, ".git"));
-  const hasManifest = await Promise.any(
-    PROJECT_MANIFESTS.map(async (name) => {
-      if (await pathExists3(path13.join(rootDir, name))) return true;
-      throw new Error("manifest missing");
-    })
-  ).catch(() => false);
-  if (!isGitRepo && !hasManifest) {
-    console.error(`\u2717  Not a project directory: ${rootDir}`);
-    console.error("   (No .git or recognized project manifest found)");
-    console.error("");
     console.error(
-      "   Run mancode init in a git repository or a recognized project directory."
+      localize(
+        locale,
+        `\u2717  \u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${rootDir}`,
+        `\u2717  Target directory does not exist: ${rootDir}`
+      )
     );
     return EXIT_NOT_A_PROJECT_DIR;
   }
-  try {
-    console.log("\u2713  \u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...");
-    const deps = await detectSystemDeps();
-    if (!deps.bash || !deps.git) {
-      console.error("\u2717  Missing required dependencies:");
-      if (!deps.bash) console.error("   - bash (required)");
-      if (!deps.git) console.error("   - git (required)");
-      console.error("");
-      console.error("   Install them and try again.");
+  const isGitRepo = await pathExists3(path14.join(rootDir, ".git"));
+  const hasManifest = await hasProjectManifest(rootDir);
+  let isGenericProject = false;
+  if (!isGitRepo && !hasManifest) {
+    const genericSafety = await canInitializeGenericProject(rootDir);
+    if (!genericSafety.ok) {
+      printNotProjectDirectory(rootDir, locale, genericSafety.reason);
+      return EXIT_NOT_A_PROJECT_DIR;
+    }
+    const prompter = options.prompter ?? (options.interactive ? createTerminalPrompter() : null);
+    const confirmed = options.empty || options.yes ? true : prompter ? await prompter.confirmGenericProject({ rootDir, locale }) : false;
+    if (!confirmed) {
+      if (options.interactive) {
+        console.log(
+          locale === "zh-CN" ? "\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002" : "Initialization cancelled."
+        );
+        return EXIT_USER_CANCEL;
+      }
+      printNotProjectDirectory(rootDir, locale, "empty");
       return EXIT_NOT_A_PROJECT_DIR;
     }
-    if (!deps.jq) {
+    isGenericProject = true;
+  }
+  try {
+    console.log(
+      localize(
+        locale,
+        "\u2713  \u68C0\u6D4B\u7CFB\u7EDF\u4F9D\u8D56...",
+        "\u2713  Checking system dependencies..."
+      )
+    );
+    const deps = await detectSystemDeps();
+    if (!deps.git) {
       console.log(
-        "\u26A0\uFE0F  jq not found (optional). Hooks will use grep/sed fallback (slightly slower)."
+        localize(
+          locale,
+          "\u26A0\uFE0F  \u672A\u627E\u5230 Git\uFF08\u53EF\u9009\uFF09\u3002\u56E2\u961F\u81EA\u52A8\u68C0\u6D4B\u5C06\u4F7F\u7528 solo \u9ED8\u8BA4\u503C\u3002",
+          "\u26A0\uFE0F  Git not found (optional). Team auto-detection will use solo defaults."
+        )
       );
     } else {
-      console.log("   bash \u2713 git \u2713 jq \u2713");
+      console.log("   git \u2713");
     }
-    console.log("\u2713  \u68C0\u6D4B\u9879\u76EE\u7C7B\u578B...");
+    console.log(
+      localize(locale, "\u2713  \u68C0\u6D4B\u9879\u76EE\u7C7B\u578B...", "\u2713  Detecting project type...")
+    );
     const profile = await detectProjectProfile(rootDir);
     const profileStack = [...profile.languages, ...profile.frameworks];
     const techStackStr = profileStack.join(" + ") || "Unknown";
@@ -3738,37 +3880,100 @@ async function init(rootDir = process3.cwd(), options = {}) {
         console.log(`   UI: ${uiLibraryStr}`);
       }
     } else if (hasManifest) {
-      console.log("   project manifest found, no known framework dependencies");
+      console.log(
+        localize(
+          locale,
+          "   \u5DF2\u53D1\u73B0\u9879\u76EE manifest\uFF0C\u672A\u8BC6\u522B\u5230\u6846\u67B6\u4F9D\u8D56",
+          "   Project manifest found; no known framework dependencies"
+        )
+      );
     } else {
       console.log(
-        "   (No recognized manifest found, profile confidence is low)"
+        localize(
+          locale,
+          "   \uFF08\u672A\u53D1\u73B0\u5DF2\u8BC6\u522B\u7684 manifest\uFF0C\u9879\u76EE\u753B\u50CF\u7F6E\u4FE1\u5EA6\u8F83\u4F4E\uFF09",
+          "   (No recognized manifest found; profile confidence is low)"
+        )
       );
     }
     const existingPlatform = wasInitialized ? await readExistingInitPlatform(stateFile) : null;
-    const initPlatformName = options.platform ?? existingPlatform ?? DEFAULT_INIT_PLATFORM;
-    const installer = getPlatformInstaller(initPlatformName);
-    if (!installer) {
-      console.error(`\u2717  Unsupported platform: ${initPlatformName}`);
+    const platformHints = await detectPlatformHints(rootDir);
+    const selectedPlatforms = await selectInitPlatforms({
+      option: options.platform,
+      existingPlatform,
+      hints: platformHints,
+      interactive: options.interactive,
+      prompter: options.prompter,
+      locale,
+      yes: options.yes
+    });
+    if (!selectedPlatforms) {
+      console.error(
+        locale === "zh-CN" ? "\u2717  \u672A\u9009\u62E9\u5E73\u53F0\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C\u5E76\u9009\u62E9\u5E73\u53F0\uFF0C\u6216\u4F7F\u7528 --platform codex,cursor / --platform all\u3002" : "\u2717  No platform selected. Choose one interactively or pass --platform codex,cursor / --platform all."
+      );
+      return EXIT_INIT_FAILED;
+    }
+    if (selectedPlatforms.length === 0) {
+      console.error("\u2717  No platform selected.");
+      return EXIT_INIT_FAILED;
+    }
+    const firstPlatform = selectedPlatforms[0];
+    if (!firstPlatform) {
+      console.error("\u2717  No platform selected.");
+      return EXIT_INIT_FAILED;
+    }
+    const installers = selectedPlatforms.map(getPlatformInstaller);
+    if (installers.some((installer) => !installer)) {
+      console.error(`\u2717  Unsupported platform: ${options.platform}`);
       return EXIT_INIT_FAILED;
     }
+    const typedInstallers = installers.filter(
+      (installer) => installer !== null
+    );
+    const onlyPlatformHint = platformHints.length === 1 ? platformHints[0] : null;
+    const detectedPrimary = onlyPlatformHint && selectedPlatforms.includes(onlyPlatformHint) ? onlyPlatformHint : null;
+    const primaryPlatform = existingPlatform && selectedPlatforms.includes(existingPlatform) ? existingPlatform : detectedPrimary ?? firstPlatform;
+    const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
+    mutationSnapshots = await snapshotFiles(managedFiles);
+    directorySnapshots = await snapshotDirectories(managedFiles, [
+      path14.join(mancodeDir, "workflows"),
+      path14.join(mancodeDir, "preseason-reports")
+    ]);
     const team = await detectTeamStatus(rootDir);
-    const existingPreferences = wasInitialized ? await readExistingInitPreferences(mancodeDir, installer.name) : {};
+    const existingPreferences = wasInitialized ? await readExistingInitPreferences(mancodeDir, primaryPlatform) : {};
     const initialMinimal = existingPreferences.minimal ?? false;
-    const teamModeEnabled = options.team ?? existingPreferences.forceTeamMode ?? team.isTeam;
+    const existingTeamMode = existingPreferences.forceTeamMode === true ? "on" : existingPreferences.teamMode ?? "auto";
+    const teamModeEnabled = options.team ?? (existingTeamMode === "on" ? true : existingTeamMode === "off" ? false : team.isTeam);
     if (options.team === true) {
-      console.log("   team: forced on (--team)");
+      console.log(
+        localize(
+          locale,
+          "   \u56E2\u961F\u6A21\u5F0F\uFF1A\u5F3A\u5236\u5F00\u542F\uFF08--team\uFF09",
+          "   team: forced on (--team)"
+        )
+      );
     } else if (options.team === false) {
-      console.log("   team: forced off (--no-team)");
+      console.log(
+        localize(
+          locale,
+          "   \u56E2\u961F\u6A21\u5F0F\uFF1A\u5F3A\u5236\u5173\u95ED\uFF08--no-team\uFF09",
+          "   team: forced off (--no-team)"
+        )
+      );
     } else if (team.isTeam) {
       console.log(
-        `   team: ${team.contributors} contributors (/manteam available)`
+        localize(
+          locale,
+          `   \u56E2\u961F\u6A21\u5F0F\uFF1A${team.contributors} \u4F4D\u8D21\u732E\u8005\uFF08\u53EF\u4F7F\u7528 /manteam\uFF09`,
+          `   team: ${team.contributors} contributors (/manteam available)`
+        )
       );
     }
     const state = {
       version: VERSION,
       currentMode: "solo",
       lastMode: "solo",
-      platform: installer.name,
+      platform: primaryPlatform,
       initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
       techStack: techStackStr,
       uiLibrary: uiLibraryStr,
@@ -3776,18 +3981,19 @@ async function init(rootDir = process3.cwd(), options = {}) {
       currentWorkflowMode: null,
       skippedSteps: [],
       teamModeAutoDetected: teamModeEnabled,
-      contributors: team.contributors
+      contributors: team.contributors,
+      projectMode: isGenericProject ? "generic" : "detected"
     };
-    if (installer.name === "claude-code") {
+    if (selectedPlatforms.includes("claude-code")) {
       await validateClaudeCodeSettings(rootDir);
     }
     await installMancodeCore(rootDir);
-    await fs2.mkdir(mancodeDir, { recursive: true });
+    await fs3.mkdir(mancodeDir, { recursive: true });
     const stateContent = `${JSON.stringify(state, null, 2)}
 `;
-    await fs2.writeFile(stateFile, stateContent, "utf-8");
-    await fs2.writeFile(
-      path13.join(mancodeDir, "project-profile.json"),
+    await fs3.writeFile(stateFile, stateContent, "utf-8");
+    await fs3.writeFile(
+      path14.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -3796,24 +4002,40 @@ async function init(rootDir = process3.cwd(), options = {}) {
       mancodeDir,
       {
         forceTeamMode: options.team === void 0 && wasInitialized ? void 0 : options.team === true,
+        teamMode: options.team === void 0 && wasInitialized ? void 0 : options.team === true ? "on" : options.team === false ? "off" : "auto",
         defaultStyle: options.style === void 0 && wasInitialized ? void 0 : options.style ?? null,
-        platforms: [installer.name],
+        platforms: selectedPlatforms,
         platformOptions: {
-          [installer.name]: { minimal: initialMinimal }
+          ...Object.fromEntries(
+            selectedPlatforms.map((platform) => [
+              platform,
+              { minimal: initialMinimal }
+            ])
+          )
         }
       },
       wasInitialized
     );
-    let styleLine = "  .mancode/aesthetics/        # style-tokens.json (\u7A7A)";
+    let styleLine = localize(
+      locale,
+      "  .mancode/aesthetics/        # style-tokens.json\uFF08\u7A7A\uFF09",
+      "  .mancode/aesthetics/        # style-tokens.json (empty)"
+    );
     if (profile.uiAssets === "detected") {
-      console.log("\u2713  \u626B\u63CF\u5BA1\u7F8E token...");
+      console.log(
+        localize(
+          locale,
+          "\u2713  \u626B\u63CF\u5BA1\u7F8E token...",
+          "\u2713  Scanning design tokens..."
+        )
+      );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path13.join(
+      const tokensPath = path14.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
       );
-      await fs2.writeFile(
+      await fs3.writeFile(
         tokensPath,
         `${JSON.stringify(tokens, null, 2)}
 `,
@@ -3823,70 +4045,146 @@ async function init(rootDir = process3.cwd(), options = {}) {
         const colorCount = Object.keys(tokens.colors).length;
         const fontCount = Object.keys(tokens.fonts).length;
         console.log(
-          `   ${colorCount} colors, ${fontCount} fonts (match: high)`
+          localize(
+            locale,
+            `   ${colorCount} \u4E2A\u989C\u8272\uFF0C${fontCount} \u4E2A\u5B57\u4F53\uFF08\u5339\u914D\u5EA6\uFF1A\u9AD8\uFF09`,
+            `   ${colorCount} colors, ${fontCount} fonts (match: high)`
+          )
+        );
+        styleLine = localize(
+          locale,
+          `  .mancode/aesthetics/        # style-tokens.json\uFF08${colorCount} \u4E2A\u989C\u8272\uFF09`,
+          `  .mancode/aesthetics/        # style-tokens.json (${colorCount} colors)`
         );
-        styleLine = `  .mancode/aesthetics/        # style-tokens.json (${colorCount} colors)`;
       } else if (tokens.matchLevel === "low") {
         console.log(
-          "   UI assets detected, no reusable tokens found (match: low)"
+          localize(
+            locale,
+            "   \u5DF2\u68C0\u6D4B\u5230 UI \u8D44\u6E90\uFF0C\u672A\u627E\u5230\u53EF\u590D\u7528 token\uFF08\u5339\u914D\u5EA6\uFF1A\u4F4E\uFF09",
+            "   UI assets detected; no reusable tokens found (match: low)"
+          )
+        );
+        styleLine = localize(
+          locale,
+          "  .mancode/aesthetics/        # style-tokens.json\uFF08\u4F4E\u5339\u914D\uFF09",
+          "  .mancode/aesthetics/        # style-tokens.json (low match)"
         );
-        styleLine = "  .mancode/aesthetics/        # style-tokens.json (low match)";
       } else {
-        console.log("   No design tokens found (match: none)");
-        styleLine = "  .mancode/aesthetics/        # style-tokens.json (no tokens)";
+        console.log(
+          localize(
+            locale,
+            "   \u672A\u627E\u5230\u8BBE\u8BA1 token\uFF08\u65E0\u5339\u914D\uFF09",
+            "   No design tokens found (match: none)"
+          )
+        );
+        styleLine = localize(
+          locale,
+          "  .mancode/aesthetics/        # style-tokens.json\uFF08\u65E0 token\uFF09",
+          "  .mancode/aesthetics/        # style-tokens.json (no tokens)"
+        );
       }
     }
-    console.log(`\u2713  \u5B89\u88C5 ${installer.displayName} \u9002\u914D...`);
-    await installer.install(rootDir, {
-      techStack: profileStack,
-      uiLibrary,
-      projectProfile: profile,
-      minimal: initialMinimal,
-      force: options.force
-    });
+    for (const installer of typedInstallers) {
+      console.log(
+        localize(
+          locale,
+          `\u2713  \u5B89\u88C5 ${installer.displayName} \u9002\u914D\u5668...`,
+          `\u2713  Installing ${installer.displayName} adapter...`
+        )
+      );
+      await installer.install(rootDir, {
+        techStack: profileStack,
+        uiLibrary,
+        projectProfile: profile,
+        minimal: initialMinimal,
+        force: options.force
+      });
+    }
     console.log("");
-    console.log("\u2713  mancode initialized.");
+    console.log(
+      localize(locale, "\u2713  mancode \u521D\u59CB\u5316\u5B8C\u6210\u3002", "\u2713  mancode initialized.")
+    );
     console.log("");
-    console.log("Created:");
-    console.log("  .mancode/state.json         # \u9879\u76EE\u72B6\u6001");
-    console.log("  .mancode/project-profile.json # \u68C0\u6D4B\u5230\u7684\u9879\u76EE\u4E8B\u5B9E");
-    console.log("  .mancode/config.json        # \u914D\u7F6E");
+    console.log(localize(locale, "\u5DF2\u521B\u5EFA\uFF1A", "Created:"));
+    console.log(
+      localize(
+        locale,
+        "  .mancode/state.json         # \u9879\u76EE\u72B6\u6001",
+        "  .mancode/state.json         # project state"
+      )
+    );
     console.log(
-      "  .mancode/hooks/             # SessionStart + UserPromptSubmit"
+      localize(
+        locale,
+        "  .mancode/project-profile.json # \u68C0\u6D4B\u5230\u7684\u9879\u76EE\u4E8B\u5B9E",
+        "  .mancode/project-profile.json # detected project facts"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .mancode/config.json        # \u914D\u7F6E",
+        "  .mancode/config.json        # configuration"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .mancode/hooks/             # SessionStart + UserPromptSubmit",
+        "  .mancode/hooks/             # SessionStart + UserPromptSubmit"
+      )
     );
     console.log(styleLine);
     console.log("  .mancode/logs/              # hooks.log");
-    printPlatformCreatedFiles(installer.name);
+    for (const platform of selectedPlatforms)
+      printPlatformCreatedFiles(platform, locale);
     console.log("");
-    console.log("Next:");
-    console.log("  mancode status              # Show project state");
-    if (installer.name === "claude-code") {
-      console.log("  (Restart Claude Code to load hooks)");
-    } else if (installer.name === "codex") {
+    console.log(localize(locale, "\u4E0B\u4E00\u6B65\uFF1A", "Next:"));
+    console.log(
+      localize(
+        locale,
+        "  mancode status              # \u663E\u793A\u9879\u76EE\u72B6\u6001",
+        "  mancode status              # Show project state"
+      )
+    );
+    if (selectedPlatforms.includes("claude-code")) {
+      console.log(
+        localize(
+          locale,
+          "  \uFF08\u91CD\u542F Claude Code \u4EE5\u52A0\u8F7D hooks\uFF09",
+          "  (Restart Claude Code to load hooks)"
+        )
+      );
+    }
+    if (selectedPlatforms.includes("codex")) {
       console.log(
-        "  (If skills do not appear, restart the ChatGPT desktop app or Codex session)"
+        localize(
+          locale,
+          "  \uFF08\u5982\u679C skills \u672A\u51FA\u73B0\uFF0C\u8BF7\u91CD\u542F ChatGPT \u684C\u9762\u5E94\u7528\u6216 Codex \u4F1A\u8BDD\uFF09",
+          "  (If skills do not appear, restart the ChatGPT desktop app or Codex session)"
+        )
       );
     }
     return EXIT_OK;
   } catch (err) {
-    if (wasInitialized) {
-      await restoreFiles(reinstallSnapshots);
-    } else {
-      await fs2.rm(stateFile, { force: true });
-      await fs2.rm(path13.join(mancodeDir, "project-profile.json"), {
-        force: true
-      });
-    }
+    await restoreFiles(mutationSnapshots);
+    await removeNewEmptyDirectories(directorySnapshots);
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`\u2717  mancode init failed: ${msg}`);
+    console.error(
+      localize(
+        locale,
+        `\u2717  mancode \u521D\u59CB\u5316\u5931\u8D25\uFF1A${msg}`,
+        `\u2717  mancode init failed: ${msg}`
+      )
+    );
     return EXIT_INIT_FAILED;
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path13.join(mancodeDir, "config.json");
+  const configPath = path14.join(mancodeDir, "config.json");
   let config = {};
   try {
-    config = JSON.parse(await fs2.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs3.readFile(configPath, "utf-8"));
   } catch {
   }
   const existingPlatforms = Array.isArray(config.platforms) ? config.platforms.filter(
@@ -3906,7 +4204,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
       ...patch.platformOptions
     }
   } : definedPatch;
-  await fs2.writeFile(
+  await fs3.writeFile(
     configPath,
     `${JSON.stringify({ ...config, ...mergedPatch }, null, 2)}
 `,
@@ -3916,36 +4214,182 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir, platform) {
   try {
     const config = JSON.parse(
-      await fs2.readFile(path13.join(mancodeDir, "config.json"), "utf-8")
+      await fs3.readFile(path14.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {};
     if (typeof config.forceTeamMode === "boolean") {
       preferences.forceTeamMode = config.forceTeamMode;
     }
-    if (Array.isArray(config.platforms) && config.platforms.includes(platform) && isRecord3(config.platformOptions)) {
-      const platformOptions = config.platformOptions[platform];
-      if (isRecord3(platformOptions) && platformOptions.minimal === true) {
-        preferences.minimal = true;
-      }
+    if (config.teamMode === "auto" || config.teamMode === "on" || config.teamMode === "off") {
+      preferences.teamMode = config.teamMode;
+    }
+    if (Array.isArray(config.platforms) && config.platforms.includes(platform) && isRecord3(config.platformOptions)) {
+      const platformOptions = config.platformOptions[platform];
+      if (isRecord3(platformOptions) && platformOptions.minimal === true) {
+        preferences.minimal = true;
+      }
+    }
+    return preferences;
+  } catch {
+    return {};
+  }
+}
+async function readExistingInitPlatform(stateFile) {
+  try {
+    const state = JSON.parse(await fs3.readFile(stateFile, "utf-8"));
+    return typeof state.platform === "string" && getPlatformInstaller(state.platform) ? state.platform : null;
+  } catch {
+    return null;
+  }
+}
+async function selectInitPlatforms(input) {
+  if (input.option !== void 0) {
+    return parsePlatformSelection(input.option);
+  }
+  if (input.existingPlatform) return [input.existingPlatform];
+  if (input.yes && input.interactive !== void 0) {
+    return input.hints.length === 1 ? input.hints : null;
+  }
+  if (input.interactive) {
+    const prompter = input.prompter ?? createTerminalPrompter();
+    return prompter.selectPlatforms({
+      locale: input.locale,
+      detected: input.hints
+    });
+  }
+  if (input.interactive === false) {
+    return input.hints.length === 1 ? input.hints : null;
+  }
+  return [DEFAULT_INIT_PLATFORM];
+}
+async function hasProjectManifest(rootDir) {
+  for (const name of PROJECT_MANIFESTS) {
+    if (await pathExists3(path14.join(rootDir, name))) return true;
+  }
+  return false;
+}
+async function canInitializeGenericProject(rootDir) {
+  const resolved = path14.resolve(rootDir);
+  if (resolved === path14.parse(resolved).root || resolved === path14.resolve(os.homedir())) {
+    return { ok: false, reason: "unsafe" };
+  }
+  try {
+    const entries = await fs3.readdir(resolved);
+    const meaningfulEntries = entries.filter(
+      (entry) => ![".DS_Store", "Thumbs.db", ".gitkeep"].includes(entry)
+    );
+    return meaningfulEntries.length === 0 ? { ok: true } : { ok: false, reason: "nonempty" };
+  } catch {
+    return { ok: false, reason: "unsafe" };
+  }
+}
+function printNotProjectDirectory(rootDir, locale, reason) {
+  if (locale === "zh-CN") {
+    console.error(`\u2717  \u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u53EF\u521D\u59CB\u5316\u7684\u9879\u76EE\u76EE\u5F55\uFF1A${rootDir}`);
+    if (reason === "unsafe") {
+      console.error("   \u4E3A\u907F\u514D\u8BEF\u5199\uFF0C\u4E0D\u80FD\u5728 Home \u76EE\u5F55\u6216\u78C1\u76D8\u6839\u76EE\u5F55\u521D\u59CB\u5316\u3002");
+    } else if (reason === "nonempty") {
+      console.error(
+        "   \u672A\u8BC6\u522B\u5230\u9879\u76EE\u6587\u4EF6\uFF0C\u4E14\u76EE\u5F55\u4E2D\u5DF2\u6709\u6587\u4EF6\u3002\u8BF7\u5148\u8FDB\u5165\u9879\u76EE\u76EE\u5F55\u3002"
+      );
+    } else {
+      console.error(
+        "   \u672A\u53D1\u73B0 .git \u6216\u9879\u76EE\u6587\u4EF6\u3002\u4EA4\u4E92\u7EC8\u7AEF\u4E2D\u53EF\u786E\u8BA4\u901A\u7528\u9879\u76EE\uFF0C\u6216\u4F7F\u7528 --empty\u3002"
+      );
+    }
+    return;
+  }
+  console.error(`\u2717  Not a project directory: ${rootDir}`);
+  if (reason === "unsafe") {
+    console.error(
+      "   Refusing to initialize a home directory or filesystem root."
+    );
+  } else if (reason === "nonempty") {
+    console.error(
+      "   No project files were detected and the directory is not empty."
+    );
+  } else {
+    console.error(
+      "   No .git or recognized project manifest found. Use an interactive terminal or --empty for a new project."
+    );
+  }
+}
+function getInitManagedFilePaths(rootDir, platforms) {
+  const files = [
+    ".mancode/state.json",
+    ".mancode/config.json",
+    ".mancode/project-profile.json",
+    ".mancode/aesthetics/style-tokens.json",
+    ".mancode/hooks/session-start.mjs",
+    ".mancode/hooks/user-prompt-submit.mjs",
+    ".mancode/logs/hooks.log",
+    ".mancode/memory/prd.md",
+    ".mancode/memory/spec.md",
+    ".mancode/memory/decisions.md"
+  ];
+  if (platforms.includes("claude-code")) {
+    files.push(
+      ".mancode/hooks/session-start.sh",
+      ".mancode/hooks/user-prompt-submit.sh",
+      ".claude/settings.json",
+      ".claude/skills/man8/SKILL.md",
+      ".claude/skills/solo/SKILL.md",
+      ".claude/skills/mancode-solo.md",
+      ".claude/skills/mancode-man8.md"
+    );
+    for (const mode of MODE_NAMES) {
+      files.push(
+        `.claude/skills/${mode}/SKILL.md`,
+        `.claude/skills/mancode-${mode}.md`
+      );
+    }
+    for (const agent of ALL_AGENTS) {
+      files.push(`.claude/agents/${agent.name}.md`);
+    }
+  }
+  if (platforms.includes("cursor")) {
+    files.push(".cursor/rules/mancode-man8.mdc", ".cursor/commands/man8.md");
+    for (const fileName of MANCODE_CURSOR_RULE_FILES) {
+      files.push(`.cursor/rules/${fileName}`);
+    }
+    for (const mode of MODE_NAMES) {
+      files.push(`.cursor/commands/${mode}.md`);
     }
-    return preferences;
-  } catch {
-    return {};
   }
-}
-async function readExistingInitPlatform(stateFile) {
-  try {
-    const state = JSON.parse(await fs2.readFile(stateFile, "utf-8"));
-    return typeof state.platform === "string" && getPlatformInstaller(state.platform) ? state.platform : null;
-  } catch {
-    return null;
+  if (platforms.includes("codex") || platforms.includes("zcode")) {
+    files.push("AGENTS.md", ".agents/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.agents/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("codex")) {
+    files.push(".codex/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.codex/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("zcode")) {
+    files.push(".zcode/skills/man8/SKILL.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.zcode/skills/${mode}/SKILL.md`);
+    }
+  }
+  if (platforms.includes("copilot")) {
+    files.push(
+      ".github/copilot-instructions.md",
+      ".github/prompts/man8.prompt.md"
+    );
+    for (const mode of MODE_NAMES) {
+      files.push(`.github/prompts/${mode}.prompt.md`);
+    }
   }
+  return [...new Set(files.map((file) => path14.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
     filePaths.map(async (filePath) => {
       try {
-        return { filePath, content: await fs2.readFile(filePath, "utf-8") };
+        return { filePath, content: await fs3.readFile(filePath, "utf-8") };
       } catch (error) {
         if (isNodeError3(error) && error.code === "ENOENT") {
           return { filePath, content: null };
@@ -3955,14 +4399,39 @@ async function snapshotFiles(filePaths) {
     })
   );
 }
+async function snapshotDirectories(filePaths, additionalDirectories = []) {
+  const directories = new Set(additionalDirectories);
+  for (const filePath of filePaths) {
+    let current = path14.dirname(filePath);
+    while (current !== path14.dirname(current)) {
+      directories.add(current);
+      current = path14.dirname(current);
+    }
+  }
+  return Promise.all(
+    [...directories].map(async (dirPath) => ({
+      dirPath,
+      existed: await pathExists3(dirPath)
+    }))
+  );
+}
 async function restoreFiles(snapshots) {
   for (const snapshot of snapshots) {
     if (snapshot.content === null) {
-      await fs2.rm(snapshot.filePath, { force: true });
+      await fs3.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs2.mkdir(path13.dirname(snapshot.filePath), { recursive: true });
-    await fs2.writeFile(snapshot.filePath, snapshot.content, "utf-8");
+    await fs3.mkdir(path14.dirname(snapshot.filePath), { recursive: true });
+    await fs3.writeFile(snapshot.filePath, snapshot.content, "utf-8");
+  }
+}
+async function removeNewEmptyDirectories(snapshots) {
+  const candidates = snapshots.filter((snapshot) => !snapshot.existed).sort((a, b) => b.dirPath.length - a.dirPath.length);
+  for (const { dirPath } of candidates) {
+    try {
+      await fs3.rmdir(dirPath);
+    } catch {
+    }
   }
 }
 function isRecord3(value) {
@@ -3971,10 +4440,22 @@ function isRecord3(value) {
 function isNodeError3(error) {
   return error instanceof Error && "code" in error;
 }
-function printPlatformCreatedFiles(platform) {
+function printPlatformCreatedFiles(platform, locale) {
   if (platform === "claude-code") {
-    console.log("  .claude/settings.json       # hook \u6CE8\u518C");
-    console.log("  .claude/skills/             # solo + MVP-2 slash skills");
+    console.log(
+      localize(
+        locale,
+        "  .claude/settings.json       # hook \u6CE8\u518C",
+        "  .claude/settings.json       # hook registration"
+      )
+    );
+    console.log(
+      localize(
+        locale,
+        "  .claude/skills/             # solo + MVP-2 slash skills",
+        "  .claude/skills/             # solo + MVP-2 slash skills"
+      )
+    );
     return;
   }
   if (platform === "cursor") {
@@ -3993,9 +4474,12 @@ function printPlatformCreatedFiles(platform) {
   }
   console.log("  .github/copilot-instructions.md # Copilot instructions");
 }
+function localize(locale, chinese, english) {
+  return locale === "zh-CN" ? chinese : english;
+}
 async function pathExists3(p) {
   try {
-    await fs2.access(p);
+    await fs3.access(p);
     return true;
   } catch {
     return false;
@@ -4003,13 +4487,13 @@ async function pathExists3(p) {
 }
 
 // src/commands/install.ts
-import { promises as fs4 } from "fs";
-import path15 from "path";
-import process4 from "process";
+import { promises as fs5 } from "fs";
+import path16 from "path";
+import process6 from "process";
 
 // src/installers/platform-status.ts
-import { promises as fs3 } from "fs";
-import path14 from "path";
+import { promises as fs4 } from "fs";
+import path15 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -4023,13 +4507,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path14.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path15.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path14.join(rootDir, ".mancode", "hooks", "session-start.sh"),
-        path14.join(rootDir, ".mancode", "hooks", "user-prompt-submit.sh")
+        path15.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path15.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -4045,7 +4529,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path14.join(rootDir, ".cursor", "rules", file)
+        (file) => path15.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -4060,13 +4544,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path14.join(rootDir, ".cursor", "rules", file)
+          (file) => path15.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path14.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path15.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -4079,7 +4563,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path14.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path15.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -4096,9 +4580,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path14.join(rootDir, ".agents", "skills");
+    const skillsDir = path15.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -4110,7 +4594,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path14.join(rootDir, "AGENTS.md"),
+      path15.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -4130,9 +4614,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path14.join(rootDir, ".agents", "skills");
+    const skillsDir = path15.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path15.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -4143,7 +4627,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path14.join(rootDir, ".github", "copilot-instructions.md")
+    path15.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -4154,9 +4638,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path14.join(rootDir, ".github", "prompts");
+    const promptsDir = path15.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path14.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path15.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -4189,13 +4673,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path14.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path15.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path14.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path15.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -4204,7 +4688,7 @@ async function claudeFullContentReady(rootDir) {
 }
 async function fileMatches(filePath, predicate) {
   try {
-    return predicate(await fs3.readFile(filePath, "utf-8"));
+    return predicate(await fs4.readFile(filePath, "utf-8"));
   } catch {
     return false;
   }
@@ -4214,7 +4698,7 @@ async function pathsExist(paths) {
 }
 async function fileHasAnyMarker(filePath, needles) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return needles.some((needle) => content.includes(needle));
   } catch {
     return false;
@@ -4222,8 +4706,8 @@ async function fileHasAnyMarker(filePath, needles) {
 }
 async function isPlatformMinimal(rootDir, platform) {
   try {
-    const raw = await fs3.readFile(
-      path14.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs4.readFile(
+      path15.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -4236,7 +4720,7 @@ async function isPlatformMinimal(rootDir, platform) {
 }
 async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START_MARKER, endMarker = DEFAULT_MANCODE_END_MARKER) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return hasManagedBlock(content, startMarker, endMarker);
   } catch {
     return false;
@@ -4244,8 +4728,8 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 }
 async function claudeHooksRegistered(rootDir) {
   try {
-    const raw = await fs3.readFile(
-      path14.join(rootDir, ".claude", "settings.json"),
+    const raw = await fs4.readFile(
+      path15.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -4258,9 +4742,9 @@ function hooksRegistered(settings) {
   if (!isRecord4(settings)) return false;
   const hooks = settings.hooks;
   if (!isRecord4(hooks)) return false;
-  return hasHookCommand(hooks.SessionStart, ".mancode/hooks/session-start.sh") && hasHookCommand(
+  return hasHookCommand(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand(
     hooks.UserPromptSubmit,
-    ".mancode/hooks/user-prompt-submit.sh"
+    ".mancode/hooks/user-prompt-submit.mjs"
   );
 }
 function hasHookCommand(value, needle) {
@@ -4275,7 +4759,7 @@ function hasHookCommand(value, needle) {
 }
 async function pathExists4(p) {
   try {
-    await fs3.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
@@ -4290,8 +4774,8 @@ var EXIT_OK2 = 0;
 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 = path15.join(rootDir, ".mancode", "state.json");
+async function install(rootDir = process6.cwd(), platform = "claude-code", options = {}) {
+  const stateFile = path16.join(rootDir, ".mancode", "state.json");
   if (!await pathExists5(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
@@ -4377,9 +4861,9 @@ async function install(rootDir = process4.cwd(), platform = "claude-code", optio
   return EXIT_OK2;
 }
 async function readConfig(rootDir) {
-  const configPath = path15.join(rootDir, ".mancode", "config.json");
+  const configPath = path16.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await fs4.readFile(configPath, "utf-8");
+    const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
   } catch (err) {
     if (isNodeError4(err) && err.code === "ENOENT") {
@@ -4392,10 +4876,10 @@ function isNodeError4(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path15.join(rootDir, ".mancode", "config.json");
+  const configPath = path16.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
-  await fs4.writeFile(configPath, content, "utf-8");
+  await fs5.writeFile(configPath, content, "utf-8");
 }
 function withDefaultConfig(config, fallbackPlatform) {
   const fallback = fallbackPlatform ?? DEFAULT_CONFIG.platforms[0];
@@ -4427,8 +4911,8 @@ function readConfiguredMinimal(value, platform) {
 }
 async function readStatePlatform(rootDir) {
   try {
-    const raw = await fs4.readFile(
-      path15.join(rootDir, ".mancode", "state.json"),
+    const raw = await fs5.readFile(
+      path16.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -4439,7 +4923,7 @@ async function readStatePlatform(rootDir) {
 }
 async function pathExists5(p) {
   try {
-    await fs4.access(p);
+    await fs5.access(p);
     return true;
   } catch {
     return false;
@@ -4450,11 +4934,11 @@ function isRecord5(value) {
 }
 
 // src/commands/list-platforms.ts
-import { promises as fs5 } from "fs";
-import path16 from "path";
-import process5 from "process";
+import { promises as fs6 } from "fs";
+import path17 from "path";
+import process7 from "process";
 var EXIT_OK3 = 0;
-async function listPlatforms(rootDir = process5.cwd()) {
+async function listPlatforms(rootDir = process7.cwd()) {
   const installed = new Set(await readInstalledPlatforms(rootDir));
   const platforms = getPlatformInstallers();
   console.log("");
@@ -4467,8 +4951,8 @@ async function listPlatforms(rootDir = process5.cwd()) {
 }
 async function readInstalledPlatforms(rootDir) {
   try {
-    const raw = await fs5.readFile(
-      path16.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs6.readFile(
+      path17.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -4492,16 +4976,16 @@ function describePlatform(platform) {
 }
 
 // src/commands/manps.ts
-import { access as access3 } from "fs/promises";
-import path18 from "path";
-import { createInterface } from "readline/promises";
+import { access as access4 } from "fs/promises";
+import path19 from "path";
+import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
-import { execFile } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
-  access as access2,
+  access as access3,
   lstat,
   mkdir as mkdir7,
   readFile as readFile8,
@@ -4509,7 +4993,7 @@ import {
   rename,
   writeFile as writeFile9
 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -4589,9 +5073,9 @@ async function runPreseasonScan(projectRoot, area = "all") {
   const needsFiles = normalizedArea === "all" || normalizedArea === "dead-code" || normalizedArea === "config";
   const files = needsFiles ? await listProjectFiles(projectRoot) : [];
   const issues = (await scanArea(projectRoot, normalizedArea, pkg, files)).slice(0, 20);
-  const reportDir = path17.join(projectRoot, ".mancode", "preseason-reports");
+  const reportDir = path18.join(projectRoot, ".mancode", "preseason-reports");
   await mkdir7(reportDir, { recursive: true });
-  const issueDbPath = path17.join(
+  const issueDbPath = path18.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -4611,7 +5095,7 @@ async function runPreseasonScan(projectRoot, area = "all") {
   const database = await buildIssueDatabase(projectRoot, report);
   await writeFile9(reportPath, renderPreseasonReport(report), "utf-8");
   await writeFile9(
-    path17.join(projectRoot, ".mancode", "preseason-report.md"),
+    path18.join(projectRoot, ".mancode", "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -4619,7 +5103,7 @@ async function runPreseasonScan(projectRoot, area = "all") {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = path17.join(
+  const issueDbPath = path18.join(
     projectRoot,
     ".mancode",
     "preseason-issues.json"
@@ -4733,7 +5217,7 @@ async function scanArea(projectRoot, area, pkg, files) {
 async function allocateReportPath(reportDir, baseName) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
-    const candidate = path17.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path18.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -4782,8 +5266,8 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path17.join(current, entry);
-    const rel = path17.relative(root, abs);
+    const abs = path18.join(current, entry);
+    const rel = path18.relative(root, abs);
     let info;
     try {
       info = await lstat(abs);
@@ -4793,7 +5277,7 @@ async function walk(root, current, results, depth) {
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path17.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path18.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -4801,7 +5285,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile8(path17.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile8(path18.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -4894,7 +5378,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path17.join(projectRoot, file);
+    const abs = path18.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -4931,7 +5415,7 @@ function scanTestGaps(files) {
   if (sourceFiles.length === 0) return [];
   const tests = new Set(files.filter((file) => file.startsWith("tests/")));
   const missing = sourceFiles.filter((file) => {
-    const base = path17.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path18.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -4940,13 +5424,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path17.basename(file)}.`,
+    detail: `No matching test file was found for ${path18.basename(file)}.`,
     recommendation: "Add focused coverage for the public behavior or document why this module is exercised indirectly."
   }));
 }
 function scanConfig(projectRoot, files) {
   const issues = [];
-  if (!files.includes(".gitignore") && !pathExistsSync(path17.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path18.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -4957,7 +5441,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path17.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path18.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -4976,7 +5460,7 @@ function scanAestheticDrift(projectRoot, files) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path17.join(projectRoot, file));
+      content = readFileSyncSafe(path18.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -4996,7 +5480,7 @@ function scanAestheticDrift(projectRoot, files) {
   return issues;
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path17.join(
+  const localBinary = path18.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -5044,7 +5528,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists6(path17.join(projectRoot, file)))
+    files.map((file) => pathExists6(path18.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -5061,7 +5545,7 @@ function architectureScannerUnavailableIssue() {
 function runDepcruise(binary, projectRoot) {
   return new Promise((resolve) => {
     const needsShell = process.platform === "win32";
-    execFile(
+    execFile3(
       binary,
       ["--output-type", "json", "."],
       {
@@ -5070,11 +5554,11 @@ function runDepcruise(binary, projectRoot) {
         maxBuffer: DEPCRUISE_MAX_BUFFER,
         shell: needsShell
       },
-      (error, stdout, stderr) => {
+      (error, stdout2, stderr) => {
         if (!error) {
           resolve({
             status: "ok",
-            stdout,
+            stdout: stdout2,
             stderr,
             exitCode: 0,
             timedOut: false
@@ -5094,7 +5578,7 @@ function runDepcruise(binary, projectRoot) {
         }
         resolve({
           status: "failed",
-          stdout: nodeError.stdout ?? stdout,
+          stdout: nodeError.stdout ?? stdout2,
           stderr: nodeError.stderr ?? stderr,
           exitCode: typeof nodeError.code === "number" ? nodeError.code : null,
           timedOut: Boolean(nodeError.killed || nodeError.signal === "SIGTERM")
@@ -5150,9 +5634,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path17.relative(projectRoot, report.reportPath);
+  const reportRef = path18.relative(projectRoot, report.reportPath);
   const run = {
-    id: path17.basename(report.reportPath, ".md"),
+    id: path18.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -5258,7 +5742,7 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path17.join(projectRoot, ".gitignore");
+    const gitignorePath = path18.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
@@ -5267,7 +5751,7 @@ async function applySafeRemediation(projectRoot, issue) {
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path17.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path18.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
@@ -5307,7 +5791,7 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path17.join(projectRoot, "package.json");
+  const packagePath = path18.join(projectRoot, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile8(packagePath, "utf-8"));
@@ -5401,7 +5885,7 @@ function pathExistsSync(file) {
 }
 async function pathExists6(file) {
   try {
-    await access2(file);
+    await access3(file);
     return true;
   } catch {
     return false;
@@ -5420,7 +5904,7 @@ var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  if (!await pathExists7(path18.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists7(path19.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
@@ -5499,8 +5983,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path18.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path18.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path19.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path19.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -5516,7 +6000,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path18.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path19.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK4;
@@ -5542,7 +6026,7 @@ async function runRemediation(rootDir, report, options, silent = false) {
       write
     });
   }
-  const rl = createInterface({
+  const rl = createInterface2({
     input: process.stdin,
     output: process.stdout
   });
@@ -5564,30 +6048,253 @@ async function readStdinLines() {
 }
 async function pathExists7(p) {
   try {
-    await access3(p);
+    await access4(p);
     return true;
   } catch {
     return false;
   }
 }
 
-// src/commands/refresh-style.ts
-import { promises as fs6 } from "fs";
-import path19 from "path";
-import process6 from "process";
+// src/commands/refresh-project.ts
+import { randomUUID } from "crypto";
+import { promises as fs7 } from "fs";
+import path20 from "path";
+import process8 from "process";
 var EXIT_OK5 = 0;
 var EXIT_NOT_INITIALIZED3 = 1;
-async function refreshStyle(rootDir = process6.cwd()) {
-  const stateFile = path19.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists8(stateFile)) {
+var EXIT_CORRUPT_STATE = 2;
+var EXIT_REFRESH_FAILED = 3;
+async function refreshProject(rootDir = process8.cwd()) {
+  const mancodeDir = path20.join(rootDir, ".mancode");
+  const statePath = path20.join(mancodeDir, "state.json");
+  if (!await pathExists8(statePath)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
     return EXIT_NOT_INITIALIZED3;
   }
+  const state = await readRequiredState(statePath);
+  if (!state) {
+    console.error("\u2717  .mancode/state.json is corrupt or incomplete.");
+    console.error("   Run `mancode init --force` to repair it.");
+    return EXIT_CORRUPT_STATE;
+  }
+  let factsWritten = false;
+  try {
+    const [profile, team, hasGit, hasManifest] = await Promise.all([
+      detectProjectProfile(rootDir),
+      detectTeamStatus(rootDir),
+      pathExists8(path20.join(rootDir, ".git")),
+      hasProjectManifest2(rootDir)
+    ]);
+    const uiLibrary = primaryUiLibrary(profile);
+    const stack = [...profile.languages, ...profile.frameworks];
+    const config = await readJson3(path20.join(mancodeDir, "config.json"));
+    const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
+    const nextState = {
+      ...state,
+      techStack: stack.join(" + ") || profile.projectKind,
+      uiLibrary: uiLibrary ?? "None",
+      projectMode: hasGit || hasManifest ? "detected" : "generic",
+      teamModeAutoDetected: configuredTeam,
+      contributors: team.contributors
+    };
+    await writeProjectFacts(
+      statePath,
+      path20.join(mancodeDir, "project-profile.json"),
+      `${JSON.stringify(nextState, null, 2)}
+`,
+      `${JSON.stringify(profile, null, 2)}
+`
+    );
+    factsWritten = true;
+    const refreshedPlatforms = await refreshStaticPlatforms(
+      rootDir,
+      config,
+      state.platform,
+      stack,
+      uiLibrary,
+      profile
+    );
+    console.log("\u2713  Project facts refreshed.");
+    console.log(
+      `   ${hasGit ? "Git detected" : "No Git repository"} | ${hasManifest ? "project manifest detected" : "generic project"}`
+    );
+    console.log(
+      `   Stack: ${nextState.techStack} | UI: ${nextState.uiLibrary}`
+    );
+    if (refreshedPlatforms.length > 0) {
+      console.log(`   Refreshed adapters: ${refreshedPlatforms.join(", ")}`);
+    }
+    console.log(
+      "   Run `mancode refresh-style` if UI files or dependencies changed."
+    );
+    return EXIT_OK5;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`\u2717  Project refresh failed: ${message}`);
+    if (factsWritten) {
+      console.error(
+        "   Project facts were saved, but one or more static adapters remain stale."
+      );
+    }
+    return EXIT_REFRESH_FAILED;
+  }
+}
+async function hasProjectManifest2(rootDir) {
+  for (const manifest of PROJECT_MANIFESTS) {
+    if (await pathExists8(path20.join(rootDir, manifest))) return true;
+  }
+  return false;
+}
+async function writeProjectFacts(statePath, profilePath, stateContent, profileContent) {
+  await Promise.all([
+    ensureReplaceableFile(statePath),
+    ensureReplaceableFile(profilePath)
+  ]);
+  const previousProfile = await readOptionalText(profilePath);
+  const stateTemp = temporaryPath(statePath);
+  const profileTemp = temporaryPath(profilePath);
+  let profileReplaced = false;
+  try {
+    await Promise.all([
+      fs7.writeFile(stateTemp, stateContent, "utf-8"),
+      fs7.writeFile(profileTemp, profileContent, "utf-8")
+    ]);
+    await fs7.rename(profileTemp, profilePath);
+    profileReplaced = true;
+    await fs7.rename(stateTemp, statePath);
+  } catch (error) {
+    if (profileReplaced) {
+      if (previousProfile === null) {
+        await fs7.rm(profilePath, { force: true });
+      } else {
+        await replaceTextFile(profilePath, previousProfile);
+      }
+    }
+    throw error;
+  } finally {
+    await Promise.all([
+      fs7.rm(stateTemp, { force: true }),
+      fs7.rm(profileTemp, { force: true })
+    ]);
+  }
+}
+async function ensureReplaceableFile(filePath) {
+  try {
+    const entry = await fs7.lstat(filePath);
+    if (!entry.isFile()) {
+      throw new Error(`cannot replace non-file path: ${filePath}`);
+    }
+  } catch (error) {
+    if (isNodeError6(error) && error.code === "ENOENT") return;
+    throw error;
+  }
+}
+async function replaceTextFile(filePath, content) {
+  const tempPath = temporaryPath(filePath);
+  try {
+    await fs7.writeFile(tempPath, content, "utf-8");
+    await fs7.rename(tempPath, filePath);
+  } finally {
+    await fs7.rm(tempPath, { force: true });
+  }
+}
+async function readOptionalText(filePath) {
+  try {
+    return await fs7.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError6(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function temporaryPath(filePath) {
+  return path20.join(
+    path20.dirname(filePath),
+    `.${path20.basename(filePath)}.${process8.pid}.${randomUUID()}.tmp`
+  );
+}
+async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
+  const platforms = configuredPlatforms(config, fallbackPlatform).filter(
+    (platform) => platform !== "claude-code"
+  );
+  const refreshed = [];
+  for (const platform of platforms) {
+    const installer = getPlatformInstaller(platform);
+    if (!installer) continue;
+    await installer.install(rootDir, {
+      techStack: stack,
+      uiLibrary,
+      projectProfile: profile,
+      minimal: platformIsMinimal(config, platform),
+      force: true
+    });
+    refreshed.push(installer.displayName);
+  }
+  return refreshed;
+}
+function configuredPlatforms(config, fallbackPlatform) {
+  const configured = Array.isArray(config.platforms) ? config.platforms : [fallbackPlatform];
+  return configured.filter(
+    (platform) => typeof platform === "string" && getPlatformInstaller(platform) !== null
+  );
+}
+function platformIsMinimal(config, platform) {
+  if (!isRecord7(config.platformOptions)) return false;
+  const options = config.platformOptions[platform];
+  return isRecord7(options) && options.minimal === true;
+}
+async function readJson3(filePath) {
+  try {
+    const value = JSON.parse(await fs7.readFile(filePath, "utf-8"));
+    return isRecord7(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+async function readRequiredState(filePath) {
+  let state;
+  try {
+    const raw = await fs7.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord7(parsed)) return null;
+    state = parsed;
+  } catch {
+    return null;
+  }
+  return typeof state.version === "string" && typeof state.currentMode === "string" && typeof state.platform === "string" ? state : null;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError6(error) {
+  return error instanceof Error && "code" in error;
+}
+async function pathExists8(filePath) {
+  try {
+    await fs7.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/refresh-style.ts
+import { promises as fs8 } from "fs";
+import path21 from "path";
+import process9 from "process";
+var EXIT_OK6 = 0;
+var EXIT_NOT_INITIALIZED4 = 1;
+async function refreshStyle(rootDir = process9.cwd()) {
+  const stateFile = path21.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists9(stateFile)) {
+    console.error("\u2717  mancode not initialized.");
+    console.error("   Run `mancode init` first.");
+    return EXIT_NOT_INITIALIZED4;
+  }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path19.join(rootDir, ".mancode", "project-profile.json");
-  await fs6.writeFile(
+  const profilePath = path21.join(rootDir, ".mancode", "project-profile.json");
+  await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
 `,
@@ -5604,18 +6311,18 @@ async function refreshStyle(rootDir = process6.cwd()) {
     );
     console.log("   Updated .mancode/project-profile.json.");
     await printStaticPlatformRefreshHint(rootDir);
-    return EXIT_OK5;
+    return EXIT_OK6;
   }
   console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
   const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-  const tokensPath = path19.join(
+  const tokensPath = path21.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs6.mkdir(path19.dirname(tokensPath), { recursive: true });
-  await fs6.writeFile(
+  await fs8.mkdir(path21.dirname(tokensPath), { recursive: true });
+  await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
 `,
@@ -5663,7 +6370,7 @@ async function refreshStyle(rootDir = process6.cwd()) {
     "\u5DF2\u66F4\u65B0 .mancode/project-profile.json \u548C .mancode/aesthetics/style-tokens.json"
   );
   await printStaticPlatformRefreshHint(rootDir);
-  return EXIT_OK5;
+  return EXIT_OK6;
 }
 async function printStaticPlatformRefreshHint(rootDir) {
   const platforms = await readInstalledPlatforms2(rootDir);
@@ -5680,11 +6387,11 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path19.join(rootDir, ".mancode", "state.json");
+  const statePath = path21.join(rootDir, ".mancode", "state.json");
   try {
-    const state = JSON.parse(await fs6.readFile(statePath, "utf-8"));
+    const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
-    await fs6.writeFile(
+    await fs8.writeFile(
       statePath,
       `${JSON.stringify(
         {
@@ -5703,8 +6410,8 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 }
 async function readInstalledPlatforms2(rootDir) {
   try {
-    const raw = await fs6.readFile(
-      path19.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs8.readFile(
+      path21.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -5715,9 +6422,9 @@ async function readInstalledPlatforms2(rootDir) {
     return [];
   }
 }
-async function pathExists8(p) {
+async function pathExists9(p) {
   try {
-    await fs6.access(p);
+    await fs8.access(p);
     return true;
   } catch {
     return false;
@@ -5726,9 +6433,9 @@ async function pathExists8(p) {
 
 // src/commands/status.ts
 import { spawn } from "child_process";
-import { promises as fs7 } from "fs";
-import path22 from "path";
-import process7 from "process";
+import { promises as fs9 } from "fs";
+import path24 from "path";
+import process10 from "process";
 
 // src/system/workflow.ts
 import {
@@ -5739,11 +6446,11 @@ import {
   stat as stat4,
   writeFile as writeFile11
 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 
 // src/system/review-ledger.ts
 import { mkdir as mkdir8, readFile as readFile9, stat as stat3, writeFile as writeFile10 } from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 var REVIEW_FILE = "review-ledger.json";
 var TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
 var BLOCKER_ID_PATTERN = /^[A-Z][A-Z0-9-]{0,31}$/;
@@ -5859,8 +6566,8 @@ async function readReviewLedger(projectRoot, taskId) {
   }
 }
 function isReviewLedger(value) {
-  if (!isRecord7(value)) return false;
-  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord7(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
+  if (!isRecord8(value)) return false;
+  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord8(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
     return false;
   }
   const requiredDomains = value.requiredDomains;
@@ -5876,13 +6583,13 @@ function isReviewLedger(value) {
   }
   const blockerIds = /* @__PURE__ */ new Set();
   return blockers.every(
-    (blocker) => isRecord7(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
+    (blocker) => isRecord8(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
   );
 }
 function isDomainArray(value) {
   return Array.isArray(value) && value.every(isReviewDomain);
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function requireReviewLedger(projectRoot, taskId) {
@@ -5892,17 +6599,17 @@ async function requireReviewLedger(projectRoot, taskId) {
   return ledger;
 }
 async function writeReviewLedger(projectRoot, taskId, ledger) {
-  const dir = path20.join(projectRoot, ".mancode", "workflows", taskId);
+  const dir = path22.join(projectRoot, ".mancode", "workflows", taskId);
   await mkdir8(dir, { recursive: true });
   await writeFile10(
-    path20.join(dir, REVIEW_FILE),
+    path22.join(dir, REVIEW_FILE),
     `${JSON.stringify(ledger, null, 2)}
 `,
     "utf-8"
   );
 }
 function reviewPath(projectRoot, taskId) {
-  return path20.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
+  return path22.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
 }
 function assertValidTaskId(taskId) {
   if (!TASK_ID_PATTERN.test(taskId)) {
@@ -5915,7 +6622,7 @@ function assertSafeReportPath(report) {
   }
 }
 async function assertReportExists(projectRoot, taskId, report) {
-  const reportPath = path20.join(
+  const reportPath = path22.join(
     projectRoot,
     ".mancode",
     "workflows",
@@ -5929,9 +6636,9 @@ async function assertReportExists(projectRoot, taskId, report) {
   throw new Error(`review report not found: ${report}`);
 }
 function isSafeReportPath(report) {
-  const normalized = path20.posix.normalize(report.replaceAll("\\", "/"));
+  const normalized = path22.posix.normalize(report.replaceAll("\\", "/"));
   return Boolean(
-    report.trim() && !path20.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
+    report.trim() && !path22.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
   );
 }
 
@@ -5979,7 +6686,7 @@ async function allocateTaskId(projectRoot, baseTaskId) {
       await mkdir9(workflowDir(projectRoot, taskId));
       return taskId;
     } catch (err) {
-      if (isNodeError6(err) && err.code === "EEXIST") {
+      if (isNodeError7(err) && err.code === "EEXIST") {
         continue;
       }
       throw err;
@@ -6055,19 +6762,19 @@ async function deleteWorkflow(projectRoot, taskId) {
   return true;
 }
 function workflowsRoot(projectRoot) {
-  return path21.join(projectRoot, ".mancode", "workflows");
+  return path23.join(projectRoot, ".mancode", "workflows");
 }
 function workflowDir(projectRoot, taskId) {
   assertValidTaskId2(taskId);
-  return path21.join(workflowsRoot(projectRoot), taskId);
+  return path23.join(workflowsRoot(projectRoot), taskId);
 }
 function metadataPath(projectRoot, taskId) {
-  return path21.join(workflowDir(projectRoot, taskId), METADATA_FILE);
+  return path23.join(workflowDir(projectRoot, taskId), METADATA_FILE);
 }
 async function writeMetadata(dir, meta) {
   const content = `${JSON.stringify(meta, null, 2)}
 `;
-  await writeFile11(path21.join(dir, METADATA_FILE), content, "utf-8");
+  await writeFile11(path23.join(dir, METADATA_FILE), content, "utf-8");
 }
 function parseWorkflowMeta(raw, taskId) {
   try {
@@ -6273,7 +6980,7 @@ async function propagateChildStatus(projectRoot, child) {
     });
   }
 }
-function isNodeError6(err) {
+function isNodeError7(err) {
   return err instanceof Error && "code" in err;
 }
 function assertValidTaskId2(taskId) {
@@ -6284,19 +6991,19 @@ function assertValidTaskId2(taskId) {
 
 // src/commands/status.ts
 var HOOK_ESTIMATE_TIMEOUT_MS = 2e3;
-var EXIT_OK6 = 0;
-var EXIT_NOT_INITIALIZED4 = 1;
-var EXIT_CORRUPT_STATE = 2;
-async function status(rootDir = process7.cwd(), options = {}) {
-  const stateFile = path22.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists9(stateFile)) {
+var EXIT_OK7 = 0;
+var EXIT_NOT_INITIALIZED5 = 1;
+var EXIT_CORRUPT_STATE2 = 2;
+async function status(rootDir = process10.cwd(), options = {}) {
+  const stateFile = path24.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists10(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` to get started.");
-    return EXIT_NOT_INITIALIZED4;
+    return EXIT_NOT_INITIALIZED5;
   }
   let state;
   try {
-    const raw = await fs7.readFile(stateFile, "utf-8");
+    const raw = await fs9.readFile(stateFile, "utf-8");
     state = JSON.parse(raw);
   } catch (err) {
     if (err instanceof SyntaxError) {
@@ -6307,7 +7014,7 @@ async function status(rootDir = process7.cwd(), options = {}) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`\u2717  Failed to read .mancode/state.json: ${msg}`);
     }
-    return EXIT_CORRUPT_STATE;
+    return EXIT_CORRUPT_STATE2;
   }
   const [
     project,
@@ -6315,14 +7022,16 @@ async function status(rootDir = process7.cwd(), options = {}) {
     config,
     hookInjection,
     teamStatus,
-    currentWorkflow
+    currentWorkflow,
+    projectRefreshRecommended
   ] = await Promise.all([
     getProjectName(rootDir),
     checkHooks(rootDir),
     readConfig2(rootDir),
     estimateHookInjection(rootDir),
     detectTeamStatus(rootDir),
-    getCurrentWorkflow(rootDir, state.currentTask ?? null)
+    getCurrentWorkflow(rootDir, state.currentTask ?? null),
+    shouldRefreshProject(rootDir, state)
   ]);
   const effectiveTeam = getEffectiveTeamStatus(state, config, teamStatus);
   const result = {
@@ -6337,7 +7046,8 @@ async function status(rootDir = process7.cwd(), options = {}) {
     hookInjection,
     team: effectiveTeam,
     currentWorkflow,
-    platformStatus: {}
+    platformStatus: {},
+    projectRefreshRecommended
   };
   result.platformStatus = await checkPlatformStatus2(rootDir, result.platforms);
   if (options.json) {
@@ -6345,7 +7055,16 @@ async function status(rootDir = process7.cwd(), options = {}) {
   } else {
     printText(result);
   }
-  return EXIT_OK6;
+  return EXIT_OK7;
+}
+async function shouldRefreshProject(rootDir, state) {
+  if (state.projectMode !== "generic") return false;
+  const hasGit = await pathExists10(path24.join(rootDir, ".git"));
+  if (hasGit) return true;
+  for (const manifest of PROJECT_MANIFESTS) {
+    if (await pathExists10(path24.join(rootDir, manifest))) return true;
+  }
+  return false;
 }
 async function checkPlatformStatus2(rootDir, installedPlatforms) {
   const installed = new Set(installedPlatforms);
@@ -6387,19 +7106,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs7.readFile(path22.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path24.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path22.basename(rootDir);
+  return path24.basename(rootDir);
 }
 async function readConfig2(rootDir) {
   try {
-    const raw = await fs7.readFile(
-      path22.join(rootDir, ".mancode", "config.json"),
+    const raw = await fs9.readFile(
+      path24.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -6414,21 +7133,22 @@ function getInstalledPlatforms(config, fallback) {
   return fallback ? [fallback] : [];
 }
 function getEffectiveTeamStatus(state, config, detected) {
-  const configuredTeam = config.forceTeamMode === true ? true : state.teamModeAutoDetected ?? detected.isTeam;
-  const forced = config.forceTeamMode === true;
+  const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : state.teamModeAutoDetected ?? detected.isTeam;
+  const forced = config.teamMode === "on" || config.forceTeamMode === true;
+  const autoDetected = config.forceTeamMode === true || config.teamMode === "on" || config.teamMode === "off" ? false : state.teamModeAutoDetected ?? detected.isTeam;
   return {
     ...detected,
     isTeam: configuredTeam,
     contributors: Math.max(detected.contributors, state.contributors ?? 0, 1),
-    autoDetected: forced ? false : state.teamModeAutoDetected ?? detected.isTeam,
+    autoDetected,
     forced
   };
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists9(path22.join(rootDir, ".mancode", "hooks", "session-start.sh")),
-    pathExists9(
-      path22.join(rootDir, ".mancode", "hooks", "user-prompt-submit.sh")
+    pathExists10(path24.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists10(
+      path24.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -6436,8 +7156,8 @@ async function checkHooks(rootDir) {
 }
 async function isRegistered(rootDir) {
   try {
-    const raw = await fs7.readFile(
-      path22.join(rootDir, ".claude", "settings.json"),
+    const raw = await fs9.readFile(
+      path24.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -6447,32 +7167,32 @@ async function isRegistered(rootDir) {
   }
 }
 function hooksRegistered2(settings) {
-  if (!isRecord8(settings)) return false;
+  if (!isRecord9(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord8(hooks)) return false;
-  return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.sh") && hasHookCommand2(
+  if (!isRecord9(hooks)) return false;
+  return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand2(
     hooks.UserPromptSubmit,
-    ".mancode/hooks/user-prompt-submit.sh"
+    ".mancode/hooks/user-prompt-submit.mjs"
   );
 }
 function hasHookCommand2(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord8(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord9(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord8(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord9(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path22.join(
+  const hookPath = path24.join(
     rootDir,
     ".mancode",
     "hooks",
-    "user-prompt-submit.sh"
+    "user-prompt-submit.mjs"
   );
-  if (!await pathExists9(hookPath)) {
+  if (!await pathExists10(hookPath)) {
     return { tokens: 0, cap: 800 };
   }
   try {
@@ -6487,7 +7207,7 @@ async function estimateHookInjection(rootDir) {
 }
 function runHookEstimate(rootDir, hookPath) {
   return new Promise((resolve, reject) => {
-    const child = spawn("bash", [hookPath], {
+    const child = spawn(process10.execPath, [hookPath], {
       cwd: rootDir,
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -6502,15 +7222,15 @@ function runHookEstimate(rootDir, hookPath) {
       child.kill();
       finish(() => reject(new Error("hook estimate timed out")));
     }, HOOK_ESTIMATE_TIMEOUT_MS);
-    let stdout = "";
+    let stdout2 = "";
     child.stdout.setEncoding("utf-8");
     child.stdout.on("data", (chunk) => {
-      stdout += chunk;
+      stdout2 += chunk;
     });
     child.on("error", (err) => finish(() => reject(err)));
     child.on("close", (code) => {
       finish(() => {
-        if (code === 0) resolve(stdout);
+        if (code === 0) resolve(stdout2);
         else reject(new Error(`hook exited with ${code}`));
       });
     });
@@ -6529,6 +7249,11 @@ function printText(r) {
   console.log(`Style:       ${r.uiLibrary}`);
   console.log(`Initialized: ${r.initializedAt}`);
   console.log(`Team:        ${formatTeamStatus(r.team)}`);
+  if (r.projectRefreshRecommended) {
+    console.log(
+      "Project:     new Git or project files detected; run `mancode refresh-project`."
+    );
+  }
   if (r.currentWorkflow) {
     const stepMax = workflowStepMax(r.currentWorkflow.mode);
     console.log(
@@ -6571,9 +7296,9 @@ function printText(r) {
   console.log("");
   if (r.platforms.includes("claude-code")) {
     console.log("Hooks:");
-    console.log(`  ${r.hooks.sessionStart ? "\u2713" : "\u2717"} session-start.sh`);
+    console.log(`  ${r.hooks.sessionStart ? "\u2713" : "\u2717"} session-start.mjs`);
     console.log(
-      `  ${r.hooks.userPromptSubmit ? "\u2713" : "\u2717"} user-prompt-submit.sh`
+      `  ${r.hooks.userPromptSubmit ? "\u2713" : "\u2717"} user-prompt-submit.mjs`
     );
     console.log(
       `  ${r.hooks.registered ? "\u2713" : "\u2717"} registered in .claude/settings.json`
@@ -6592,12 +7317,12 @@ function formatTeamStatus(team) {
 function workflowStepMax(mode) {
   return maxWorkflowStep(mode);
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null;
 }
-async function pathExists9(p) {
+async function pathExists10(p) {
   try {
-    await fs7.access(p);
+    await fs9.access(p);
     return true;
   } catch {
     return false;
@@ -6605,18 +7330,18 @@ async function pathExists9(p) {
 }
 
 // src/commands/uninstall.ts
-import { access as access4, readFile as readFile11, rm as rm5, writeFile as writeFile12 } from "fs/promises";
-import path23 from "path";
-import process8 from "process";
-var EXIT_OK7 = 0;
-var EXIT_NOT_INITIALIZED5 = 1;
+import { access as access5, readFile as readFile11, rm as rm5, writeFile as writeFile12 } from "fs/promises";
+import path25 from "path";
+import process11 from "process";
+var EXIT_OK8 = 0;
+var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
-async function uninstall(rootDir = process8.cwd(), platform, options = {}) {
-  const stateFile = path23.join(rootDir, ".mancode", "state.json");
-  if (!await pathExists10(stateFile)) {
+async function uninstall(rootDir = process11.cwd(), platform, options = {}) {
+  const stateFile = path25.join(rootDir, ".mancode", "state.json");
+  if (!await pathExists11(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED5;
+    return EXIT_NOT_INITIALIZED6;
   }
   const removeAll = !platform || options.all;
   if (platform) {
@@ -6641,7 +7366,7 @@ async function uninstall(rootDir = process8.cwd(), platform, options = {}) {
     await uninstallPlatform(rootDir, platform ?? "claude-code");
   }
   console.log("\u2713  Uninstall complete.");
-  return EXIT_OK7;
+  return EXIT_OK8;
 }
 async function uninstallPlatform(rootDir, platform) {
   console.log(`\u2713  Removing ${formatPlatformName(platform)} adapter...`);
@@ -6664,7 +7389,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm5(path23.join(rootDir, ".mancode"), {
+  await rm5(path25.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -6674,7 +7399,7 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path23.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path25.join(rootDir, ".claude", "settings.json");
   let content;
   try {
     content = await readFile11(settingsPath, "utf-8");
@@ -6688,14 +7413,14 @@ async function cleanClaudeSettings(rootDir) {
     return;
   }
   const cleanedHooks = {};
-  if (isRecord9(settings.hooks)) {
+  if (isRecord10(settings.hooks)) {
     for (const [event, value] of Object.entries(settings.hooks)) {
       const cleaned = cleanClaudeHookValue(value);
       if (cleaned !== void 0) cleanedHooks[event] = cleaned;
     }
     settings.hooks = Object.keys(cleanedHooks).length > 0 ? cleanedHooks : void 0;
   }
-  if (isRecord9(settings.skills)) {
+  if (isRecord10(settings.skills)) {
     const retainedSkills = Object.fromEntries(
       Object.entries(settings.skills).filter(
         ([name, value]) => LEGACY_CLAUDE_SKILL_SETTINGS[name] !== value
@@ -6715,7 +7440,7 @@ function cleanClaudeHookValue(value) {
     const entries2 = value.flatMap(cleanClaudeHookEntry);
     return entries2.length > 0 ? entries2 : void 0;
   }
-  if (!isRecord9(value)) return value;
+  if (!isRecord10(value)) return value;
   if (Array.isArray(value.hooks) || typeof value.command === "string") {
     const entries2 = cleanClaudeHookEntry(value);
     return entries2.length > 0 ? entries2 : void 0;
@@ -6729,7 +7454,7 @@ function cleanClaudeHookValue(value) {
 }
 function cleanClaudeHookEntry(entry) {
   if (Array.isArray(entry)) return entry.flatMap(cleanClaudeHookEntry);
-  if (!isRecord9(entry)) return [entry];
+  if (!isRecord10(entry)) return [entry];
   if (Array.isArray(entry.hooks)) {
     const hooks = entry.hooks.filter((hook) => !isMancodeHookEntry(hook));
     return hooks.length > 0 ? [{ ...entry, hooks }] : [];
@@ -6737,11 +7462,11 @@ function cleanClaudeHookEntry(entry) {
   return isMancodeHookEntry(entry) ? [] : [entry];
 }
 function isMancodeHookEntry(value) {
-  return isRecord9(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
+  return isRecord10(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
 }
 function containsLegacyMancodeHookPath2(value) {
   if (Array.isArray(value)) return value.some(containsLegacyMancodeHookPath2);
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   if (typeof value.command === "string" && value.command.includes(".mancode/hooks/")) {
     return true;
   }
@@ -6752,7 +7477,7 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path23.join(rootDir, "AGENTS.md");
+  const agentsPath = path25.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile11(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
@@ -6767,7 +7492,7 @@ async function uninstallCodex(rootDir) {
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path23.join(
+  const instructionsPath = path25.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
@@ -6786,7 +7511,7 @@ async function uninstallCopilot(rootDir) {
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path23.join(rootDir, "AGENTS.md");
+  const agentsPath = path25.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile11(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -6805,13 +7530,13 @@ async function uninstallZcode(rootDir) {
   await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path23.join(rootDir, ".mancode", "config.json");
+  const configPath = path25.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await readFile11(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
-      if (isRecord9(config.platformOptions)) {
+      if (isRecord10(config.platformOptions)) {
         const platformOptions = Object.fromEntries(
           Object.entries(config.platformOptions).filter(
             ([name]) => name !== platform
@@ -6829,12 +7554,12 @@ async function removeFromConfig(rootDir, platform) {
   } catch {
   }
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function pathExists10(p) {
+async function pathExists11(p) {
   try {
-    await access4(p);
+    await access5(p);
     return true;
   } catch {
     return false;
@@ -6842,30 +7567,30 @@ async function pathExists10(p) {
 }
 
 // src/commands/version.ts
-import process9 from "process";
+import process12 from "process";
 function version() {
-  const nodeVersion = process9.version;
-  const platform = `${process9.platform}/${process9.arch}`;
+  const nodeVersion = process12.version;
+  const platform = `${process12.platform}/${process12.arch}`;
   console.log(`mancode/${VERSION}`);
   console.log(`node/${nodeVersion.replace("v", "")}`);
   console.log(platform);
 }
 
 // src/commands/workflow.ts
-import { access as access5 } from "fs/promises";
-import path24 from "path";
-var EXIT_OK8 = 0;
-var EXIT_NOT_INITIALIZED6 = 1;
+import { access as access6 } from "fs/promises";
+import path26 from "path";
+var EXIT_OK9 = 0;
+var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_INVALID_ARG2 = 2;
 async function workflow(rootDir, subcommand, args = [], options = {}) {
-  if (!await pathExists11(path24.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists12(path26.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
       console.error("\u2717  mancode not initialized.");
       console.error("   Run `mancode init` to get started.");
     }
-    return EXIT_NOT_INITIALIZED6;
+    return EXIT_NOT_INITIALIZED7;
   }
   switch (subcommand) {
     case "create":
@@ -6914,7 +7639,7 @@ async function workflowReview(rootDir, args, options) {
     if (!ledger)
       return invalidArg(options, `review not initialized: ${taskId}`);
     outputReviewLedger(ledger, options);
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   if (meta.status !== "in_progress" || meta.currentStep < 6) {
     return invalidArg(
@@ -6971,7 +7696,7 @@ async function workflowReview(rootDir, args, options) {
       );
     }
     outputReviewLedger(ledger, options);
-    return EXIT_OK8;
+    return EXIT_OK9;
   } catch (error) {
     return invalidArg(
       options,
@@ -7027,7 +7752,7 @@ async function workflowCreate(rootDir, args, options) {
       error instanceof Error ? error.message : "unable to create workflow"
     );
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowUpdate(rootDir, taskId, options) {
   if (!taskId) {
@@ -7125,18 +7850,18 @@ async function workflowUpdate(rootDir, taskId, options) {
   } else {
     console.log(`Updated workflow: ${taskId}`);
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowList(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
   const views = attachActiveChildren(workflows);
   if (options.json) {
     console.log(JSON.stringify(views, null, 2));
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   if (workflows.length === 0) {
     console.log("No workflows.");
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   const inProgress = workflows.filter((w) => w.status === "in_progress").length;
   console.log(
@@ -7146,7 +7871,7 @@ async function workflowList(rootDir, options) {
   for (const meta of views) {
     console.log(formatWorkflowRow(meta));
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowShow(rootDir, taskId, options) {
   if (!taskId) {
@@ -7183,7 +7908,7 @@ async function workflowShow(rootDir, taskId, options) {
         2
       )
     );
-    return EXIT_OK8;
+    return EXIT_OK9;
   }
   console.log(`Workflow:    ${meta.taskId}`);
   console.log(`Task:        ${meta.task}`);
@@ -7210,7 +7935,7 @@ async function workflowShow(rootDir, taskId, options) {
       }
     }
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function workflowClean(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
@@ -7278,7 +8003,7 @@ async function workflowClean(rootDir, options) {
   } else {
     console.log(`Removed ${removed.length} workflow(s).`);
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 function formatWorkflowRow(meta) {
   const stepMax = maxWorkflowStep(meta.mode);
@@ -7337,9 +8062,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 access5(p);
+    await access6(p);
     return true;
   } catch {
     return false;
@@ -7350,8 +8075,11 @@ async function pathExists11(p) {
 program.name("mancode").description(
   "AI coding agent harness. Modes: solo, man, mamba, manteam, manps."
 ).version(VERSION);
-program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platform>", "Initial adapter platform (MVP-3)").action(async (options) => {
-  const code = await init(process.cwd(), options);
+program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
+  const code = await init(process.cwd(), {
+    ...options,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  });
   process.exitCode = code;
 });
 program.command("install [platform]").description(
@@ -7397,6 +8125,12 @@ program.command("refresh-style").description("Refresh project profile and rescan
   const code = await refreshStyle(process.cwd());
   process.exitCode = code;
 });
+program.command("refresh-project").description(
+  "Refresh detected project facts after adding Git or project files"
+).action(async () => {
+  const code = await refreshProject(process.cwd());
+  process.exitCode = code;
+});
 program.command("version").description("Show version, node version, and platform").action(() => {
   version();
 });