@nick848/fet 1.0.6 → 1.0.7

package/dist/cli/index.js

@@ -8,9 +8,28 @@ import {
 import { createInterface } from "readline/promises";
 import { Command } from "commander";
 
-// src/commands/init.ts
-import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import { join as join8 } from "path";
+// src/commands/doctor.ts
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/context-placeholders.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var AGENTS_LLM_PLACEHOLDER_PATTERN = /\[NEEDS? LLM INPUT\]/g;
+async function countAgentsLlmPlaceholders(projectRoot) {
+  try {
+    const content = await readFile(join(projectRoot, "AGENTS.md"), "utf8");
+    return [...content.matchAll(AGENTS_LLM_PLACEHOLDER_PATTERN)].length;
+  } catch {
+    return 0;
+  }
+}
+function renderAgentsPlaceholderWarning(count2, language = "zh-CN") {
+  if (language === "en") {
+    return `AGENTS.md still contains ${count2} LLM placeholder(s). Run fet fill-context first so your IDE AI can replace them. Continuing current command.`;
+  }
+  return `AGENTS.md \u4ECD\u6709 ${count2} \u4E2A LLM \u5360\u4F4D\u7B26\u3002\u5EFA\u8BAE\u5148\u8FD0\u884C fet fill-context\uFF0C\u8BA9 IDE AI \u8865\u9F50\u9879\u76EE\u4E0A\u4E0B\u6587\uFF1B\u5F53\u524D\u547D\u4EE4\u4F1A\u7EE7\u7EED\u6267\u884C\u3002`;
+}
 
 // src/fs/atomic-write.ts
 import { dirname } from "path";
@@ -31,7 +50,7 @@ async function atomicWrite(targetPath, content) {
 
 // src/fs/backup.ts
 import { copyFile, stat } from "fs/promises";
-import { basename, dirname as dirname2, join } from "path";
+import { basename, dirname as dirname2, join as join2 } from "path";
 async function createBackup(filePath) {
   try {
     await stat(filePath);
@@ -39,17 +58,17 @@ async function createBackup(filePath) {
     return null;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
-  const backupPath = join(dirname2(filePath), `${basename(filePath)}.fet-backup-${timestamp}`);
+  const backupPath = join2(dirname2(filePath), `${basename(filePath)}.fet-backup-${timestamp}`);
   await copyFile(filePath, backupPath);
   return backupPath;
 }
 
 // src/fs/lock.ts
 import { hostname } from "os";
-import { dirname as dirname3, join as join2 } from "path";
-import { mkdir as mkdir2, open as open2, readFile, rm } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+import { mkdir as mkdir2, open as open2, readFile as readFile2, rm } from "fs/promises";
 async function withProjectLock(projectRoot, metadata, fn) {
-  const lockPath = join2(projectRoot, "openspec", ".fet.lock");
+  const lockPath = join3(projectRoot, "openspec", ".fet.lock");
   const lock = {
     pid: process.pid,
     hostname: hostname(),
@@ -81,13 +100,13 @@ async function withProjectLock(projectRoot, metadata, fn) {
 }
 async function readExistingLock(lockPath) {
   try {
-    return JSON.parse(await readFile(lockPath, "utf8"));
+    return JSON.parse(await readFile2(lockPath, "utf8"));
   } catch {
     return { path: lockPath };
   }
 }
 async function clearLock(projectRoot) {
-  const lockPath = join2(projectRoot, "openspec", ".fet.lock");
+  const lockPath = join3(projectRoot, "openspec", ".fet.lock");
   try {
     await rm(lockPath);
     return true;
@@ -97,8 +116,8 @@ async function clearLock(projectRoot) {
 }
 
 // src/fs/journal.ts
-import { join as join3 } from "path";
-import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { readFile as readFile3 } from "fs/promises";
 function createInitJournal(fetVersion) {
   return {
     schemaVersion: 1,
@@ -110,7 +129,7 @@ function createInitJournal(fetVersion) {
 }
 async function writeInitJournal(projectRoot, journal) {
   await atomicWrite(
-    join3(projectRoot, "openspec", ".fet-init-journal.json"),
+    join4(projectRoot, "openspec", ".fet-init-journal.json"),
     `${JSON.stringify(journal, null, 2)}
 `
   );
@@ -119,7 +138,7 @@ async function writeInitJournal(projectRoot, journal) {
 // src/gitnexus.ts
 import { execFile } from "child_process";
 import { stat as stat2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var DEFAULT_GRAPH_PATH = ".gitnexus";
@@ -165,7 +184,7 @@ function toGitNexusState(detection, previous) {
 }
 async function inspectGitNexusGraph(projectRoot, env = process.env) {
   const relative2 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
-  const graphPath = join4(projectRoot, relative2);
+  const graphPath = join5(projectRoot, relative2);
   try {
     const info = await stat2(graphPath);
     return {
@@ -213,11 +232,17 @@ function mergeGitNexusGraphInfo(state, graph2) {
     lastIndexedAt: graph2.lastIndexedAt
   };
 }
-function renderGitNexusRecommendation(state) {
+function renderGitNexusRecommendation(state, language = "zh-CN") {
+  if (language === "en") {
+    if (state.installed) {
+      return `Optional GitNexus detected (${state.version ?? "unknown"}). You can generate a code graph after init; future OpenSpec artifacts should prefer the graph when it is available.`;
+    }
+    return "Optional GitNexus code graph support is not installed. Consider installing GitNexus later to speed up OpenSpec artifact generation and improve code insertion context.";
+  }
   if (state.installed) {
-    return `Optional GitNexus detected (${state.version ?? "unknown"}). You can generate a code graph after init; future OpenSpec artifacts should prefer the graph when it is available.`;
+    return `\u68C0\u6D4B\u5230\u53EF\u9009 GitNexus\uFF08${state.version ?? "unknown"}\uFF09\u3002\u521D\u59CB\u5316\u540E\u53EF\u4EE5\u751F\u6210\u4EE3\u7801\u56FE\uFF1B\u540E\u7EED OpenSpec \u4EA7\u7269\u5728\u56FE\u53EF\u7528\u65F6\u5E94\u4F18\u5148\u53C2\u8003\u5B83\u3002`;
   }
-  return "Optional GitNexus code graph support is not installed. Consider installing GitNexus later to speed up OpenSpec artifact generation and improve code insertion context.";
+  return "\u672A\u5B89\u88C5\u53EF\u9009\u7684 GitNexus \u4EE3\u7801\u56FE\u652F\u6301\u3002\u53EF\u4EE5\u7A0D\u540E\u5B89\u88C5 GitNexus\uFF0C\u4EE5\u52A0\u901F OpenSpec \u4EA7\u7269\u751F\u6210\u5E76\u6539\u5584\u4EE3\u7801\u63D2\u5165\u4E0A\u4E0B\u6587\u3002";
 }
 function resolveGitNexusCommand(env) {
   const raw = env.FET_GITNEXUS_COMMAND?.trim() || env.FET_GITNEXUS_EXECUTABLE?.trim() || "gitnexus";
@@ -230,946 +255,1078 @@ function splitCommand(value) {
   return (matches?.length ? matches : [value]).map((part) => part.replace(/^["']|["']$/g, ""));
 }
 
-// src/version.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname as dirname4, join as join5, parse } from "path";
-import { fileURLToPath } from "url";
-var FET_VERSION = readPackageVersion();
-function readPackageVersion() {
-  let currentDir = dirname4(fileURLToPath(import.meta.url));
-  const root = parse(currentDir).root;
-  while (true) {
-    const packageJsonPath = join5(currentDir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-      if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-        return packageJson.version;
-      }
-      throw new Error(`package.json \u7F3A\u5C11\u6709\u6548\u7684 version \u5B57\u6BB5: ${packageJsonPath}`);
-    }
-    if (currentDir === root) {
-      throw new Error("\u65E0\u6CD5\u5B9A\u4F4D FET package.json");
+// src/commands/doctor.ts
+async function doctorCommand(ctx, options = {}) {
+  const checks = [];
+  checks.push(await checkOpenSpec(ctx));
+  checks.push(await checkState(ctx));
+  checks.push(await checkFile("agents", join6(ctx.projectRoot, "AGENTS.md"), "AGENTS.md \u7F3A\u5931", "fet update-context"));
+  checks.push(await checkFile("config", join6(ctx.projectRoot, "openspec", "config.yaml"), "openspec/config.yaml \u7F3A\u5931", "fet init"));
+  checks.push(await checkPlaceholders(ctx.projectRoot));
+  checks.push(await checkGitNexus(ctx));
+  for (const adapter of ctx.toolAdapters) {
+    checks.push(...await adapter.doctor(ctx.projectRoot));
+  }
+  const lockPath = join6(ctx.projectRoot, "openspec", ".fet.lock");
+  if (await exists(lockPath)) {
+    if (options.fixLock) {
+      await clearLock(ctx.projectRoot);
+      checks.push({ id: "lock", status: "pass", message: "\u5DF2\u6E05\u7406 openspec/.fet.lock" });
+    } else {
+      checks.push({ id: "lock", status: "warn", message: "\u5B58\u5728 openspec/.fet.lock", suggestedCommand: "fet doctor --fix-lock" });
     }
-    currentDir = dirname4(currentDir);
   }
+  const warnings = checks.filter((check) => check.status !== "pass").map((check) => check.message);
+  ctx.output.result({
+    ok: true,
+    command: "doctor",
+    summary: warnings.length ? `\u8BCA\u65AD\u5B8C\u6210\uFF0C\u53D1\u73B0 ${warnings.length} \u4E2A\u9700\u8981\u5173\u6CE8\u7684\u95EE\u9898\u3002` : "\u8BCA\u65AD\u5B8C\u6210\uFF0C\u672A\u53D1\u73B0\u660E\u663E\u95EE\u9898\u3002",
+    warnings,
+    data: checks
+  });
 }
-
-// src/templates/markers.ts
-var AUTO_BEGIN = "<!-- FET:BEGIN AUTO -->";
-var AUTO_END = "<!-- FET:END AUTO -->";
-var USER_BEGIN = "<!-- FET:BEGIN USER -->";
-var USER_END = "<!-- FET:END USER -->";
-var LLM_PLACEHOLDER_PATTERN = /\[NEEDS? LLM INPUT\]/;
-function hasManagedAutoRegion(content) {
-  return count(content, AUTO_BEGIN) === 1 && count(content, AUTO_END) === 1 && content.indexOf(AUTO_BEGIN) < content.indexOf(AUTO_END);
-}
-function hasInvalidManagedAutoRegion(content) {
-  const beginCount = count(content, AUTO_BEGIN);
-  const endCount = count(content, AUTO_END);
-  return beginCount !== endCount || beginCount > 1 || endCount > 1 || beginCount === 1 && content.indexOf(AUTO_BEGIN) > content.indexOf(AUTO_END);
-}
-function replaceManagedRegion(existing, generated) {
-  if (!existing) {
-    return generated;
-  }
-  const start = existing.indexOf(AUTO_BEGIN);
-  const end = existing.indexOf(AUTO_END);
-  if (start === -1 || end === -1 || end < start) {
-    return generated;
+async function checkGitNexus(ctx) {
+  const global = await ctx.stateStore.readGlobal();
+  const state = mergeGitNexusGraphInfo(
+    toGitNexusState(await detectGitNexus(), global?.graph?.gitnexus),
+    await inspectGitNexusGraph(ctx.projectRoot)
+  );
+  if (global) {
+    global.graph ??= {};
+    global.graph.gitnexus = state;
+    await ctx.stateStore.writeGlobal(global);
   }
-  const before = existing.slice(0, start);
-  const after = existing.slice(end + AUTO_END.length);
-  const existingAuto = extractAuto(existing);
-  const generatedAuto = extractAuto(generated);
-  return `${before}${AUTO_BEGIN}
-${mergeAutoRegion(existingAuto, generatedAuto)}
-${AUTO_END}${after}`;
+  return state.installed ? {
+    id: "gitnexus",
+    status: "pass",
+    message: `GitNexus detected: ${state.executablePath ?? "gitnexus"} (${state.version ?? "unknown"}), graph ${state.graphExists ? "found" : "not found"}`
+  } : {
+    id: "gitnexus",
+    status: "warn",
+    message: "Optional GitNexus code graph support is not installed",
+    suggestedCommand: "Install GitNexus later if you want OpenSpec artifacts to prefer a repository graph"
+  };
 }
-function mergeAutoRegion(existingAuto, generatedAuto) {
-  const generatedSections = splitMarkdownSections(generatedAuto);
-  const existingSections = new Map(splitMarkdownSections(existingAuto).map((section) => [section.heading, section]));
-  if (!generatedSections.length || !existingSections.size) {
-    return generatedAuto;
+async function checkOpenSpec(ctx) {
+  try {
+    const identity = await ctx.openSpec.resolveExecutable();
+    return { id: "openspec", status: "pass", message: `OpenSpec: ${identity.executablePath} (${identity.version})` };
+  } catch (error) {
+    return { id: "openspec", status: "fail", message: error instanceof Error ? error.message : "OpenSpec \u68C0\u6D4B\u5931\u8D25" };
   }
-  return generatedSections.map((section) => {
-    const existing = existingSections.get(section.heading);
-    if (existing && LLM_PLACEHOLDER_PATTERN.test(section.body) && !LLM_PLACEHOLDER_PATTERN.test(existing.body)) {
-      return existing.raw.trim();
-    }
-    return section.raw.trim();
-  }).join("\n\n");
 }
-function splitMarkdownSections(content) {
-  const matches = [...content.matchAll(/^## .+$/gm)];
-  if (!matches.length) {
-    return [];
+async function checkState(ctx) {
+  try {
+    const state = await ctx.stateStore.readGlobal();
+    return state ? { id: "state", status: "pass", message: "FET \u5168\u5C40\u72B6\u6001\u53EF\u8BFB\u53D6" } : { id: "state", status: "warn", message: "FET \u5168\u5C40\u72B6\u6001\u5C1A\u672A\u521D\u59CB\u5316", suggestedCommand: "fet init" };
+  } catch (error) {
+    return { id: "state", status: "fail", message: error instanceof Error ? error.message : "FET \u72B6\u6001\u8BFB\u53D6\u5931\u8D25" };
   }
-  return matches.map((match, index) => {
-    const start = match.index ?? 0;
-    const end = matches[index + 1]?.index ?? content.length;
-    const raw = content.slice(start, end).trim();
-    const newline = raw.indexOf("\n");
-    const heading = newline === -1 ? raw.trim() : raw.slice(0, newline).trim();
-    const body = newline === -1 ? "" : raw.slice(newline + 1).trim();
-    return { heading, body, raw };
-  });
 }
-function extractAuto(content) {
-  const start = content.indexOf(AUTO_BEGIN);
-  const end = content.indexOf(AUTO_END);
-  if (start === -1 || end === -1 || end < start) {
-    return content.trim();
+async function checkFile(id, path, missing, suggestedCommand) {
+  return await exists(path) ? { id, status: "pass", message: `${id} \u5B58\u5728` } : { id, status: "warn", message: missing, suggestedCommand };
+}
+async function checkPlaceholders(projectRoot) {
+  try {
+    await readFile4(join6(projectRoot, "AGENTS.md"), "utf8");
+    const count2 = await countAgentsLlmPlaceholders(projectRoot);
+    return count2 ? {
+      id: "context-placeholders",
+      status: "warn",
+      message: `AGENTS.md has ${count2} LLM placeholder(s)`,
+      suggestedCommand: "fet fill-context"
+    } : { id: "context-placeholders", status: "pass", message: "AGENTS.md placeholders resolved" };
+  } catch {
+    return { id: "context-placeholders", status: "warn", message: "AGENTS.md missing", suggestedCommand: "fet update-context" };
   }
-  return content.slice(start + AUTO_BEGIN.length, end).trim();
 }
-function count(content, needle) {
-  return content.split(needle).length - 1;
+async function exists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// src/templates/agents-md.ts
-function renderAgentsMd(scan) {
-  const commands = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
-  const routes = scan.routes.map((route) => `| ${route.path} | ${route.source} | ${route.confidence}${route.inferred ? " inferred" : ""} |`).join("\n");
-  const workspaces = scan.project.workspaces.map((workspace) => `| ${workspace.name} | ${workspace.path} | ${workspace.source} |`).join("\n");
-  return `# Project Context
-
-${AUTO_BEGIN}
-## Project Snapshot
-
-- Name: ${scan.project.name}
-- Package Manager: ${scan.project.packageManager} (${scan.project.packageManagerConfidence})
-- Framework: ${scan.project.framework.name} (${scan.project.framework.confidence})
-- Language: ${scan.project.language}
-- Monorepo: ${scan.project.monorepo ? "yes" : "no"}
-
-## Workspaces
-
-| Name | Path | Source |
-|------|------|--------|
-${workspaces || "| root | . | inferred |"}
-
-## Commands
-
-| Name | Command | Source |
-|------|---------|--------|
-${commands || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
-
-## Structure
-
-[NEEDS LLM INPUT]
+// src/commands/fill-context.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7 } from "path";
+async function fillContextCommand(ctx) {
+  await withProjectLock(ctx.projectRoot, { command: "fill-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    const handoffPath = join7(ctx.projectRoot, ".fet", "fill-context.md");
+    await mkdir3(dirname4(handoffPath), { recursive: true });
+    await atomicWrite(handoffPath, renderGenericHandoff(ctx.language));
+    for (const adapter of ctx.toolAdapters) {
+      const plan = await adapter.planInstall(ctx.projectRoot, ctx.language);
+      const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
+      const state = await ctx.stateStore.getOrCreateGlobal();
+      state.toolAdapters[adapter.tool] = {
+        adapterVersion: adapter.adapterVersion,
+        installed: true,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await ctx.stateStore.writeGlobal(state);
+      if (ctx.verbose) {
+        ctx.output.info(ctx.language === "en" ? `Updated ${adapter.tool} adapter` : `\u5DF2\u66F4\u65B0 ${adapter.tool} \u9002\u914D\u5668`, { written: result.written });
+      }
+    }
+  });
+  const placeholders = await countAgentsLlmPlaceholders(ctx.projectRoot);
+  ctx.output.result({
+    ok: true,
+    command: "fill-context",
+    summary: ctx.language === "en" ? placeholders ? `Found ${placeholders} AGENTS.md placeholder(s). Use your IDE AI to fill them.` : "No AGENTS.md placeholders found. IDE fill-context commands were refreshed." : placeholders ? `\u53D1\u73B0 ${placeholders} \u4E2A AGENTS.md \u5360\u4F4D\u7B26\u3002\u8BF7\u4F7F\u7528 IDE AI \u8865\u9F50\u3002` : "\u672A\u53D1\u73B0 AGENTS.md \u5360\u4F4D\u7B26\uFF0C\u5DF2\u5237\u65B0 IDE fill-context \u547D\u4EE4\u3002",
+    nextSteps: ctx.language === "en" ? placeholders ? [
+      "Cursor: run /fet-fill-context",
+      "Codex: run /prompts:fet-fill-context",
+      "OpenCode or other IDEs: open .fet/fill-context.md or run fet fill-context for handoff instructions"
+    ] : ["Run fet doctor to confirm project context health"] : placeholders ? [
+      "Cursor\uFF1A\u8FD0\u884C /fet-fill-context",
+      "Codex\uFF1A\u8FD0\u884C /prompts:fet-fill-context",
+      "OpenCode \u6216\u5176\u4ED6 IDE\uFF1A\u6253\u5F00 .fet/fill-context.md\uFF0C\u6216\u8FD0\u884C fet fill-context \u67E5\u770B\u4EA4\u63A5\u8BF4\u660E"
+    ] : ["\u8FD0\u884C fet doctor \u786E\u8BA4\u9879\u76EE\u4E0A\u4E0B\u6587\u72B6\u6001"],
+    data: {
+      placeholders,
+      cursorCommand: "/fet-fill-context",
+      codexCommand: "/prompts:fet-fill-context"
+    }
+  });
+}
+function renderGenericHandoff(language) {
+  if (language === "en") {
+    return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: fill-context
+FET:END -->
 
-## Routes
+# FET Fill Context
 
-| Route | Source | Confidence |
-|-------|--------|------------|
-${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
+Use the IDE AI to complete FET-generated placeholders.
 
-## Conventions
+1. Read AGENTS.md and openspec/config.yaml.
+2. Read .fet/karpathy-guidelines.md when it exists. For Codex, also read .codex/fet/karpathy-guidelines.md when it exists.
+3. Inspect README files, package scripts, routes, tests, source layout, and project conventions.
+4. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content.
+5. Preserve FET managed markers.
+6. Do not modify business code.
+7. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
+`;
+  }
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: fill-context
+FET:END -->
 
-[NEEDS LLM INPUT]
+# FET \u586B\u5145\u4E0A\u4E0B\u6587
 
-## AI Work Guidelines
+\u4F7F\u7528 IDE AI \u8865\u9F50 FET \u751F\u6210\u7684\u9879\u76EE\u4E0A\u4E0B\u6587\u5360\u4F4D\u7B26\u3002
 
-- Prefer the project-level Andrej Karpathy inspired guidelines in .fet/karpathy-guidelines.md when using FET-managed IDE workflows.
-- For Codex, also read .codex/fet/karpathy-guidelines.md when present.
-- Treat those guidelines as secondary to the user's latest request and explicit OpenSpec artifacts.
+1. \u9605\u8BFB AGENTS.md \u548C openspec/config.yaml\u3002
+2. \u5982\u679C\u5B58\u5728 .fet/karpathy-guidelines.md\uFF0C\u8BF7\u4E00\u5E76\u9605\u8BFB\u3002\u5BF9 Codex\uFF0C\u5982\u679C\u5B58\u5728 .codex/fet/karpathy-guidelines.md\uFF0C\u4E5F\u8981\u9605\u8BFB\u3002
+3. \u68C0\u67E5 README\u3001package scripts\u3001\u8DEF\u7531\u3001\u6D4B\u8BD5\u3001\u6E90\u7801\u7ED3\u6784\u548C\u9879\u76EE\u7EA6\u5B9A\u3002
+4. \u5C06 AGENTS.md \u4E2D\u6BCF\u4E2A \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002
+5. \u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\u3002
+6. \u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
+7. \u8FD0\u884C \`fet doctor\`\uFF0C\u786E\u8BA4\u4E0D\u518D\u6709 AGENTS.md \u5360\u4F4D\u7B26\u8B66\u544A\u3002
+`;
+}
 
-## Scanner Metadata
+// src/commands/graph.ts
+import { mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname5, join as join8 } from "path";
+async function graphCommand(ctx, action, args = []) {
+  switch (action) {
+    case "status":
+      await graphStatusCommand(ctx);
+      return;
+    case "doctor":
+      await graphDoctorCommand(ctx);
+      return;
+    case "setup":
+      await graphSetupCommand(ctx);
+      return;
+    case "handoff":
+      await graphHandoffCommand(ctx);
+      return;
+    case "init":
+      await graphAnalyzeCommand(ctx, "init", args);
+      return;
+    case "refresh":
+      await graphAnalyzeCommand(ctx, "refresh", args);
+      return;
+  }
+}
+async function graphStatusCommand(ctx) {
+  const result = await refreshGraphState(ctx, { runStatus: true });
+  const warnings = result.state.installed ? [] : ["GitNexus is not installed. Run fet graph setup for installation handoff instructions."];
+  ctx.output.result({
+    ok: true,
+    command: "graph status",
+    summary: result.state.installed ? `GitNexus graph status checked. Graph ${result.state.graphExists ? "exists" : "does not exist"} at ${result.state.graphPath ?? ".gitnexus"}.` : "GitNexus is not installed. Graph support remains optional.",
+    warnings,
+    nextSteps: result.state.installed && !result.state.graphExists ? ["Run fet graph init to build the first GitNexus graph"] : void 0,
+    data: result
+  });
+}
+async function graphDoctorCommand(ctx) {
+  const result = await refreshGraphState(ctx, { runStatus: true });
+  const warnings = [
+    ...!result.state.installed ? ["GitNexus is not installed."] : [],
+    ...result.state.installed && !result.state.graphExists ? ["GitNexus is installed but no graph directory was found."] : [],
+    ...!result.state.handoffPath ? ["Graph handoff instructions have not been generated."] : []
+  ];
+  ctx.output.result({
+    ok: true,
+    command: "graph doctor",
+    summary: warnings.length ? `Graph doctor completed with ${warnings.length} warning(s).` : "Graph doctor completed without warnings.",
+    warnings,
+    nextSteps: warnings.length ? ["Run fet graph setup", "Run fet graph handoff", "Run fet graph init when GitNexus is installed"] : void 0,
+    data: result
+  });
+}
+async function graphSetupCommand(ctx) {
+  let result;
+  const handoffPath = join8(ctx.projectRoot, ".fet", "graph-setup.md");
+  await withProjectLock(ctx.projectRoot, { command: "graph setup", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    result = await refreshGraphState(ctx, { write: false });
+    await writeHandoffFile(handoffPath, renderGraphSetupHandoff(result.state));
+    const global = await ctx.stateStore.getOrCreateGlobal();
+    global.graph ??= {};
+    global.graph.gitnexus = {
+      ...result.state,
+      setupHandoffPath: ".fet/graph-setup.md",
+      setupHandoffUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await ctx.stateStore.writeGlobal(global);
+  });
+  ctx.output.result({
+    ok: true,
+    command: "graph setup",
+    summary: "GitNexus setup handoff generated.",
+    warnings: result.state.installed ? [] : ["GitNexus is not installed. The handoff explains installation and IDE-assisted setup options."],
+    nextSteps: result.state.installed ? ["Run gitnexus setup if you want to configure IDE/MCP integrations", "Run fet graph init"] : ["Open .fet/graph-setup.md in your IDE AI"],
+    data: {
+      path: ".fet/graph-setup.md",
+      gitnexus: result.state
+    }
+  });
+}
+async function graphHandoffCommand(ctx) {
+  let result;
+  const handoffPath = join8(ctx.projectRoot, ".fet", "graph-handoff.md");
+  await withProjectLock(ctx.projectRoot, { command: "graph handoff", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    result = await refreshGraphState(ctx, { runStatus: true, write: false });
+    await writeHandoffFile(handoffPath, renderGraphUsageHandoff(result.state));
+    const global = await ctx.stateStore.getOrCreateGlobal();
+    global.graph ??= {};
+    global.graph.gitnexus = {
+      ...result.state,
+      handoffPath: ".fet/graph-handoff.md",
+      handoffUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await ctx.stateStore.writeGlobal(global);
+  });
+  ctx.output.result({
+    ok: true,
+    command: "graph handoff",
+    summary: "GitNexus graph usage handoff generated.",
+    warnings: result.state.installed ? [] : ["GitNexus is not installed. The handoff still documents the fallback behavior."],
+    nextSteps: ["Cursor/Codex/OpenCode: read .fet/graph-handoff.md before broad repository scans"],
+    data: {
+      path: ".fet/graph-handoff.md",
+      gitnexus: result.state
+    }
+  });
+}
+async function graphAnalyzeCommand(ctx, mode, args) {
+  const detection = await detectGitNexus();
+  if (!detection.installed) {
+    throw new FetError({
+      code: "GRAPH_PROVIDER_NOT_FOUND" /* GraphProviderNotFound */,
+      message: "GitNexus is not installed or is not available on PATH.",
+      details: { executable: detection.executablePath, error: detection.error },
+      suggestedCommand: "fet graph setup"
+    });
+  }
+  const run = await runGitNexus(["analyze", ...args], { cwd: ctx.projectRoot });
+  if (run.exitCode !== 0) {
+    throw new FetError({
+      code: "GRAPH_COMMAND_FAILED" /* GraphCommandFailed */,
+      message: "GitNexus analyze failed.",
+      details: { command: run.command.join(" "), exitCode: run.exitCode, stdout: run.stdout, stderr: run.stderr },
+      suggestedCommand: "fet graph doctor"
+    });
+  }
+  const result = await refreshGraphState(ctx, { write: false });
+  const global = await ctx.stateStore.getOrCreateGlobal();
+  global.graph ??= {};
+  global.graph.gitnexus = {
+    ...result.state,
+    lastRefreshAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await ctx.stateStore.writeGlobal(global);
+  ctx.output.result({
+    ok: true,
+    command: `graph ${mode}`,
+    summary: mode === "init" ? "GitNexus graph initialized." : "GitNexus graph refreshed.",
+    warnings: result.state.graphExists ? [] : ["GitNexus analyze completed, but the configured graph directory was not found."],
+    nextSteps: ["Run fet graph status", "Use .fet/graph-handoff.md or generated IDE prompts to prefer graph context"],
+    data: {
+      gitnexus: global.graph.gitnexus,
+      run: {
+        command: run.command,
+        stdout: run.stdout.trim(),
+        stderr: run.stderr.trim()
+      }
+    }
+  });
+}
+async function refreshGraphState(ctx, options = {}) {
+  const global = await ctx.stateStore.getOrCreateGlobal();
+  global.graph ??= {};
+  const detection = await detectGitNexus();
+  const graph2 = await inspectGitNexusGraph(ctx.projectRoot);
+  let state = mergeGitNexusGraphInfo(toGitNexusState(detection, global.graph.gitnexus), graph2);
+  let gitnexusStatus = null;
+  if (options.runStatus && detection.installed) {
+    gitnexusStatus = await runGitNexus(["status"], { cwd: ctx.projectRoot });
+    state = {
+      ...state,
+      lastStatus: firstLine(gitnexusStatus.stdout) || firstLine(gitnexusStatus.stderr) || `exit ${gitnexusStatus.exitCode}`
+    };
+  }
+  if (options.write ?? true) {
+    global.graph.gitnexus = state;
+    await ctx.stateStore.writeGlobal(global);
+  }
+  return {
+    state,
+    gitnexusStatus: gitnexusStatus ? {
+      exitCode: gitnexusStatus.exitCode,
+      command: gitnexusStatus.command,
+      stdout: gitnexusStatus.stdout.trim(),
+      stderr: gitnexusStatus.stderr.trim()
+    } : null
+  };
+}
+async function writeHandoffFile(path, content) {
+  await mkdir4(dirname5(path), { recursive: true });
+  await atomicWrite(path, content);
+}
+function renderGraphSetupHandoff(state) {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: graph-setup
+FET:END -->
 
-- Generated At: ${scan.generatedAt}
-- FET Version: ${FET_VERSION}
-- Scanner Version: ${scan.scannerVersion}
-- Warnings: ${scan.warnings.length ? scan.warnings.join("; ") : "none"}
-${AUTO_END}
+# FET Graph Setup
 
-${USER_BEGIN}
-## Notes For AI
+GitNexus graph support is optional. FET does not install GitNexus automatically and does not require graph support for OpenSpec workflows.
 
-[NEEDS LLM INPUT]
-${USER_END}
+Current status:
+
+- Installed: ${state.installed ? "yes" : "no"}
+- Executable: ${state.executablePath ?? "gitnexus"}
+- Version: ${state.version ?? "unknown"}
+- Graph path: ${state.graphPath ?? ".gitnexus"}
+- Graph exists: ${state.graphExists ? "yes" : "no"}
+
+Suggested setup flow:
+
+1. If GitNexus is not installed, install it using the method recommended by the GitNexus project.
+2. If you want GitNexus MCP or IDE integration, run \`gitnexus setup\` yourself after reviewing what it changes.
+3. Return to this project and run \`fet graph init\` to build the first graph.
+4. Run \`fet graph handoff\` so IDE AI can prefer graph context before broad repository scans.
+
+Guardrails:
+
+- Do not block FET/OpenSpec commands when GitNexus is unavailable.
+- Do not generate or modify application code during setup.
+- Do not run global IDE configuration commands unless the user explicitly approves them.
 `;
 }
+function renderGraphUsageHandoff(state) {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: graph-handoff
+FET:END -->
 
-// src/templates/config-yaml.ts
-import { stringify } from "yaml";
-function renderFetConfig(scan) {
-  return stringify({
-    fet: {
-      schemaVersion: 1,
-      generatedAt: scan.generatedAt,
-      fetVersion: FET_VERSION,
-      scannerVersion: scan.scannerVersion,
-      project: {
-        packageManager: scan.project.packageManager,
-        packageManagerConfidence: scan.project.packageManagerConfidence,
-        framework: scan.project.framework,
-        language: scan.project.language,
-        monorepo: scan.project.monorepo,
-        workspaces: scan.project.workspaces
-      },
-      commands: scan.commands,
-      validation: {
-        monorepo: scan.project.monorepo,
-        missing: {
-          lint: "warn",
-          typecheck: "warn",
-          test: "warn"
-        },
-        workspaces: scan.project.workspaces
+# FET Graph Handoff
+
+Use GitNexus graph context as an optional first pass before broad repository scans.
+
+Current status:
+
+- Installed: ${state.installed ? "yes" : "no"}
+- Graph path: ${state.graphPath ?? ".gitnexus"}
+- Graph exists: ${state.graphExists ? "yes" : "no"}
+- Last indexed at: ${state.lastIndexedAt ?? "unknown"}
+- Last status: ${state.lastStatus ?? "unknown"}
+
+When graph context is available:
+
+1. Use the graph to identify likely modules, dependencies, and insertion points.
+2. Read only the concrete source files needed to confirm behavior.
+3. Prefer OpenSpec artifacts and AGENTS.md over graph guesses when they conflict.
+4. Fall back to normal repository inspection if the graph is missing, stale, or incomplete.
+
+When producing OpenSpec artifacts:
+
+- Use graph context to make proposal, design, specs, and tasks more precise.
+- Avoid large repository scans when the graph already narrows the relevant area.
+- Keep all generated artifacts in the normal OpenSpec change directory.
+`;
+}
+function firstLine(value) {
+  return value.trim().split(/\r?\n/)[0]?.trim() || null;
+}
+
+// src/commands/init.ts
+import { readFile as readFile7, stat as stat4 } from "fs/promises";
+import { join as join11 } from "path";
+
+// src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname6, join as join9, parse } from "path";
+import { fileURLToPath } from "url";
+var FET_VERSION = readPackageVersion();
+function readPackageVersion() {
+  let currentDir = dirname6(fileURLToPath(import.meta.url));
+  const root = parse(currentDir).root;
+  while (true) {
+    const packageJsonPath = join9(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+        return packageJson.version;
       }
+      throw new Error(`package.json \u7F3A\u5C11\u6709\u6548\u7684 version \u5B57\u6BB5: ${packageJsonPath}`);
     }
+    if (currentDir === root) {
+      throw new Error("\u65E0\u6CD5\u5B9A\u4F4D FET package.json");
+    }
+    currentDir = dirname6(currentDir);
+  }
+}
+
+// src/templates/markers.ts
+var AUTO_BEGIN = "<!-- FET:BEGIN AUTO -->";
+var AUTO_END = "<!-- FET:END AUTO -->";
+var USER_BEGIN = "<!-- FET:BEGIN USER -->";
+var USER_END = "<!-- FET:END USER -->";
+var LLM_PLACEHOLDER_PATTERN = /\[NEEDS? LLM INPUT\]/;
+function hasManagedAutoRegion(content) {
+  return count(content, AUTO_BEGIN) === 1 && count(content, AUTO_END) === 1 && content.indexOf(AUTO_BEGIN) < content.indexOf(AUTO_END);
+}
+function hasInvalidManagedAutoRegion(content) {
+  const beginCount = count(content, AUTO_BEGIN);
+  const endCount = count(content, AUTO_END);
+  return beginCount !== endCount || beginCount > 1 || endCount > 1 || beginCount === 1 && content.indexOf(AUTO_BEGIN) > content.indexOf(AUTO_END);
+}
+function replaceManagedRegion(existing, generated) {
+  if (!existing) {
+    return generated;
+  }
+  const start = existing.indexOf(AUTO_BEGIN);
+  const end = existing.indexOf(AUTO_END);
+  if (start === -1 || end === -1 || end < start) {
+    return generated;
+  }
+  const before = existing.slice(0, start);
+  const after = existing.slice(end + AUTO_END.length);
+  const existingAuto = extractAuto(existing);
+  const generatedAuto = extractAuto(generated);
+  return `${before}${AUTO_BEGIN}
+${mergeAutoRegion(existingAuto, generatedAuto)}
+${AUTO_END}${after}`;
+}
+function mergeAutoRegion(existingAuto, generatedAuto) {
+  const generatedSections = splitMarkdownSections(generatedAuto);
+  const existingSections = new Map(splitMarkdownSections(existingAuto).map((section) => [sectionKey(section.heading), section]));
+  if (!generatedSections.length || !existingSections.size) {
+    return generatedAuto;
+  }
+  return generatedSections.map((section) => {
+    const existing = existingSections.get(sectionKey(section.heading));
+    if (existing && LLM_PLACEHOLDER_PATTERN.test(section.body) && !LLM_PLACEHOLDER_PATTERN.test(existing.body)) {
+      return existing.raw.trim();
+    }
+    return section.raw.trim();
+  }).join("\n\n");
+}
+function sectionKey(heading) {
+  const normalized = heading.replace(/^##\s+/, "").trim().toLowerCase();
+  const aliases = {
+    "project snapshot": "snapshot",
+    "\u9879\u76EE\u5FEB\u7167": "snapshot",
+    workspaces: "workspaces",
+    "\u5DE5\u4F5C\u533A": "workspaces",
+    commands: "commands",
+    "\u547D\u4EE4": "commands",
+    structure: "structure",
+    "\u7ED3\u6784": "structure",
+    routes: "routes",
+    "\u8DEF\u7531": "routes",
+    conventions: "conventions",
+    "\u7EA6\u5B9A": "conventions",
+    "ai work guidelines": "ai-guidelines",
+    "ai \u5DE5\u4F5C\u6307\u5357": "ai-guidelines",
+    "scanner metadata": "metadata",
+    "\u626B\u63CF\u5143\u6570\u636E": "metadata",
+    "notes for ai": "notes",
+    "\u7ED9 ai \u7684\u5907\u6CE8": "notes"
+  };
+  return aliases[normalized] ?? normalized;
+}
+function splitMarkdownSections(content) {
+  const matches = [...content.matchAll(/^## .+$/gm)];
+  if (!matches.length) {
+    return [];
+  }
+  return matches.map((match, index) => {
+    const start = match.index ?? 0;
+    const end = matches[index + 1]?.index ?? content.length;
+    const raw = content.slice(start, end).trim();
+    const newline = raw.indexOf("\n");
+    const heading = newline === -1 ? raw.trim() : raw.slice(0, newline).trim();
+    const body = newline === -1 ? "" : raw.slice(newline + 1).trim();
+    return { heading, body, raw };
   });
 }
-
-// src/templates/karpathy-skills.ts
-var KARPATHY_SKILLS_SOURCE = "https://github.com/forrestchang/andrej-karpathy-skills";
-var BEGIN = "<!-- FET:BEGIN ANDREJ-KARPATHY-SKILLS -->";
-var END = "<!-- FET:END ANDREJ-KARPATHY-SKILLS -->";
-function mergeKarpathyClaudeMd(existing) {
-  const block = renderManagedBlock(renderKarpathyClaudeGuidelines());
-  if (!existing || !existing.trim()) {
-    return `${block}
-`;
-  }
-  const start = existing.indexOf(BEGIN);
-  const end = existing.indexOf(END);
-  if (start !== -1 && end !== -1 && end > start) {
-    return `${existing.slice(0, start)}${block}${existing.slice(end + END.length)}`;
+function extractAuto(content) {
+  const start = content.indexOf(AUTO_BEGIN);
+  const end = content.indexOf(AUTO_END);
+  if (start === -1 || end === -1 || end < start) {
+    return content.trim();
   }
-  return `${existing.replace(/\s*$/, "")}
-
-${block}
-`;
+  return content.slice(start + AUTO_BEGIN.length, end).trim();
 }
-function renderKarpathyCursorRule() {
-  return `<!-- FET:MANAGED
-schemaVersion: 1
-generator: karpathy-skills
-FET:END -->
-
----
-description: Andrej Karpathy inspired coding guidelines
-alwaysApply: true
----
-
-${renderKarpathyGuidelinesBody()}
-`;
+function count(content, needle) {
+  return content.split(needle).length - 1;
 }
-function renderKarpathyFetHandoff() {
-  return `<!-- FET:MANAGED
-schemaVersion: 1
-generator: karpathy-skills
-FET:END -->
 
-# Andrej Karpathy Inspired Coding Guidelines
-
-${renderKarpathyGuidelinesBody()}
-`;
-}
-function renderManagedBlock(content) {
-  return `${BEGIN}
-${content}
-${END}`;
+// src/templates/agents-md.ts
+function renderAgentsMd(scan, language = "zh-CN") {
+  if (language === "en") {
+    return renderAgentsMdEn(scan);
+  }
+  return renderAgentsMdZh(scan);
 }
-function renderKarpathyClaudeGuidelines() {
-  return `# Andrej Karpathy Inspired Coding Guidelines
+function renderAgentsMdZh(scan) {
+  const commands = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
+  const routes = scan.routes.map((route) => `| ${route.path} | ${route.source} | ${route.confidence}${route.inferred ? " inferred" : ""} |`).join("\n");
+  const workspaces = scan.project.workspaces.map((workspace) => `| ${workspace.name} | ${workspace.path} | ${workspace.source} |`).join("\n");
+  return `# \u9879\u76EE\u4E0A\u4E0B\u6587
 
-${renderKarpathyGuidelinesBody()}`;
-}
-function renderKarpathyGuidelinesBody() {
-  return `Source: ${KARPATHY_SKILLS_SOURCE}
+${AUTO_BEGIN}
+## \u9879\u76EE\u5FEB\u7167
 
-Use these project-level guidelines together with AGENTS.md, OpenSpec artifacts, and the user's latest request.
+- \u540D\u79F0\uFF1A${scan.project.name}
+- \u5305\u7BA1\u7406\u5668\uFF1A${scan.project.packageManager}\uFF08${scan.project.packageManagerConfidence}\uFF09
+- \u6846\u67B6\uFF1A${scan.project.framework.name}\uFF08${scan.project.framework.confidence}\uFF09
+- \u8BED\u8A00\uFF1A${scan.project.language}
+- Monorepo\uFF1A${scan.project.monorepo ? "\u662F" : "\u5426"}
 
-## Think Before Coding
+## \u5DE5\u4F5C\u533A
 
-- State important assumptions before editing.
-- Ask for clarification when ambiguity would change the implementation.
-- Surface tradeoffs instead of silently choosing a risky path.
-- Push back when a simpler approach better fits the request.
+| \u540D\u79F0 | \u8DEF\u5F84 | \u6765\u6E90 |
+|------|------|--------|
+${workspaces || "| root | . | inferred |"}
 
-## Simplicity First
+## \u547D\u4EE4
 
-- Solve the requested problem with the smallest clear change.
-- Avoid speculative features, configuration, or abstraction.
-- Do not create abstractions for one-off code.
-- Prefer deleting complexity introduced by your own change over adding more structure.
+| \u540D\u79F0 | \u547D\u4EE4 | \u6765\u6E90 |
+|------|---------|--------|
+${commands || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
 
-## Precise Edits
+## \u7ED3\u6784
 
-- Touch only files and lines that directly serve the task.
-- Preserve existing style even when you personally prefer another pattern.
-- Do not refactor nearby code, comments, or formatting unless the task requires it.
-- Remove only dead imports, variables, or helpers made obsolete by your own change.
+[NEEDS LLM INPUT]
 
-## Goal-Driven Execution
+## \u8DEF\u7531
 
-- Convert vague work into concrete success criteria.
-- For bugs, prefer a reproducing test or clear verification before the fix.
-- For multi-step work, keep a short plan and verify each meaningful step.
-- Continue iterating until the success criteria are met or a blocker is explicit.
+| \u8DEF\u7531 | \u6765\u6E90 | \u7F6E\u4FE1\u5EA6 |
+|-------|--------|------------|
+${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
 
-These guidelines intentionally favor caution over speed for non-trivial work. For obvious one-line fixes, use judgment and stay lightweight.`;
-}
+## \u7EA6\u5B9A
 
-// src/templates/verify-instructions.ts
-function renderVerifyInstructions(changeId, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  return `---
-schemaVersion: 1
-fetVersion: ${FET_VERSION}
-generatedAt: ${generatedAt}
-changeId: ${changeId}
-purpose: manual-verify
----
+[NEEDS LLM INPUT]
 
-# Verify Instructions
+## AI \u5DE5\u4F5C\u6307\u5357
 
-\u8BF7\u6309\u987A\u5E8F\u5B8C\u6210\u4EE5\u4E0B\u68C0\u67E5\uFF1A
+- \u4F7F\u7528 FET \u6258\u7BA1\u7684 IDE \u5DE5\u4F5C\u6D41\u65F6\uFF0C\u4F18\u5148\u53C2\u8003 .fet/karpathy-guidelines.md \u4E2D\u7684\u9879\u76EE\u7EA7\u6307\u5357\u3002
+- \u5BF9 Codex\uFF0C\u8FD8\u5E94\u5728\u5B58\u5728\u65F6\u9605\u8BFB .codex/fet/karpathy-guidelines.md\u3002
+- \u8FD9\u4E9B\u6307\u5357\u4F4E\u4E8E\u7528\u6237\u6700\u65B0\u8BF7\u6C42\u548C\u660E\u786E\u7684 OpenSpec \u4EA7\u7269\u3002
+- \u9ED8\u8BA4\u4F7F\u7528\u4E2D\u6587\u4EA7\u51FA\u4EA4\u4E92\u4FE1\u606F\u3001\u8BA1\u5212\u6587\u6863\u548C\u5B9E\u73B0\u8BF4\u660E\uFF0C\u9664\u975E\u7528\u6237\u53E6\u6709\u660E\u786E\u8981\u6C42\u3002
 
-1. \u8FD0\u884C OpenSpec \u89C4\u8303\u6821\u9A8C\uFF1A\`openspec verify\`
-2. \u6309\u9879\u76EE\u7EA6\u5B9A\u8FD0\u884C lint\u3001typecheck\u3001test\u3002
-3. \u68C0\u67E5\u672C\u6B21 change \u7684 \`tasks.md\` \u662F\u5426\u4E0E\u5B9E\u73B0\u72B6\u6001\u4E00\u81F4\u3002
+## \u626B\u63CF\u5143\u6570\u636E
 
-\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+- \u751F\u6210\u65F6\u95F4\uFF1A${scan.generatedAt}
+- FET \u7248\u672C\uFF1A${FET_VERSION}
+- \u626B\u63CF\u5668\u7248\u672C\uFF1A${scan.scannerVersion}
+- \u8B66\u544A\uFF1A${scan.warnings.length ? scan.warnings.join("; ") : "\u65E0"}
+${AUTO_END}
 
-\`\`\`sh
-fet verify --done --change ${changeId}
-\`\`\`
+${USER_BEGIN}
+## \u7ED9 AI \u7684\u5907\u6CE8
+
+[NEEDS LLM INPUT]
+${USER_END}
 `;
 }
+function renderAgentsMdEn(scan) {
+  const commands = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
+  const routes = scan.routes.map((route) => `| ${route.path} | ${route.source} | ${route.confidence}${route.inferred ? " inferred" : ""} |`).join("\n");
+  const workspaces = scan.project.workspaces.map((workspace) => `| ${workspace.name} | ${workspace.path} | ${workspace.source} |`).join("\n");
+  return `# Project Context
 
-// src/templates/gitignore.ts
-var BEGIN2 = "# FET:BEGIN LOCAL STATE";
-var END2 = "# FET:END LOCAL STATE";
-var RULES = [
-  "openspec/fet-state.json",
-  "openspec/.fet.lock",
-  "openspec/.fet-init-journal.json",
-  "openspec/changes/*/fet-state.json",
-  "openspec/changes/*/.fet/",
-  ".gitnexus/"
-];
-function mergeGitignore(existing) {
-  const block = `${BEGIN2}
-${RULES.join("\n")}
-${END2}`;
-  if (!existing || !existing.trim()) {
-    return `${block}
-`;
-  }
-  const start = existing.indexOf(BEGIN2);
-  const end = existing.indexOf(END2);
-  if (start !== -1 && end !== -1 && end > start) {
-    return `${existing.slice(0, start)}${block}${existing.slice(end + END2.length)}`;
-  }
-  return `${existing.replace(/\s*$/, "")}
+${AUTO_BEGIN}
+## Project Snapshot
 
-${block}
-`;
-}
+- Name: ${scan.project.name}
+- Package Manager: ${scan.project.packageManager} (${scan.project.packageManagerConfidence})
+- Framework: ${scan.project.framework.name} (${scan.project.framework.confidence})
+- Language: ${scan.project.language}
+- Monorepo: ${scan.project.monorepo ? "yes" : "no"}
 
-// src/commands/update-context.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join7 } from "path";
+## Workspaces
 
-// src/config/yaml.ts
-import { readFile as readFile3 } from "fs/promises";
-import { parseDocument } from "yaml";
-async function mergeFetConfig(configPath, renderedFetYaml) {
-  const fetDoc = parseDocument(renderedFetYaml);
-  const nextFet = fetDoc.get("fet", true);
-  let existing = "";
-  try {
-    existing = await readFile3(configPath, "utf8");
-  } catch {
-    return renderedFetYaml;
-  }
-  const doc = parseDocument(existing || "{}");
-  doc.set("fet", nextFet);
-  return doc.toString();
-}
+| Name | Path | Source |
+|------|------|--------|
+${workspaces || "| root | . | inferred |"}
 
-// src/context-placeholders.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join6 } from "path";
-var AGENTS_LLM_PLACEHOLDER_PATTERN = /\[NEEDS? LLM INPUT\]/g;
-async function countAgentsLlmPlaceholders(projectRoot) {
-  try {
-    const content = await readFile4(join6(projectRoot, "AGENTS.md"), "utf8");
-    return [...content.matchAll(AGENTS_LLM_PLACEHOLDER_PATTERN)].length;
-  } catch {
-    return 0;
-  }
-}
-function renderAgentsPlaceholderWarning(count2) {
-  return `AGENTS.md still contains ${count2} LLM placeholder(s). Run fet fill-context first so your IDE AI can replace them. Continuing current command.`;
-}
+## Commands
 
-// src/commands/update-context.ts
-async function updateContextCommand(ctx) {
-  let contextResult = { warnings: [] };
-  await withProjectLock(
-    ctx.projectRoot,
-    { command: "update-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
-    async () => {
-      contextResult = await updateContextFiles(ctx);
-    }
-  );
-  ctx.output.result({
-    ok: true,
-    command: "update-context",
-    summary: "\u5DF2\u66F4\u65B0 AGENTS.md \u4E0E openspec/config.yaml \u7684 FET \u6258\u7BA1\u533A\u57DF\u3002",
-    warnings: contextResult.warnings
-  });
-}
-async function updateContextFiles(ctx) {
-  const scan = await ctx.scanner.scan(ctx.projectRoot, {});
-  const agentsPath = join7(ctx.projectRoot, "AGENTS.md");
-  const configPath = join7(ctx.projectRoot, "openspec", "config.yaml");
-  const claudePath = join7(ctx.projectRoot, "CLAUDE.md");
-  const karpathyHandoffPath = join7(ctx.projectRoot, ".fet", "karpathy-guidelines.md");
-  const karpathyCursorPath = join7(ctx.projectRoot, ".cursor", "rules", "karpathy-guidelines.mdc");
-  const existingAgents = await readOptional(agentsPath);
-  const existingClaude = await readOptional(claudePath);
-  const existingKarpathyCursor = await readOptional(karpathyCursorPath);
-  const warnings = [...scan.warnings];
-  if (existingAgents && hasInvalidManagedAutoRegion(existingAgents)) {
-    throw new FetError({
-      code: "CONFIG_INVALID" /* ConfigInvalid */,
-      message: "AGENTS.md \u7684 FET \u6258\u7BA1\u6807\u8BB0\u635F\u574F\u6216\u91CD\u590D",
-      details: { path: "AGENTS.md" },
-      suggestedCommand: "\u624B\u52A8\u4FEE\u590D FET:BEGIN AUTO / FET:END AUTO \u6807\u8BB0\u540E\u91CD\u8BD5"
-    });
-  }
-  if (existingAgents && !hasManagedAutoRegion(existingAgents)) {
-    if (!ctx.yes) {
-      throw new FetError({
-        code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
-        message: "AGENTS.md \u5DF2\u5B58\u5728\u4E14\u4E0D\u5305\u542B FET \u6258\u7BA1\u533A\u57DF",
-        details: { path: "AGENTS.md" },
-        suggestedCommand: ctx.command === "init" ? "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet init --yes" : "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet update-context --yes"
-      });
-    }
-    const backupPath = await createBackup(agentsPath);
-    if (backupPath) {
-      warnings.push(`\u5DF2\u5907\u4EFD\u975E\u6258\u7BA1 AGENTS.md \u5230 ${backupPath}`);
-    }
-  }
-  await atomicWrite(agentsPath, replaceManagedRegion(existingAgents, renderAgentsMd(scan)));
-  await atomicWrite(configPath, await mergeFetConfig(configPath, renderFetConfig(scan)));
-  await atomicWrite(claudePath, mergeKarpathyClaudeMd(existingClaude));
-  await atomicWrite(karpathyHandoffPath, renderKarpathyFetHandoff());
-  if (!existingKarpathyCursor || existingKarpathyCursor.includes("FET:MANAGED")) {
-    await atomicWrite(karpathyCursorPath, renderKarpathyCursorRule());
-  } else {
-    warnings.push(".cursor/rules/karpathy-guidelines.mdc exists and is not managed by FET; leaving it unchanged.");
-  }
-  const placeholderCount = await countAgentsLlmPlaceholders(ctx.projectRoot);
-  if (placeholderCount > 0) {
-    warnings.push(renderAgentsPlaceholderWarning(placeholderCount));
-  }
-  const state = await ctx.stateStore.getOrCreateGlobal();
-  state.context = {
-    agentsMdUpdatedAt: scan.generatedAt,
-    configUpdatedAt: scan.generatedAt,
-    scannerVersion: scan.scannerVersion
-  };
-  await ctx.stateStore.writeGlobal(state);
-  return { warnings };
-}
-async function readOptional(path) {
-  try {
-    return await readFile5(path, "utf8");
-  } catch {
-    return null;
-  }
+| Name | Command | Source |
+|------|---------|--------|
+${commands || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
+
+## Structure
+
+[NEEDS LLM INPUT]
+
+## Routes
+
+| Route | Source | Confidence |
+|-------|--------|------------|
+${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
+
+## Conventions
+
+[NEEDS LLM INPUT]
+
+## AI Work Guidelines
+
+- Prefer the project-level Andrej Karpathy inspired guidelines in .fet/karpathy-guidelines.md when using FET-managed IDE workflows.
+- For Codex, also read .codex/fet/karpathy-guidelines.md when present.
+- Treat those guidelines as secondary to the user's latest request and explicit OpenSpec artifacts.
+
+## Scanner Metadata
+
+- Generated At: ${scan.generatedAt}
+- FET Version: ${FET_VERSION}
+- Scanner Version: ${scan.scannerVersion}
+- Warnings: ${scan.warnings.length ? scan.warnings.join("; ") : "none"}
+${AUTO_END}
+
+${USER_BEGIN}
+## Notes For AI
+
+[NEEDS LLM INPUT]
+${USER_END}
+`;
 }
 
-// src/commands/init.ts
-async function initCommand(ctx) {
-  const alreadyInitialized = await exists(join8(ctx.projectRoot, "openspec", "config.yaml"));
-  let warnings = [];
-  await withProjectLock(
-    ctx.projectRoot,
-    { command: "init", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
-    async () => {
-      const journal = createInitJournal(ctx.fetVersion);
-      await writeInitJournal(ctx.projectRoot, journal);
-      const identity = await ctx.openSpec.resolveExecutable();
-      if (!alreadyInitialized) {
-        const result = await ctx.openSpec.run("init", ["--tools", "none"], { cwd: ctx.projectRoot, stdio: "inherit" });
-        if (result.exitCode !== 0) {
-          process.exitCode = result.exitCode;
-          return;
-        }
-      }
-      const contextResult = await updateContextFiles(ctx);
-      warnings = contextResult.warnings;
-      await ensureGitignore(ctx);
-      const state = await ctx.stateStore.getOrCreateGlobal();
-      state.openspec = identity;
-      state.graph ??= {};
-      const gitnexus = mergeGitNexusGraphInfo(
-        toGitNexusState(await detectGitNexus(), state.graph.gitnexus),
-        await inspectGitNexusGraph(ctx.projectRoot)
-      );
-      if (!gitnexus.installed && !gitnexus.recommendationShownAt) {
-        warnings.push(renderGitNexusRecommendation(gitnexus));
-        gitnexus.recommendationShownAt = (/* @__PURE__ */ new Date()).toISOString();
-      }
-      state.graph.gitnexus = gitnexus;
-      for (const adapter of ctx.toolAdapters) {
-        const plan = await adapter.planInstall(ctx.projectRoot);
-        const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
-        state.toolAdapters[adapter.tool] = {
-          adapterVersion: adapter.adapterVersion,
-          installed: true,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        journal.steps.push(...result.written.map((path) => ({ operation: "write", path, status: "done" })));
+// src/templates/config-yaml.ts
+import { stringify } from "yaml";
+function renderFetConfig(scan, language = "zh-CN") {
+  return stringify({
+    fet: {
+      schemaVersion: 1,
+      generatedAt: scan.generatedAt,
+      fetVersion: FET_VERSION,
+      language,
+      scannerVersion: scan.scannerVersion,
+      project: {
+        packageManager: scan.project.packageManager,
+        packageManagerConfidence: scan.project.packageManagerConfidence,
+        framework: scan.project.framework,
+        language: scan.project.language,
+        monorepo: scan.project.monorepo,
+        workspaces: scan.project.workspaces
+      },
+      commands: scan.commands,
+      validation: {
+        monorepo: scan.project.monorepo,
+        missing: {
+          lint: "warn",
+          typecheck: "warn",
+          test: "warn"
+        },
+        workspaces: scan.project.workspaces
       }
-      journal.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await writeInitJournal(ctx.projectRoot, journal);
-      await ctx.stateStore.writeGlobal(state);
     }
-  );
-  ctx.output.result({
-    ok: true,
-    command: "init",
-    summary: "FET \u521D\u59CB\u5316\u5B8C\u6210\u3002",
-    warnings,
-    nextSteps: ["\u4F7F\u7528 fet propose/new \u521B\u5EFA OpenSpec change", "\u4F7F\u7528 fet doctor \u68C0\u67E5\u9879\u76EE\u72B6\u6001"]
   });
 }
-async function ensureGitignore(ctx) {
-  const gitignorePath = join8(ctx.projectRoot, ".gitignore");
-  const existing = await readOptional2(gitignorePath);
-  await atomicWrite(gitignorePath, mergeGitignore(existing));
-}
-async function readOptional2(path) {
-  try {
-    return await readFile6(path, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function exists(path) {
-  try {
-    await stat3(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
 
-// src/commands/doctor.ts
-import { readFile as readFile7, stat as stat4 } from "fs/promises";
-import { join as join9 } from "path";
-async function doctorCommand(ctx, options = {}) {
-  const checks = [];
-  checks.push(await checkOpenSpec(ctx));
-  checks.push(await checkState(ctx));
-  checks.push(await checkFile("agents", join9(ctx.projectRoot, "AGENTS.md"), "AGENTS.md \u7F3A\u5931", "fet update-context"));
-  checks.push(await checkFile("config", join9(ctx.projectRoot, "openspec", "config.yaml"), "openspec/config.yaml \u7F3A\u5931", "fet init"));
-  checks.push(await checkPlaceholders(ctx.projectRoot));
-  checks.push(await checkGitNexus(ctx));
-  for (const adapter of ctx.toolAdapters) {
-    checks.push(...await adapter.doctor(ctx.projectRoot));
-  }
-  const lockPath = join9(ctx.projectRoot, "openspec", ".fet.lock");
-  if (await exists2(lockPath)) {
-    if (options.fixLock) {
-      await clearLock(ctx.projectRoot);
-      checks.push({ id: "lock", status: "pass", message: "\u5DF2\u6E05\u7406 openspec/.fet.lock" });
-    } else {
-      checks.push({ id: "lock", status: "warn", message: "\u5B58\u5728 openspec/.fet.lock", suggestedCommand: "fet doctor --fix-lock" });
-    }
+// src/templates/karpathy-skills.ts
+var KARPATHY_SKILLS_SOURCE = "https://github.com/forrestchang/andrej-karpathy-skills";
+var BEGIN = "<!-- FET:BEGIN ANDREJ-KARPATHY-SKILLS -->";
+var END = "<!-- FET:END ANDREJ-KARPATHY-SKILLS -->";
+function mergeKarpathyClaudeMd(existing) {
+  const block = renderManagedBlock(renderKarpathyClaudeGuidelines());
+  if (!existing || !existing.trim()) {
+    return `${block}
+`;
   }
-  const warnings = checks.filter((check) => check.status !== "pass").map((check) => check.message);
-  ctx.output.result({
-    ok: true,
-    command: "doctor",
-    summary: warnings.length ? `\u8BCA\u65AD\u5B8C\u6210\uFF0C\u53D1\u73B0 ${warnings.length} \u4E2A\u9700\u8981\u5173\u6CE8\u7684\u95EE\u9898\u3002` : "\u8BCA\u65AD\u5B8C\u6210\uFF0C\u672A\u53D1\u73B0\u660E\u663E\u95EE\u9898\u3002",
-    warnings,
-    data: checks
-  });
-}
-async function checkGitNexus(ctx) {
-  const global = await ctx.stateStore.readGlobal();
-  const state = mergeGitNexusGraphInfo(
-    toGitNexusState(await detectGitNexus(), global?.graph?.gitnexus),
-    await inspectGitNexusGraph(ctx.projectRoot)
-  );
-  if (global) {
-    global.graph ??= {};
-    global.graph.gitnexus = state;
-    await ctx.stateStore.writeGlobal(global);
+  const start = existing.indexOf(BEGIN);
+  const end = existing.indexOf(END);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${existing.slice(0, start)}${block}${existing.slice(end + END.length)}`;
   }
-  return state.installed ? {
-    id: "gitnexus",
-    status: "pass",
-    message: `GitNexus detected: ${state.executablePath ?? "gitnexus"} (${state.version ?? "unknown"}), graph ${state.graphExists ? "found" : "not found"}`
-  } : {
-    id: "gitnexus",
-    status: "warn",
-    message: "Optional GitNexus code graph support is not installed",
-    suggestedCommand: "Install GitNexus later if you want OpenSpec artifacts to prefer a repository graph"
-  };
+  return `${existing.replace(/\s*$/, "")}
+
+${block}
+`;
 }
-async function checkOpenSpec(ctx) {
-  try {
-    const identity = await ctx.openSpec.resolveExecutable();
-    return { id: "openspec", status: "pass", message: `OpenSpec: ${identity.executablePath} (${identity.version})` };
-  } catch (error) {
-    return { id: "openspec", status: "fail", message: error instanceof Error ? error.message : "OpenSpec \u68C0\u6D4B\u5931\u8D25" };
-  }
+function renderKarpathyCursorRule(language = "zh-CN") {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: karpathy-skills
+FET:END -->
+
+---
+description: ${language === "en" ? "Andrej Karpathy inspired coding guidelines" : "\u53D7 Andrej Karpathy \u542F\u53D1\u7684\u7F16\u7801\u6307\u5357"}
+alwaysApply: true
+---
+
+${renderKarpathyGuidelinesBody(language)}
+`;
 }
-async function checkState(ctx) {
-  try {
-    const state = await ctx.stateStore.readGlobal();
-    return state ? { id: "state", status: "pass", message: "FET \u5168\u5C40\u72B6\u6001\u53EF\u8BFB\u53D6" } : { id: "state", status: "warn", message: "FET \u5168\u5C40\u72B6\u6001\u5C1A\u672A\u521D\u59CB\u5316", suggestedCommand: "fet init" };
-  } catch (error) {
-    return { id: "state", status: "fail", message: error instanceof Error ? error.message : "FET \u72B6\u6001\u8BFB\u53D6\u5931\u8D25" };
-  }
+function renderKarpathyFetHandoff(language = "zh-CN") {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: karpathy-skills
+FET:END -->
+
+# ${language === "en" ? "Andrej Karpathy Inspired Coding Guidelines" : "\u53D7 Andrej Karpathy \u542F\u53D1\u7684\u7F16\u7801\u6307\u5357"}
+
+${renderKarpathyGuidelinesBody(language)}
+`;
 }
-async function checkFile(id, path, missing, suggestedCommand) {
-  return await exists2(path) ? { id, status: "pass", message: `${id} \u5B58\u5728` } : { id, status: "warn", message: missing, suggestedCommand };
+function renderManagedBlock(content) {
+  return `${BEGIN}
+${content}
+${END}`;
 }
-async function checkPlaceholders(projectRoot) {
-  try {
-    await readFile7(join9(projectRoot, "AGENTS.md"), "utf8");
-    const count2 = await countAgentsLlmPlaceholders(projectRoot);
-    return count2 ? {
-      id: "context-placeholders",
-      status: "warn",
-      message: `AGENTS.md has ${count2} LLM placeholder(s)`,
-      suggestedCommand: "fet fill-context"
-    } : { id: "context-placeholders", status: "pass", message: "AGENTS.md placeholders resolved" };
-  } catch {
-    return { id: "context-placeholders", status: "warn", message: "AGENTS.md missing", suggestedCommand: "fet update-context" };
-  }
+function renderKarpathyClaudeGuidelines() {
+  return `# Andrej Karpathy Inspired Coding Guidelines
+
+${renderKarpathyGuidelinesBody()}`;
 }
-async function exists2(path) {
-  try {
-    await stat4(path);
-    return true;
-  } catch {
-    return false;
+function renderKarpathyGuidelinesBody(language = "zh-CN") {
+  if (language === "en") {
+    return renderKarpathyGuidelinesBodyEn();
   }
+  return `\u6765\u6E90\uFF1A${KARPATHY_SKILLS_SOURCE}
+
+\u5C06\u8FD9\u4E9B\u9879\u76EE\u7EA7\u6307\u5357\u4E0E AGENTS.md\u3001OpenSpec \u4EA7\u7269\u548C\u7528\u6237\u6700\u65B0\u8BF7\u6C42\u4E00\u8D77\u4F7F\u7528\u3002
+
+## \u7F16\u7801\u524D\u5148\u601D\u8003
+
+- \u7F16\u8F91\u524D\u8BF4\u660E\u91CD\u8981\u5047\u8BBE\u3002
+- \u5F53\u6B67\u4E49\u4F1A\u6539\u53D8\u5B9E\u73B0\u65F6\uFF0C\u5148\u6F84\u6E05\u3002
+- \u4E3B\u52A8\u5448\u73B0\u53D6\u820D\uFF0C\u4E0D\u8981\u9759\u9ED8\u9009\u62E9\u9AD8\u98CE\u9669\u8DEF\u5F84\u3002
+- \u5F53\u66F4\u7B80\u5355\u7684\u65B9\u6848\u66F4\u9002\u5408\u8BF7\u6C42\u65F6\uFF0C\u660E\u786E\u63D0\u51FA\u3002
+
+## \u7B80\u6D01\u4F18\u5148
+
+- \u7528\u6700\u5C0F\u4E14\u6E05\u6670\u7684\u6539\u52A8\u89E3\u51B3\u8BF7\u6C42\u7684\u95EE\u9898\u3002
+- \u907F\u514D\u731C\u6D4B\u6027\u529F\u80FD\u3001\u914D\u7F6E\u6216\u62BD\u8C61\u3002
+- \u4E0D\u8981\u4E3A\u4E00\u6B21\u6027\u4EE3\u7801\u521B\u5EFA\u62BD\u8C61\u3002
+- \u4F18\u5148\u5220\u9664\u81EA\u5DF1\u6539\u52A8\u5F15\u5165\u7684\u590D\u6742\u5EA6\uFF0C\u800C\u4E0D\u662F\u7EE7\u7EED\u5806\u7ED3\u6784\u3002
+
+## \u7CBE\u51C6\u7F16\u8F91
+
+- \u53EA\u4FEE\u6539\u76F4\u63A5\u670D\u52A1\u4E8E\u4EFB\u52A1\u7684\u6587\u4EF6\u548C\u884C\u3002
+- \u4FDD\u6301\u73B0\u6709\u98CE\u683C\uFF0C\u5373\u4FBF\u4F60\u4E2A\u4EBA\u66F4\u504F\u597D\u53E6\u4E00\u79CD\u6A21\u5F0F\u3002
+- \u9664\u975E\u4EFB\u52A1\u9700\u8981\uFF0C\u4E0D\u8981\u987A\u624B\u91CD\u6784\u9644\u8FD1\u4EE3\u7801\u3001\u6CE8\u91CA\u6216\u683C\u5F0F\u3002
+- \u53EA\u79FB\u9664\u56E0\u81EA\u5DF1\u6539\u52A8\u800C\u8FC7\u65F6\u7684\u6B7B\u5BFC\u5165\u3001\u53D8\u91CF\u6216 helper\u3002
+
+## \u76EE\u6807\u9A71\u52A8\u6267\u884C
+
+- \u628A\u6A21\u7CCA\u5DE5\u4F5C\u8F6C\u6210\u5177\u4F53\u6210\u529F\u6807\u51C6\u3002
+- \u5BF9 bug\uFF0C\u4F18\u5148\u51C6\u5907\u590D\u73B0\u6D4B\u8BD5\u6216\u6E05\u6670\u9A8C\u8BC1\uFF0C\u518D\u505A\u4FEE\u590D\u3002
+- \u5BF9\u591A\u6B65\u9AA4\u5DE5\u4F5C\uFF0C\u4FDD\u7559\u7B80\u77ED\u8BA1\u5212\u5E76\u9A8C\u8BC1\u6BCF\u4E2A\u6709\u610F\u4E49\u7684\u6B65\u9AA4\u3002
+- \u6301\u7EED\u8FED\u4EE3\uFF0C\u76F4\u5230\u8FBE\u5230\u6210\u529F\u6807\u51C6\u6216\u660E\u786E\u9047\u5230\u963B\u585E\u3002
+
+\u8FD9\u4E9B\u6307\u5357\u5728\u975E\u5E73\u51E1\u5DE5\u4F5C\u4E2D\u523B\u610F\u504F\u5411\u8C28\u614E\u800C\u4E0D\u662F\u901F\u5EA6\u3002\u660E\u663E\u7684\u4E00\u884C\u4FEE\u590D\u53EF\u4EE5\u7075\u6D3B\u5224\u65AD\uFF0C\u4FDD\u6301\u8F7B\u91CF\u3002`;
 }
+function renderKarpathyGuidelinesBodyEn() {
+  return `Source: ${KARPATHY_SKILLS_SOURCE}
+
+Use these project-level guidelines together with AGENTS.md, OpenSpec artifacts, and the user's latest request.
+
+## Think Before Coding
+
+- State important assumptions before editing.
+- Ask for clarification when ambiguity would change the implementation.
+- Surface tradeoffs instead of silently choosing a risky path.
+- Push back when a simpler approach better fits the request.
+
+## Simplicity First
+
+- Solve the requested problem with the smallest clear change.
+- Avoid speculative features, configuration, or abstraction.
+- Do not create abstractions for one-off code.
+- Prefer deleting complexity introduced by your own change over adding more structure.
+
+## Precise Edits
+
+- Touch only files and lines that directly serve the task.
+- Preserve existing style even when you personally prefer another pattern.
+- Do not refactor nearby code, comments, or formatting unless the task requires it.
+- Remove only dead imports, variables, or helpers made obsolete by your own change.
+
+## Goal-Driven Execution
 
-// src/commands/fill-context.ts
-import { mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname5, join as join10 } from "path";
-async function fillContextCommand(ctx) {
-  await withProjectLock(
-    ctx.projectRoot,
-    { command: "fill-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
-    async () => {
-      const handoffPath = join10(ctx.projectRoot, ".fet", "fill-context.md");
-      await mkdir3(dirname5(handoffPath), { recursive: true });
-      await atomicWrite(handoffPath, renderGenericHandoff());
-      for (const adapter of ctx.toolAdapters) {
-        const plan = await adapter.planInstall(ctx.projectRoot);
-        const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
-        const state = await ctx.stateStore.getOrCreateGlobal();
-        state.toolAdapters[adapter.tool] = {
-          adapterVersion: adapter.adapterVersion,
-          installed: true,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        await ctx.stateStore.writeGlobal(state);
-        if (ctx.verbose) {
-          ctx.output.info(`Updated ${adapter.tool} adapter`, { written: result.written });
-        }
-      }
-    }
-  );
-  const placeholders = await countAgentsLlmPlaceholders(ctx.projectRoot);
-  ctx.output.result({
-    ok: true,
-    command: "fill-context",
-    summary: placeholders ? `Found ${placeholders} AGENTS.md placeholder(s). Use your IDE AI to fill them.` : "No AGENTS.md placeholders found. IDE fill-context commands were refreshed.",
-    nextSteps: placeholders ? [
-      "Cursor: run /fet-fill-context",
-      "Codex: run /prompts:fet-fill-context",
-      "OpenCode or other IDEs: open .fet/fill-context.md or run fet fill-context for handoff instructions"
-    ] : ["Run fet doctor to confirm project context health"],
-    data: {
-      placeholders,
-      cursorCommand: "/fet-fill-context",
-      codexCommand: "/prompts:fet-fill-context"
-    }
-  });
+- Convert vague work into concrete success criteria.
+- For bugs, prefer a reproducing test or clear verification before the fix.
+- For multi-step work, keep a short plan and verify each meaningful step.
+- Continue iterating until the success criteria are met or a blocker is explicit.
+
+These guidelines intentionally favor caution over speed for non-trivial work. For obvious one-line fixes, use judgment and stay lightweight.`;
 }
-function renderGenericHandoff() {
-  return `<!-- FET:MANAGED
+
+// src/templates/verify-instructions.ts
+function renderVerifyInstructions(changeId, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return `---
 schemaVersion: 1
-generator: fill-context
-FET:END -->
+fetVersion: ${FET_VERSION}
+generatedAt: ${generatedAt}
+changeId: ${changeId}
+purpose: manual-verify
+---
 
-# FET Fill Context
+# Verify Instructions
 
-Use the IDE AI to complete FET-generated placeholders.
+\u8BF7\u6309\u987A\u5E8F\u5B8C\u6210\u4EE5\u4E0B\u68C0\u67E5\uFF1A
 
-1. Read AGENTS.md and openspec/config.yaml.
-2. Read .fet/karpathy-guidelines.md when it exists. For Codex, also read .codex/fet/karpathy-guidelines.md when it exists.
-3. Inspect README files, package scripts, routes, tests, source layout, and project conventions.
-4. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content.
-5. Preserve FET managed markers.
-6. Do not modify business code.
-7. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
+1. \u8FD0\u884C OpenSpec \u89C4\u8303\u6821\u9A8C\uFF1A\`openspec verify\`
+2. \u6309\u9879\u76EE\u7EA6\u5B9A\u8FD0\u884C lint\u3001typecheck\u3001test\u3002
+3. \u68C0\u67E5\u672C\u6B21 change \u7684 \`tasks.md\` \u662F\u5426\u4E0E\u5B9E\u73B0\u72B6\u6001\u4E00\u81F4\u3002
+
+\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+
+\`\`\`sh
+fet verify --done --change ${changeId}
+\`\`\`
 `;
 }
 
-// src/commands/graph.ts
-import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname6, join as join11 } from "path";
-async function graphCommand(ctx, action, args = []) {
-  switch (action) {
-    case "status":
-      await graphStatusCommand(ctx);
-      return;
-    case "doctor":
-      await graphDoctorCommand(ctx);
-      return;
-    case "setup":
-      await graphSetupCommand(ctx);
-      return;
-    case "handoff":
-      await graphHandoffCommand(ctx);
-      return;
-    case "init":
-      await graphAnalyzeCommand(ctx, "init", args);
-      return;
-    case "refresh":
-      await graphAnalyzeCommand(ctx, "refresh", args);
-      return;
+// src/templates/gitignore.ts
+var BEGIN2 = "# FET:BEGIN LOCAL STATE";
+var END2 = "# FET:END LOCAL STATE";
+var RULES = [
+  "openspec/fet-state.json",
+  "openspec/.fet.lock",
+  "openspec/.fet-init-journal.json",
+  "openspec/changes/*/fet-state.json",
+  "openspec/changes/*/.fet/",
+  ".gitnexus/"
+];
+function mergeGitignore(existing) {
+  const block = `${BEGIN2}
+${RULES.join("\n")}
+${END2}`;
+  if (!existing || !existing.trim()) {
+    return `${block}
+`;
   }
+  const start = existing.indexOf(BEGIN2);
+  const end = existing.indexOf(END2);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${existing.slice(0, start)}${block}${existing.slice(end + END2.length)}`;
+  }
+  return `${existing.replace(/\s*$/, "")}
+
+${block}
+`;
 }
-async function graphStatusCommand(ctx) {
-  const result = await refreshGraphState(ctx, { runStatus: true });
-  const warnings = result.state.installed ? [] : ["GitNexus is not installed. Run fet graph setup for installation handoff instructions."];
-  ctx.output.result({
-    ok: true,
-    command: "graph status",
-    summary: result.state.installed ? `GitNexus graph status checked. Graph ${result.state.graphExists ? "exists" : "does not exist"} at ${result.state.graphPath ?? ".gitnexus"}.` : "GitNexus is not installed. Graph support remains optional.",
-    warnings,
-    nextSteps: result.state.installed && !result.state.graphExists ? ["Run fet graph init to build the first GitNexus graph"] : void 0,
-    data: result
-  });
-}
-async function graphDoctorCommand(ctx) {
-  const result = await refreshGraphState(ctx, { runStatus: true });
-  const warnings = [
-    ...!result.state.installed ? ["GitNexus is not installed."] : [],
-    ...result.state.installed && !result.state.graphExists ? ["GitNexus is installed but no graph directory was found."] : [],
-    ...!result.state.handoffPath ? ["Graph handoff instructions have not been generated."] : []
-  ];
-  ctx.output.result({
-    ok: true,
-    command: "graph doctor",
-    summary: warnings.length ? `Graph doctor completed with ${warnings.length} warning(s).` : "Graph doctor completed without warnings.",
-    warnings,
-    nextSteps: warnings.length ? ["Run fet graph setup", "Run fet graph handoff", "Run fet graph init when GitNexus is installed"] : void 0,
-    data: result
-  });
-}
-async function graphSetupCommand(ctx) {
-  let result;
-  const handoffPath = join11(ctx.projectRoot, ".fet", "graph-setup.md");
-  await withProjectLock(ctx.projectRoot, { command: "graph setup", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
-    result = await refreshGraphState(ctx, { write: false });
-    await writeHandoffFile(handoffPath, renderGraphSetupHandoff(result.state));
-    const global = await ctx.stateStore.getOrCreateGlobal();
-    global.graph ??= {};
-    global.graph.gitnexus = {
-      ...result.state,
-      setupHandoffPath: ".fet/graph-setup.md",
-      setupHandoffUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await ctx.stateStore.writeGlobal(global);
-  });
-  ctx.output.result({
-    ok: true,
-    command: "graph setup",
-    summary: "GitNexus setup handoff generated.",
-    warnings: result.state.installed ? [] : ["GitNexus is not installed. The handoff explains installation and IDE-assisted setup options."],
-    nextSteps: result.state.installed ? ["Run gitnexus setup if you want to configure IDE/MCP integrations", "Run fet graph init"] : ["Open .fet/graph-setup.md in your IDE AI"],
-    data: {
-      path: ".fet/graph-setup.md",
-      gitnexus: result.state
-    }
-  });
+
+// src/commands/update-context.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join10 } from "path";
+
+// src/config/yaml.ts
+import { readFile as readFile5 } from "fs/promises";
+import { parseDocument } from "yaml";
+async function mergeFetConfig(configPath, renderedFetYaml) {
+  const fetDoc = parseDocument(renderedFetYaml);
+  const nextFet = fetDoc.get("fet", true);
+  let existing = "";
+  try {
+    existing = await readFile5(configPath, "utf8");
+  } catch {
+    return renderedFetYaml;
+  }
+  const doc = parseDocument(existing || "{}");
+  doc.set("fet", nextFet);
+  return doc.toString();
 }
-async function graphHandoffCommand(ctx) {
-  let result;
-  const handoffPath = join11(ctx.projectRoot, ".fet", "graph-handoff.md");
-  await withProjectLock(ctx.projectRoot, { command: "graph handoff", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
-    result = await refreshGraphState(ctx, { runStatus: true, write: false });
-    await writeHandoffFile(handoffPath, renderGraphUsageHandoff(result.state));
-    const global = await ctx.stateStore.getOrCreateGlobal();
-    global.graph ??= {};
-    global.graph.gitnexus = {
-      ...result.state,
-      handoffPath: ".fet/graph-handoff.md",
-      handoffUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await ctx.stateStore.writeGlobal(global);
+
+// src/commands/update-context.ts
+async function updateContextCommand(ctx) {
+  let contextResult = { warnings: [] };
+  await withProjectLock(ctx.projectRoot, { command: "update-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    contextResult = await updateContextFiles(ctx);
   });
   ctx.output.result({
     ok: true,
-    command: "graph handoff",
-    summary: "GitNexus graph usage handoff generated.",
-    warnings: result.state.installed ? [] : ["GitNexus is not installed. The handoff still documents the fallback behavior."],
-    nextSteps: ["Cursor/Codex/OpenCode: read .fet/graph-handoff.md before broad repository scans"],
-    data: {
-      path: ".fet/graph-handoff.md",
-      gitnexus: result.state
-    }
+    command: "update-context",
+    summary: ctx.language === "en" ? "Updated FET-managed regions in AGENTS.md and openspec/config.yaml." : "\u5DF2\u66F4\u65B0 AGENTS.md \u4E0E openspec/config.yaml \u4E2D\u7684 FET \u6258\u7BA1\u533A\u57DF\u3002",
+    warnings: contextResult.warnings
   });
 }
-async function graphAnalyzeCommand(ctx, mode, args) {
-  const detection = await detectGitNexus();
-  if (!detection.installed) {
-    throw new FetError({
-      code: "GRAPH_PROVIDER_NOT_FOUND" /* GraphProviderNotFound */,
-      message: "GitNexus is not installed or is not available on PATH.",
-      details: { executable: detection.executablePath, error: detection.error },
-      suggestedCommand: "fet graph setup"
-    });
-  }
-  const run = await runGitNexus(["analyze", ...args], { cwd: ctx.projectRoot });
-  if (run.exitCode !== 0) {
-    throw new FetError({
-      code: "GRAPH_COMMAND_FAILED" /* GraphCommandFailed */,
-      message: "GitNexus analyze failed.",
-      details: { command: run.command.join(" "), exitCode: run.exitCode, stdout: run.stdout, stderr: run.stderr },
-      suggestedCommand: "fet graph doctor"
-    });
-  }
-  const result = await refreshGraphState(ctx, { write: false });
-  const global = await ctx.stateStore.getOrCreateGlobal();
-  global.graph ??= {};
-  global.graph.gitnexus = {
-    ...result.state,
-    lastRefreshAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await ctx.stateStore.writeGlobal(global);
-  ctx.output.result({
-    ok: true,
-    command: `graph ${mode}`,
-    summary: mode === "init" ? "GitNexus graph initialized." : "GitNexus graph refreshed.",
-    warnings: result.state.graphExists ? [] : ["GitNexus analyze completed, but the configured graph directory was not found."],
-    nextSteps: ["Run fet graph status", "Use .fet/graph-handoff.md or generated IDE prompts to prefer graph context"],
-    data: {
-      gitnexus: global.graph.gitnexus,
-      run: {
-        command: run.command,
-        stdout: run.stdout.trim(),
-        stderr: run.stderr.trim()
-      }
+async function updateContextFiles(ctx) {
+  const scan = await ctx.scanner.scan(ctx.projectRoot, {});
+  const agentsPath = join10(ctx.projectRoot, "AGENTS.md");
+  const configPath = join10(ctx.projectRoot, "openspec", "config.yaml");
+  const claudePath = join10(ctx.projectRoot, "CLAUDE.md");
+  const karpathyHandoffPath = join10(ctx.projectRoot, ".fet", "karpathy-guidelines.md");
+  const karpathyCursorPath = join10(ctx.projectRoot, ".cursor", "rules", "karpathy-guidelines.mdc");
+  const existingAgents = await readOptional(agentsPath);
+  const existingClaude = await readOptional(claudePath);
+  const existingKarpathyCursor = await readOptional(karpathyCursorPath);
+  const warnings = [...scan.warnings];
+  if (existingAgents && hasInvalidManagedAutoRegion(existingAgents)) {
+    throw new FetError({
+      code: "CONFIG_INVALID" /* ConfigInvalid */,
+      message: ctx.language === "en" ? "AGENTS.md FET managed markers are broken or duplicated." : "AGENTS.md \u7684 FET \u6258\u7BA1\u6807\u8BB0\u635F\u574F\u6216\u91CD\u590D\u3002",
+      details: { path: "AGENTS.md" },
+      suggestedCommand: ctx.language === "en" ? "Manually repair FET:BEGIN AUTO / FET:END AUTO markers, then rerun." : "\u624B\u52A8\u4FEE\u590D FET:BEGIN AUTO / FET:END AUTO \u6807\u8BB0\u540E\u91CD\u8BD5\u3002"
+    });
+  }
+  if (existingAgents && !hasManagedAutoRegion(existingAgents)) {
+    if (!ctx.yes) {
+      throw new FetError({
+        code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
+        message: ctx.language === "en" ? "AGENTS.md already exists and does not contain a FET-managed region." : "AGENTS.md \u5DF2\u5B58\u5728\uFF0C\u4E14\u4E0D\u5305\u542B FET \u6258\u7BA1\u533A\u57DF\u3002",
+        details: { path: "AGENTS.md" },
+        suggestedCommand: ctx.command === "init" ? ctx.language === "en" ? "Confirm it can be backed up and replaced, then run fet init --yes." : "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet init --yes\u3002" : ctx.language === "en" ? "Confirm it can be backed up and replaced, then run fet update-context --yes." : "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet update-context --yes\u3002"
+      });
+    }
+    const backupPath = await createBackup(agentsPath);
+    if (backupPath) {
+      warnings.push(ctx.language === "en" ? `Backed up unmanaged AGENTS.md to ${backupPath}` : `\u5DF2\u5C06\u975E\u6258\u7BA1 AGENTS.md \u5907\u4EFD\u5230 ${backupPath}`);
     }
-  });
-}
-async function refreshGraphState(ctx, options = {}) {
-  const global = await ctx.stateStore.getOrCreateGlobal();
-  global.graph ??= {};
-  const detection = await detectGitNexus();
-  const graph2 = await inspectGitNexusGraph(ctx.projectRoot);
-  let state = mergeGitNexusGraphInfo(toGitNexusState(detection, global.graph.gitnexus), graph2);
-  let gitnexusStatus = null;
-  if (options.runStatus && detection.installed) {
-    gitnexusStatus = await runGitNexus(["status"], { cwd: ctx.projectRoot });
-    state = {
-      ...state,
-      lastStatus: firstLine(gitnexusStatus.stdout) || firstLine(gitnexusStatus.stderr) || `exit ${gitnexusStatus.exitCode}`
-    };
   }
-  if (options.write ?? true) {
-    global.graph.gitnexus = state;
-    await ctx.stateStore.writeGlobal(global);
+  await atomicWrite(agentsPath, replaceManagedRegion(existingAgents, renderAgentsMd(scan, ctx.language)));
+  await atomicWrite(configPath, await mergeFetConfig(configPath, renderFetConfig(scan, ctx.language)));
+  await atomicWrite(claudePath, mergeKarpathyClaudeMd(existingClaude));
+  await atomicWrite(karpathyHandoffPath, renderKarpathyFetHandoff(ctx.language));
+  if (!existingKarpathyCursor || existingKarpathyCursor.includes("FET:MANAGED")) {
+    await atomicWrite(karpathyCursorPath, renderKarpathyCursorRule(ctx.language));
+  } else {
+    warnings.push(
+      ctx.language === "en" ? ".cursor/rules/karpathy-guidelines.mdc exists and is not managed by FET; leaving it unchanged." : ".cursor/rules/karpathy-guidelines.mdc \u5DF2\u5B58\u5728\u4E14\u4E0D\u7531 FET \u6258\u7BA1\uFF0C\u5DF2\u4FDD\u6301\u4E0D\u53D8\u3002"
+    );
   }
-  return {
-    state,
-    gitnexusStatus: gitnexusStatus ? {
-      exitCode: gitnexusStatus.exitCode,
-      command: gitnexusStatus.command,
-      stdout: gitnexusStatus.stdout.trim(),
-      stderr: gitnexusStatus.stderr.trim()
-    } : null
+  const placeholderCount = await countAgentsLlmPlaceholders(ctx.projectRoot);
+  if (placeholderCount > 0) {
+    warnings.push(renderAgentsPlaceholderWarning(placeholderCount, ctx.language));
+  }
+  const state = await ctx.stateStore.getOrCreateGlobal();
+  state.context = {
+    agentsMdUpdatedAt: scan.generatedAt,
+    configUpdatedAt: scan.generatedAt,
+    scannerVersion: scan.scannerVersion
   };
+  await ctx.stateStore.writeGlobal(state);
+  return { warnings };
 }
-async function writeHandoffFile(path, content) {
-  await mkdir4(dirname6(path), { recursive: true });
-  await atomicWrite(path, content);
+async function readOptional(path) {
+  try {
+    return await readFile6(path, "utf8");
+  } catch {
+    return null;
+  }
 }
-function renderGraphSetupHandoff(state) {
-  return `<!-- FET:MANAGED
-schemaVersion: 1
-generator: graph-setup
-FET:END -->
-
-# FET Graph Setup
-
-GitNexus graph support is optional. FET does not install GitNexus automatically and does not require graph support for OpenSpec workflows.
-
-Current status:
-
-- Installed: ${state.installed ? "yes" : "no"}
-- Executable: ${state.executablePath ?? "gitnexus"}
-- Version: ${state.version ?? "unknown"}
-- Graph path: ${state.graphPath ?? ".gitnexus"}
-- Graph exists: ${state.graphExists ? "yes" : "no"}
-
-Suggested setup flow:
-
-1. If GitNexus is not installed, install it using the method recommended by the GitNexus project.
-2. If you want GitNexus MCP or IDE integration, run \`gitnexus setup\` yourself after reviewing what it changes.
-3. Return to this project and run \`fet graph init\` to build the first graph.
-4. Run \`fet graph handoff\` so IDE AI can prefer graph context before broad repository scans.
-
-Guardrails:
 
-- Do not block FET/OpenSpec commands when GitNexus is unavailable.
-- Do not generate or modify application code during setup.
-- Do not run global IDE configuration commands unless the user explicitly approves them.
-`;
+// src/commands/init.ts
+async function initCommand(ctx) {
+  const alreadyInitialized = await exists2(join11(ctx.projectRoot, "openspec", "config.yaml"));
+  let warnings = [];
+  await withProjectLock(ctx.projectRoot, { command: "init", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    const journal = createInitJournal(ctx.fetVersion);
+    await writeInitJournal(ctx.projectRoot, journal);
+    const identity = await ctx.openSpec.resolveExecutable();
+    if (!alreadyInitialized) {
+      const result = await ctx.openSpec.run("init", ["--tools", "none"], { cwd: ctx.projectRoot, stdio: "inherit" });
+      if (result.exitCode !== 0) {
+        process.exitCode = result.exitCode;
+        return;
+      }
+    }
+    const contextResult = await updateContextFiles(ctx);
+    warnings = contextResult.warnings;
+    await ensureGitignore(ctx);
+    const state = await ctx.stateStore.getOrCreateGlobal();
+    state.openspec = identity;
+    state.language = {
+      current: ctx.language,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.graph ??= {};
+    const gitnexus = mergeGitNexusGraphInfo(toGitNexusState(await detectGitNexus(), state.graph.gitnexus), await inspectGitNexusGraph(ctx.projectRoot));
+    if (!gitnexus.installed && !gitnexus.recommendationShownAt) {
+      warnings.push(renderGitNexusRecommendation(gitnexus, ctx.language));
+      gitnexus.recommendationShownAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    state.graph.gitnexus = gitnexus;
+    for (const adapter of ctx.toolAdapters) {
+      const plan = await adapter.planInstall(ctx.projectRoot, ctx.language);
+      const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
+      state.toolAdapters[adapter.tool] = {
+        adapterVersion: adapter.adapterVersion,
+        installed: true,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      journal.steps.push(...result.written.map((path) => ({ operation: "write", path, status: "done" })));
+    }
+    journal.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeInitJournal(ctx.projectRoot, journal);
+    await ctx.stateStore.writeGlobal(state);
+  });
+  ctx.output.result({
+    ok: true,
+    command: "init",
+    summary: ctx.language === "en" ? "FET initialization completed." : "FET \u521D\u59CB\u5316\u5B8C\u6210\u3002",
+    warnings,
+    nextSteps: ctx.language === "en" ? ["Use fet propose/new to create an OpenSpec change", "Use fet doctor to check project health"] : ["\u4F7F\u7528 fet propose/new \u521B\u5EFA OpenSpec change", "\u4F7F\u7528 fet doctor \u68C0\u67E5\u9879\u76EE\u72B6\u6001"]
+  });
 }
-function renderGraphUsageHandoff(state) {
-  return `<!-- FET:MANAGED
-schemaVersion: 1
-generator: graph-handoff
-FET:END -->
-
-# FET Graph Handoff
-
-Use GitNexus graph context as an optional first pass before broad repository scans.
-
-Current status:
-
-- Installed: ${state.installed ? "yes" : "no"}
-- Graph path: ${state.graphPath ?? ".gitnexus"}
-- Graph exists: ${state.graphExists ? "yes" : "no"}
-- Last indexed at: ${state.lastIndexedAt ?? "unknown"}
-- Last status: ${state.lastStatus ?? "unknown"}
-
-When graph context is available:
-
-1. Use the graph to identify likely modules, dependencies, and insertion points.
-2. Read only the concrete source files needed to confirm behavior.
-3. Prefer OpenSpec artifacts and AGENTS.md over graph guesses when they conflict.
-4. Fall back to normal repository inspection if the graph is missing, stale, or incomplete.
-
-When producing OpenSpec artifacts:
-
-- Use graph context to make proposal, design, specs, and tasks more precise.
-- Avoid large repository scans when the graph already narrows the relevant area.
-- Keep all generated artifacts in the normal OpenSpec change directory.
-`;
+async function ensureGitignore(ctx) {
+  const gitignorePath = join11(ctx.projectRoot, ".gitignore");
+  const existing = await readOptional2(gitignorePath);
+  await atomicWrite(gitignorePath, mergeGitignore(existing));
 }
-function firstLine(value) {
-  return value.trim().split(/\r?\n/)[0]?.trim() || null;
+async function readOptional2(path) {
+  try {
+    return await readFile7(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists2(path) {
+  try {
+    await stat4(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 // src/commands/proxy.ts
@@ -1206,6 +1363,22 @@ async function git(cwd, args) {
 import { mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
 import { join as join12 } from "path";
 
+// src/language.ts
+var DEFAULT_LANGUAGE = "zh-CN";
+function normalizeLanguage(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return DEFAULT_LANGUAGE;
+  }
+  if (["en", "en-us", "english"].includes(normalized)) {
+    return "en";
+  }
+  return DEFAULT_LANGUAGE;
+}
+function languageInstruction(language) {
+  return language === "en" ? "Use English for FET interaction messages, generated handoff documents, and IDE prompt output unless the user asks otherwise." : "\u9664\u975E\u7528\u6237\u53E6\u6709\u660E\u786E\u8981\u6C42\uFF0CFET \u7684\u4EA4\u4E92\u4FE1\u606F\u3001\u751F\u6210\u7684\u4EA4\u63A5\u6587\u6863\u548C IDE \u63D0\u793A\u4EA7\u51FA\u5747\u4F7F\u7528\u4E2D\u6587\u3002";
+}
+
 // src/state/schema.ts
 var phases = ["explore", "propose", "implement", "verify", "sync", "archive"];
 function createGlobalState(fetVersion, project) {
@@ -1216,6 +1389,10 @@ function createGlobalState(fetVersion, project) {
     createdAt: now,
     updatedAt: now,
     project,
+    language: {
+      current: DEFAULT_LANGUAGE,
+      updatedAt: now
+    },
     openspec: null,
     activeChangeId: null,
     openChangeIds: [],
@@ -1239,9 +1416,7 @@ function createChangeState(fetVersion, changeId, phase) {
     createdAt: now,
     updatedAt: now,
     currentPhase: phase,
-    phases: Object.fromEntries(
-      phases.map((item) => [item, { status: item === phase ? "in_progress" : "not_started" }])
-    ),
+    phases: Object.fromEntries(phases.map((item) => [item, { status: item === phase ? "in_progress" : "not_started" }])),
     tasks: {
       source: "tasks.md",
       completedIds: [],
@@ -1256,6 +1431,12 @@ function assertGlobalState(value) {
   if (!isRecord(value) || value.schemaVersion !== 1) {
     throw unsupportedSchema("\u5168\u5C40\u72B6\u6001 schema \u4E0D\u53D7\u652F\u6301");
   }
+  if (!isRecord(value.language)) {
+    value.language = {
+      current: DEFAULT_LANGUAGE,
+      updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
   if (typeof value.fetVersion !== "string" || !isRecord(value.project)) {
     throw corruptedState("\u5168\u5C40\u72B6\u6001\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5");
   }
@@ -1537,14 +1718,16 @@ function stripFetOptions(args) {
 async function mapOpenSpecCommand(ctx, command, args) {
   switch (command) {
     case "propose":
-    case "continue":
-    case "ff":
-    case "apply":
-    case "sync":
     case "bulk-archive":
     case "explore":
     case "onboard":
       return { command, args: withGlobalChange(ctx, args) };
+    case "continue":
+    case "ff":
+      return { command, args: await withDefaultChange(ctx, args, true) };
+    case "apply":
+    case "sync":
+      return { command, args: await withDefaultChange(ctx, args) };
     case "new":
       return { command: "new", args: args[0] === "change" ? args : ["change", ...args] };
     case "archive":
@@ -1568,6 +1751,18 @@ async function mapOpenSpecCommand(ctx, command, args) {
 function withGlobalChange(ctx, args) {
   return ctx.changeId ? ["--change", ctx.changeId, ...args] : args;
 }
+async function withDefaultChange(ctx, args, allowWithArgs = false) {
+  if (ctx.changeId) {
+    return ["--change", ctx.changeId, ...args];
+  }
+  if (args.includes("--change") || args.some((arg) => arg.startsWith("--change="))) {
+    return args;
+  }
+  if (args.length > 0 && !allowWithArgs) {
+    return args;
+  }
+  return ["--change", await requireChangeId(ctx), ...args];
+}
 async function requireChangeId(ctx) {
   if (ctx.changeId) {
     return ctx.changeId;
@@ -1813,8 +2008,18 @@ function detectCurrentModel(env = process.env) {
 function isHighCostModel(model) {
   return HIGH_COST_MODEL_PATTERNS.some((pattern) => pattern.test(model));
 }
+function getModelPolicyMode(env = process.env) {
+  const value = env.FET_MODEL_POLICY?.trim().toLowerCase();
+  if (value === "off" || env.FET_SKIP_MODEL_POLICY === "1") {
+    return "off";
+  }
+  if (value === "confirm") {
+    return "confirm";
+  }
+  return "warn";
+}
 function getCommandModelPolicyMismatch(command, env = process.env) {
-  if (env.FET_MODEL_POLICY === "off" || env.FET_SKIP_MODEL_POLICY === "1") {
+  if (getModelPolicyMode(env) === "off") {
     return null;
   }
   const detected = detectCurrentModel(env);
@@ -1843,15 +2048,26 @@ function getCommandModelPolicyMismatch(command, env = process.env) {
   }
   return null;
 }
-function formatModelPolicyMismatch(mismatch) {
-  const switchHint = mismatch.recommended === "high-cost" ? "Recommended models include GPT-5.5, GLM-5.1, GLM-5, Claude Opus, or Claude Sonnet." : "Recommended action: switch to a lower-cost model and reserve high-cost models for fet apply.";
-  return `${mismatch.reason} Detected ${mismatch.detected.source}="${mismatch.detected.name}". ${switchHint}`;
+function formatModelPolicyMismatch(mismatch, language = "zh-CN") {
+  if (language === "en") {
+    const switchHint2 = mismatch.recommended === "high-cost" ? "Recommended models include GPT-5.5, GLM-5.1, GLM-5, Claude Opus, or Claude Sonnet." : "Recommended action: switch to a lower-cost model and reserve high-cost models for fet apply.";
+    return `${mismatch.reason} Detected ${mismatch.detected.source}="${mismatch.detected.name}". ${switchHint2}`;
+  }
+  const switchHint = mismatch.recommended === "high-cost" ? "\u5EFA\u8BAE\u6A21\u578B\u5305\u62EC GPT-5.5\u3001GLM-5.1\u3001GLM-5\u3001Claude Opus \u6216 Claude Sonnet\u3002" : "\u5EFA\u8BAE\u5207\u6362\u5230\u4F4E\u6210\u672C\u6A21\u578B\uFF0C\u628A\u9AD8\u6210\u672C\u6A21\u578B\u7559\u7ED9 fet apply\u3002";
+  const reason = mismatch.recommended === "high-cost" ? "fet apply \u5C5E\u4E8E\u5B9E\u65BD\u9636\u6BB5\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u9AD8\u80FD\u529B/\u9AD8\u6210\u672C\u6A21\u578B\u3002" : `fet ${mismatch.command} \u4E0D\u662F\u5B9E\u65BD\u9636\u6BB5\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u4F4E\u6210\u672C\u6A21\u578B\u3002`;
+  return `${reason} \u68C0\u6D4B\u5230 ${mismatch.detected.source}="${mismatch.detected.name}"\u3002${switchHint}`;
 }
-function renderIdeModelPolicy(command) {
+function renderIdeModelPolicy(command, language = "zh-CN") {
+  if (language === "en") {
+    if (command === "apply") {
+      return "Model policy: this command is recommended to run with a high-capability/high-cost model such as GPT-5.5, GLM-5.1, GLM-5, Claude Opus, or Claude Sonnet. Treat this as advisory: do not interrupt the workflow solely to ask about switching models. Run the FET command unless the user explicitly asks to pause for a model switch, and report any FET model warning in the summary.";
+    }
+    return "Model policy: this command is recommended to run with a low-cost model. If the current IDE model is GPT-5.5, GLM-5.1, GLM-5, Claude Opus, Claude Sonnet, or another high-cost model, treat it as an advisory warning: do not interrupt the workflow solely to ask about switching models. Run the FET command unless the user explicitly asks to pause for a model switch, and report any FET model warning in the summary.";
+  }
   if (command === "apply") {
-    return "Model policy: this command is recommended to run with a high-capability/high-cost model such as GPT-5.5, GLM-5.1, GLM-5, Claude Opus, or Claude Sonnet. If the current IDE model is lower-cost, tell the user and ask whether to stop for a model switch or continue anyway.";
+    return "\u6A21\u578B\u7B56\u7565\uFF1A\u8BE5\u547D\u4EE4\u5EFA\u8BAE\u4F7F\u7528\u9AD8\u80FD\u529B/\u9AD8\u6210\u672C\u6A21\u578B\u8FD0\u884C\uFF0C\u4F8B\u5982 GPT-5.5\u3001GLM-5.1\u3001GLM-5\u3001Claude Opus \u6216 Claude Sonnet\u3002\u6B64\u63D0\u793A\u4EC5\u4F5C\u4E3A\u5EFA\u8BAE\uFF0C\u4E0D\u8981\u4EC5\u56E0\u6A21\u578B\u7B56\u7565\u800C\u6253\u65AD\u6D41\u7A0B\u8BE2\u95EE\u662F\u5426\u5207\u6362\u6A21\u578B\uFF1B\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\u5148\u5207\u6362\u6A21\u578B\uFF0C\u5426\u5219\u7EE7\u7EED\u8FD0\u884C FET \u547D\u4EE4\uFF0C\u5E76\u5728\u603B\u7ED3\u4E2D\u8BF4\u660E FET \u8F93\u51FA\u7684\u6A21\u578B\u63D0\u9192\u3002";
   }
-  return "Model policy: this command is recommended to run with a low-cost model. If the current IDE model is GPT-5.5, GLM-5.1, GLM-5, Claude Opus, Claude Sonnet, or another high-cost model, tell the user and ask whether to stop for a model switch or continue anyway.";
+  return "\u6A21\u578B\u7B56\u7565\uFF1A\u8BE5\u547D\u4EE4\u5EFA\u8BAE\u4F7F\u7528\u4F4E\u6210\u672C\u6A21\u578B\u8FD0\u884C\u3002\u82E5\u5F53\u524D IDE \u6A21\u578B\u662F GPT-5.5\u3001GLM-5.1\u3001GLM-5\u3001Claude Opus\u3001Claude Sonnet \u6216\u5176\u4ED6\u9AD8\u6210\u672C\u6A21\u578B\uFF0C\u6B64\u63D0\u793A\u4EC5\u4F5C\u4E3A\u5EFA\u8BAE\uFF1B\u4E0D\u8981\u4EC5\u56E0\u6A21\u578B\u7B56\u7565\u800C\u6253\u65AD\u6D41\u7A0B\u8BE2\u95EE\u662F\u5426\u5207\u6362\u6A21\u578B\u3002\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\u5148\u5207\u6362\u6A21\u578B\uFF0C\u5426\u5219\u7EE7\u7EED\u8FD0\u884C FET \u547D\u4EE4\uFF0C\u5E76\u5728\u603B\u7ED3\u4E2D\u8BF4\u660E FET \u8F93\u51FA\u7684\u6A21\u578B\u63D0\u9192\u3002";
 }
 
 // src/cli/context.ts
@@ -1890,7 +2106,7 @@ function renderFetAdapterUsage(command, args = "[...args]") {
 }
 
 // src/adapters/codex/templates.ts
-function codexGuideFile() {
+function codexGuideFile(language = DEFAULT_LANGUAGE) {
   return {
     path: ".codex/fet/context.md",
     content: `<!-- FET:MANAGED
@@ -1902,6 +2118,10 @@ FET:END -->
 
 # FET For Codex
 
+## \u8BED\u8A00
+
+${languageInstruction(language)}
+
 Before doing FET or OpenSpec work in Codex, read:
 
 - AGENTS.md
@@ -1917,22 +2137,22 @@ Command guides live in .codex/fet/commands/.
 `
   };
 }
-function codexCommandFiles() {
+function codexCommandFiles(language = DEFAULT_LANGUAGE) {
   return [
-    codexKarpathyGuidelinesFile(),
+    codexKarpathyGuidelinesFile(language),
     ...FET_ADAPTER_COMMANDS.map((command) => ({
       path: `.codex/fet/commands/${command}.md`,
-      content: renderCommand(command)
+      content: renderCommand(command, language)
     }))
   ];
 }
-function codexSlashPromptFiles() {
+function codexSlashPromptFiles(language = DEFAULT_LANGUAGE) {
   return FET_ADAPTER_COMMANDS.map((command) => ({
     path: `prompts/fet-${command}.md`,
-    content: renderSlashPrompt(command)
+    content: renderSlashPrompt(command, language)
   }));
 }
-function codexKarpathyGuidelinesFile() {
+function codexKarpathyGuidelinesFile(language) {
   return {
     path: ".codex/fet/karpathy-guidelines.md",
     content: `<!-- FET:MANAGED
@@ -1944,19 +2164,22 @@ FET:END -->
 
 # Andrej Karpathy Inspired Coding Guidelines
 
-${renderKarpathyGuidelinesBody()}
+${renderKarpathyGuidelinesBody(language)}
 `
   };
 }
-function renderCommand(command) {
+function renderCommand(command, language) {
+  if (language !== "en") {
+    return renderCommandZh(command);
+  }
   if (command === "fill-context") {
-    return renderFillContextCommand();
+    return renderFillContextCommand(language);
   }
   if (command === "passthrough") {
-    return renderPassthroughCommand();
+    return renderPassthroughCommand(language);
   }
   if (command.startsWith("graph-")) {
-    return renderGraphCommand(command);
+    return renderGraphCommand(command, language);
   }
   const usage = renderFetAdapterUsage(command, "");
   return `<!-- FET:MANAGED
@@ -1969,7 +2192,9 @@ FET:END -->
 
 # ${usage}
 
-${renderIdeModelPolicy(command)}
+${renderIdeModelPolicy(command, language)}
+
+${languageInstruction(language)}
 
 When the user asks Codex to run the FET ${command} workflow, first make sure the project context is loaded from AGENTS.md and openspec/config.yaml.
 
@@ -1988,7 +2213,41 @@ If the command needs a change id, pass it with \`--change <change-id>\` or use t
 After the command completes, report the important next steps from the FET output and keep any generated OpenSpec artifacts in the normal project workflow.
 `;
 }
-function renderPassthroughCommand() {
+function renderCommandZh(command) {
+  const usage = renderFetAdapterUsage(command, command === "fill-context" ? "" : command === "passthrough" ? "<openspec-command> [...args]" : "");
+  const title = commandTitleZh(command);
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: ${usage}
+FET:END -->
+
+# ${usage}
+
+${renderIdeModelPolicy(command, "zh-CN")}
+
+${languageInstruction("zh-CN")}
+
+## \u7528\u9014
+
+${title}
+
+## \u6267\u884C\u65B9\u5F0F
+
+\u5728\u6267\u884C\u524D\u9605\u8BFB AGENTS.md\u3001openspec/config.yaml\u3001.codex/fet/karpathy-guidelines.md\uFF0C\u4EE5\u53CA\u5F53\u524D change \u76EE\u5F55\u4E0B\u5DF2\u6709\u7684 OpenSpec \u4EA7\u7269\u3002
+
+\`\`\`sh
+${usage}
+\`\`\`
+
+\u5982\u679C\u547D\u4EE4\u9700\u8981 change id\uFF0C\u4F18\u5148\u4F7F\u7528\u7528\u6237\u8F93\u5165\u3001\`--change <change-id>\`\u3001FET active change \u6216\u552F\u4E00\u6253\u5F00\u7684 change\u3002\u5B58\u5728\u6B67\u4E49\u65F6\u5148\u8BE2\u95EE\u7528\u6237\u3002
+
+\u6267\u884C\u5B8C\u6210\u540E\uFF0C\u7528\u4E2D\u6587\u603B\u7ED3\u5173\u952E\u8F93\u51FA\u3001\u751F\u6210\u6216\u66F4\u65B0\u7684\u6587\u4EF6\uFF0C\u4EE5\u53CA\u4E0B\u4E00\u6B65\u5EFA\u8BAE\u3002
+`;
+}
+function renderPassthroughCommand(language) {
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -1999,7 +2258,9 @@ FET:END -->
 
 # fet passthrough
 
-${renderIdeModelPolicy("passthrough")}
+${renderIdeModelPolicy("passthrough", language)}
+
+${languageInstruction(language)}
 
 When the user asks Codex to run an OpenSpec command that FET does not manage as a first-class workflow command, use FET passthrough instead of calling OpenSpec directly.
 
@@ -2016,7 +2277,7 @@ fet passthrough <openspec-command> [...args]
 This preserves the FET entry point while allowing access to unmanaged or newly added OpenSpec commands. Passthrough does not update FET lifecycle state.
 `;
 }
-function renderGraphCommand(command) {
+function renderGraphCommand(command, language) {
   const usage = renderFetAdapterUsage(command, "");
   const subcommand = command.slice("graph-".length);
   return `<!-- FET:MANAGED
@@ -2029,7 +2290,9 @@ FET:END -->
 
 # ${usage}
 
-${renderIdeModelPolicy(command)}
+${renderIdeModelPolicy(command, language)}
+
+${languageInstruction(language)}
 
 When the user asks Codex to work with optional GitNexus graph support, use FET as the entry point.
 
@@ -2048,42 +2311,45 @@ For graph init or refresh, pass extra GitNexus analyze arguments only when the u
 After the command completes, report the GitNexus state, generated handoff files, and next steps.
 `;
 }
-function renderSlashPrompt(command) {
+function renderSlashPrompt(command, language) {
+  if (language !== "en") {
+    return renderSlashPromptZh(command);
+  }
   if (command === "continue") {
-    return renderContinueSlashPrompt();
+    return renderContinueSlashPrompt(language);
   }
   if (command === "ff" || command === "propose") {
-    return renderFastForwardSlashPrompt(command);
+    return renderFastForwardSlashPrompt(command, language);
   }
   if (command === "explore") {
-    return renderExploreSlashPrompt();
+    return renderExploreSlashPrompt(language);
   }
   if (command === "new") {
-    return renderNewSlashPrompt();
+    return renderNewSlashPrompt(language);
   }
   if (command === "apply") {
-    return renderApplySlashPrompt();
+    return renderApplySlashPrompt(language);
   }
   if (command === "verify") {
-    return renderVerifySlashPrompt();
+    return renderVerifySlashPrompt(language);
   }
   if (command === "sync") {
-    return renderSyncSlashPrompt();
+    return renderSyncSlashPrompt(language);
   }
   if (command === "archive") {
-    return renderArchiveSlashPrompt();
+    return renderArchiveSlashPrompt(language);
   }
   if (command === "bulk-archive") {
-    return renderBulkArchiveSlashPrompt();
+    return renderBulkArchiveSlashPrompt(language);
   }
   if (command === "onboard") {
-    return renderOnboardSlashPrompt();
+    return renderOnboardSlashPrompt(language);
   }
   if (command === "fill-context") {
-    return renderFillContextSlashPrompt();
+    return renderFillContextSlashPrompt(language);
   }
   if (command === "passthrough") {
-    return renderPassthroughSlashPrompt();
+    return renderPassthroughSlashPrompt(language);
   }
   const usage = renderFetAdapterUsage(command);
   const isGraph = command.startsWith("graph-");
@@ -2099,7 +2365,6 @@ FET:END -->
 
 ---
 description: ${description}
-argument-hint: command arguments
 ---
 
 Use FET as the entry point for this OpenSpec workflow.
@@ -2119,7 +2384,89 @@ ${shellCommand}
 After it completes, summarize the important FET output and next steps.
 `;
 }
-function renderFillContextCommand() {
+function renderSlashPromptZh(command) {
+  const usage = renderFetAdapterUsage(command, command === "fill-context" ? "" : command === "passthrough" ? "<openspec-command> [...args]" : "[...args]");
+  const argumentHint = command === "passthrough" ? "openspec-command [...args]" : void 0;
+  const argumentHintLine = argumentHint ? `argument-hint: ${argumentHint}
+` : "";
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: ${usage}
+FET:END -->
+
+---
+description: ${commandTitleZh(command)}
+${argumentHintLine}---
+
+${renderIdeModelPolicy(command, "zh-CN")}
+
+${languageInstruction("zh-CN")}
+
+## \u76EE\u6807
+
+${commandGoalZh(command)}
+
+## \u6B65\u9AA4
+
+1. \u9605\u8BFB AGENTS.md\u3001openspec/config.yaml \u548C .codex/fet/karpathy-guidelines.md\u3002
+2. \u5982\u679C\u5B58\u5728\u5F53\u524D OpenSpec change\uFF0C\u9605\u8BFB openspec/changes/<change-id>/ \u4E0B\u7684\u76F8\u5173\u4EA7\u7269\u3002
+3. \u8FD0\u884C FET \u547D\u4EE4\uFF1A
+   \`\`\`sh
+   ${usage}
+   \`\`\`
+4. \u6309 FET/OpenSpec \u8F93\u51FA\u7EE7\u7EED\uFF1B\u9700\u8981\u5199\u4EA7\u7269\u65F6\uFF0C\u53EA\u5199\u5230 OpenSpec \u6307\u5B9A\u8DEF\u5F84\uFF0C\u4E0D\u8981\u628A\u63D0\u793A\u5305\u88C5\u6587\u672C\u590D\u5236\u8FDB\u4EA7\u7269\u3002
+5. \u7528\u4E2D\u6587\u603B\u7ED3\u672C\u6B21\u52A8\u4F5C\u3001\u6587\u4EF6\u8DEF\u5F84\u3001\u72B6\u6001\u548C\u4E0B\u4E00\u6B65\u3002
+
+## \u7EA6\u675F
+
+- \u9ED8\u8BA4\u4F7F\u7528\u4E2D\u6587\u4EA7\u51FA\u3002
+- \u4E0D\u8981\u7ED5\u8FC7 FET \u76F4\u63A5\u8C03\u7528 openspec\uFF0C\u9664\u975E FET \u547D\u4EE4\u672C\u8EAB\u4E0D\u53EF\u7528\u3002
+- change \u4E0D\u660E\u786E\u65F6\u5148\u8BE2\u95EE\u7528\u6237\u3002
+${command === "fill-context" ? "- \u66FF\u6362 AGENTS.md \u4E2D\u6BCF\u4E2A `[NEEDS LLM INPUT]` \u6216 `[NEED LLM INPUT]` \u5360\u4F4D\u7B26\uFF0C\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002\n" : ""}${command === "continue" ? "- \u4E00\u6B21\u53EA\u521B\u5EFA\u4E00\u4E2A ready artifact\uFF0C\u5E76\u5728\u5199\u5165\u524D\u9605\u8BFB\u4F9D\u8D56\u6587\u4EF6\u3002\n" : ""}${command === "apply" ? "- \u4E0D\u8981\u5728\u672A\u5B8C\u6210\u771F\u5B9E\u5B9E\u73B0\u524D\u52FE\u9009 tasks.md\uFF1B\u4E0D\u8981\u4ECE apply \u9636\u6BB5\u76F4\u63A5 sync \u6216 archive\u3002\n" : ""}`;
+}
+function commandTitleZh(command) {
+  const titles = {
+    explore: "\u63A2\u7D22 FET/OpenSpec \u9700\u6C42",
+    propose: "\u521B\u5EFA\u5E76\u8865\u9F50 FET/OpenSpec \u63D0\u6848\u4EA7\u7269",
+    new: "\u521B\u5EFA\u65B0\u7684 FET/OpenSpec change \u9AA8\u67B6",
+    continue: "\u63A8\u8FDB\u5F53\u524D FET/OpenSpec change \u7684\u4E0B\u4E00\u4E2A\u4EA7\u7269",
+    ff: "\u5FEB\u901F\u751F\u6210 FET/OpenSpec \u6240\u9700\u4EA7\u7269",
+    apply: "\u5B9E\u65BD FET/OpenSpec change \u4E2D\u7684\u4EFB\u52A1",
+    verify: "\u9A8C\u8BC1 FET/OpenSpec change",
+    sync: "\u540C\u6B65 delta specs \u5230\u4E3B\u89C4\u8303",
+    archive: "\u5F52\u6863\u5DF2\u9A8C\u8BC1\u7684 FET/OpenSpec change",
+    "bulk-archive": "\u6279\u91CF\u5F52\u6863 FET/OpenSpec changes",
+    onboard: "\u52A0\u8F7D FET/OpenSpec \u9879\u76EE\u4E0A\u4E0B\u6587",
+    "fill-context": "\u586B\u5145 FET AGENTS.md \u5360\u4F4D\u7B26",
+    passthrough: "\u901A\u8FC7 FET \u900F\u4F20\u672A\u63A5\u7BA1\u7684 OpenSpec \u547D\u4EE4",
+    "graph-status": "\u67E5\u770B GitNexus \u4EE3\u7801\u56FE\u72B6\u6001",
+    "graph-setup": "\u751F\u6210 GitNexus \u5B89\u88C5\u4EA4\u63A5\u8BF4\u660E",
+    "graph-init": "\u521D\u59CB\u5316 GitNexus \u4EE3\u7801\u56FE",
+    "graph-refresh": "\u5237\u65B0 GitNexus \u4EE3\u7801\u56FE",
+    "graph-doctor": "\u8BCA\u65AD GitNexus \u4EE3\u7801\u56FE",
+    "graph-handoff": "\u751F\u6210 GitNexus \u4EE3\u7801\u56FE\u4F7F\u7528\u8BF4\u660E"
+  };
+  return titles[command] ?? `\u8FD0\u884C FET ${command} \u5DE5\u4F5C\u6D41`;
+}
+function commandGoalZh(command) {
+  if (command === "fill-context") {
+    return "\u8865\u9F50 FET \u81EA\u52A8\u751F\u6210\u7684\u9879\u76EE\u4E0A\u4E0B\u6587\uFF0C\u8BA9\u540E\u7EED AI \u7F16\u7801\u548C OpenSpec \u5DE5\u4F5C\u6D41\u62E5\u6709\u7A33\u5B9A\u7684\u9879\u76EE\u4E8B\u5B9E\u3002";
+  }
+  if (command === "continue") {
+    return "\u57FA\u4E8E active change \u6216\u7528\u6237\u6307\u5B9A\u7684 change\uFF0C\u521B\u5EFA\u4E0B\u4E00\u4E2A ready \u7684 OpenSpec \u89C4\u5212\u4EA7\u7269\u3002";
+  }
+  if (command === "apply") {
+    return "\u8BFB\u53D6 OpenSpec \u4EA7\u7269\u5E76\u6309 tasks.md \u5B9E\u65BD\u4EE3\u7801\u53D8\u66F4\u3002";
+  }
+  if (command.startsWith("graph-")) {
+    return "\u7BA1\u7406\u53EF\u9009\u7684 GitNexus \u4EE3\u7801\u56FE\uFF0C\u8BA9 AI \u5728\u5927\u8303\u56F4\u626B\u63CF\u524D\u4F18\u5148\u83B7\u5F97\u7ED3\u6784\u5316\u4EE3\u7801\u4E0A\u4E0B\u6587\u3002";
+  }
+  return commandTitleZh(command);
+}
+function renderFillContextCommand(language) {
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -2130,7 +2477,9 @@ FET:END -->
 
 # fet fill-context
 
-${renderIdeModelPolicy("fill-context")}
+${renderIdeModelPolicy("fill-context", language)}
+
+${languageInstruction(language)}
 
 Use this command to complete FET-generated project context placeholders with Codex.
 
@@ -2147,7 +2496,7 @@ fet fill-context
 Then read AGENTS.md and openspec/config.yaml, inspect the project, and replace every [NEEDS LLM INPUT] or [NEED LLM INPUT] placeholder in AGENTS.md with concrete project-specific content. Preserve FET managed markers and do not modify business code.
 `;
 }
-function renderFillContextSlashPrompt() {
+function renderFillContextSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet fill-context",
     "Fill FET AGENTS.md placeholders with Codex",
@@ -2179,10 +2528,12 @@ Steps:
 Guardrails:
 - Do not invent facts that cannot be inferred from the repo.
 - Use [UNKNOWN] only when the repository does not contain enough evidence.
-- Keep generated context stable and useful for future AI coding sessions.`
+- Keep generated context stable and useful for future AI coding sessions.`,
+    void 0,
+    language
   );
 }
-function renderNewSlashPrompt() {
+function renderNewSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet new [...args]",
     "Create a new FET/OpenSpec change scaffold",
@@ -2211,20 +2562,22 @@ Steps:
 Guardrails:
 - Do not create artifact files in /prompts:fet-new.
 - If the change already exists, suggest /prompts:fet-continue <change-id>.
-- Show the change location and the next command to create the first artifact.`
+- Show the change location and the next command to create the first artifact.`,
+    void 0,
+    language
   );
 }
-function renderApplySlashPrompt() {
+function renderApplySlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet apply [...args]",
     "Implement tasks from a FET/OpenSpec change",
     `Implement a FET-managed OpenSpec change.
 
-Input after the slash command should identify the change, for example a change id or --change <change-id>.
+Input after the slash command may identify the change, for example a change id or --change <change-id>. If omitted, use the active OpenSpec change when it is unambiguous.
 
 Steps:
 
-1. Resolve the change id. If ambiguous, ask the user.
+1. Resolve the change id from the input, active FET/OpenSpec state, or the only open change. If ambiguous, ask the user.
 2. Run the native OpenSpec apply flow through FET:
    \`\`\`sh
    fet apply --change <change-id> --json
@@ -2241,20 +2594,22 @@ Steps:
 Guardrails:
 - Never skip reading OpenSpec artifacts before implementation.
 - Do not mark a task complete until the code change is actually done.
-- Do not run sync or archive from apply.`
+- Do not run sync or archive from apply.`,
+    void 0,
+    language
   );
 }
-function renderVerifySlashPrompt() {
+function renderVerifySlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet verify [...args]",
     "Verify a FET/OpenSpec change before sync or archive",
     `Verify a FET-managed OpenSpec change.
 
-Input after the slash command should identify the change. If the user passes --done, declare verification complete only after checks have been performed or explicitly accepted by the user.
+Input after the slash command may identify the change. If omitted, use the active OpenSpec change when it is unambiguous. If the user passes --done, declare verification complete only after checks have been performed or explicitly accepted by the user.
 
 Steps:
 
-1. Resolve the change id. If ambiguous, ask the user.
+1. Resolve the change id from the input, active FET/OpenSpec state, or the only open change. If ambiguous, ask the user.
 2. Generate FET verification instructions:
    \`\`\`sh
    fet verify --change <change-id>
@@ -2274,20 +2629,22 @@ Steps:
 Guardrails:
 - Do not run --done before producing a verification assessment.
 - Treat incomplete tasks or missing required behavior as critical unless user explicitly accepts them.
-- Suggest /prompts:fet-sync <change-id> and /prompts:fet-archive <change-id> only after verification is done.`
+- Suggest /prompts:fet-sync <change-id> and /prompts:fet-archive <change-id> only after verification is done.`,
+    void 0,
+    language
   );
 }
-function renderSyncSlashPrompt() {
+function renderSyncSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet sync [...args]",
     "Sync delta specs and validate a FET/OpenSpec change",
     `Sync a FET-managed OpenSpec change.
 
-Input after the slash command should identify the change.
+Input after the slash command may identify the change. If omitted, use the active OpenSpec change when it is unambiguous.
 
 Steps:
 
-1. Resolve the change id. If ambiguous, ask the user.
+1. Resolve the change id from the input, active FET/OpenSpec state, or the only open change. If ambiguous, ask the user.
 2. Confirm FET verification is complete or run /prompts:fet-verify <change-id> first.
 3. Find delta specs under openspec/changes/<change-id>/specs/*/spec.md.
 4. If delta specs exist, intelligently merge them into openspec/specs/<capability>/spec.md:
@@ -2306,20 +2663,22 @@ Steps:
 Guardrails:
 - Read both delta and main specs before editing.
 - Make sync idempotent where possible.
-- If FET reports verify is not done, stop and run/ask for verification instead of bypassing the gate.`
+- If FET reports verify is not done, stop and run/ask for verification instead of bypassing the gate.`,
+    void 0,
+    language
   );
 }
-function renderArchiveSlashPrompt() {
+function renderArchiveSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet archive [...args]",
     "Archive a verified FET/OpenSpec change",
     `Archive a FET-managed OpenSpec change.
 
-Input after the slash command should identify the change.
+Input after the slash command may identify the change. If omitted, use the active OpenSpec change when it is unambiguous.
 
 Steps:
 
-1. Resolve the change id. If ambiguous, ask the user.
+1. Resolve the change id from the input, active FET/OpenSpec state, or the only open change. If ambiguous, ask the user.
 2. Check artifact and task status:
    \`\`\`sh
    fet passthrough status --change <change-id> --json
@@ -2336,10 +2695,12 @@ Steps:
 Guardrails:
 - Do not move change directories manually; use fet archive.
 - Do not bypass the FET verify gate.
-- Ask before archiving with incomplete tasks or unsynced delta specs.`
+- Ask before archiving with incomplete tasks or unsynced delta specs.`,
+    void 0,
+    language
   );
 }
-function renderBulkArchiveSlashPrompt() {
+function renderBulkArchiveSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet bulk-archive [...args]",
     "Archive multiple FET/OpenSpec changes safely",
@@ -2363,10 +2724,12 @@ Steps:
 Guardrails:
 - Never archive all changes without explicit user selection.
 - Do not bypass verify or warnings for individual changes.
-- Continue with remaining selected changes if one archive fails, then report the failure clearly.`
+- Continue with remaining selected changes if one archive fails, then report the failure clearly.`,
+    void 0,
+    language
   );
 }
-function renderOnboardSlashPrompt() {
+function renderOnboardSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet onboard [...args]",
     "Load FET/OpenSpec onboarding context",
@@ -2377,7 +2740,7 @@ Steps:
 1. Read AGENTS.md and openspec/config.yaml.
 2. Run FET onboarding:
    \`\`\`sh
-   fet onboard $ARGUMENTS
+   fet onboard
    \`\`\`
 3. Summarize:
    - Project context.
@@ -2387,10 +2750,12 @@ Steps:
 
 Guardrails:
 - Do not create or modify artifacts during onboard.
-- Use this command to orient the session, then suggest the next concrete FET command.`
+- Use this command to orient the session, then suggest the next concrete FET command.`,
+    void 0,
+    language
   );
 }
-function renderPassthroughSlashPrompt() {
+function renderPassthroughSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet passthrough <openspec-command> [...args]",
     "Run an unmanaged OpenSpec command through FET",
@@ -2408,10 +2773,12 @@ Steps:
 Guardrails:
 - Do not call openspec directly unless FET passthrough itself is unavailable.
 - Remember that passthrough does not update FET lifecycle state.
-- For managed workflows, prefer the specific FET prompt instead of passthrough.`
+- For managed workflows, prefer the specific FET prompt instead of passthrough.`,
+    "openspec-command [...args]",
+    language
   );
 }
-function renderExploreSlashPrompt() {
+function renderExploreSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet explore [...args]",
     "Explore requirements for a FET/OpenSpec change",
@@ -2443,21 +2810,23 @@ Guardrails:
 - Do not write application code in explore mode.
 - Ask a clarifying question if the proposal would otherwise be mostly guesswork.
 - Creating or updating OpenSpec artifacts is allowed when the user asks to capture the thinking.
-- After creating proposal.md, show the path and suggest /prompts:fet-continue <change-id> for the next artifact.`
+- After creating proposal.md, show the path and suggest /prompts:fet-continue <change-id> for the next artifact.`,
+    void 0,
+    language
   );
 }
-function renderContinueSlashPrompt() {
+function renderContinueSlashPrompt(language) {
   return renderManagedSlashPrompt(
     "fet continue [...args]",
     "Create the next FET/OpenSpec artifact",
     `Continue a FET-managed OpenSpec change by creating exactly one ready artifact.
 
-Input after the slash command should be a change id, optionally followed by an artifact id.
+Input after the slash command may be a change id, optionally followed by an artifact id. If omitted, use the active OpenSpec change and continue the next ready artifact.
 
 Steps:
 
 1. Load project context from AGENTS.md and openspec/config.yaml.
-2. Resolve the change id. If it is missing and cannot be inferred unambiguously, ask the user.
+2. Resolve the change id from the input, active FET/OpenSpec state, or the only open change. If ambiguous, ask the user.
 3. Check status:
    \`\`\`sh
    fet passthrough status --change <change-id> --json
@@ -2465,7 +2834,7 @@ Steps:
 4. Pick the first artifact whose status is ready, unless the user specified an artifact id.
 5. Run the native OpenSpec continue flow through FET:
    \`\`\`sh
-   fet continue <artifact-id> --change <change-id> --json
+   fet continue [artifact-id] --change <change-id> --json
    \`\`\`
 6. Follow the native continue output. When it provides template, instruction, dependencies, and outputPath, use those fields.
 7. Read dependency files before writing.
@@ -2483,10 +2852,12 @@ Output:
 Guardrails:
 - Create one artifact per invocation.
 - Never skip dependency order.
-- Ask the user if instructions are ambiguous enough that a useful artifact cannot be written.`
+- Ask the user if instructions are ambiguous enough that a useful artifact cannot be written.`,
+    void 0,
+    language
   );
 }
-function renderFastForwardSlashPrompt(command) {
+function renderFastForwardSlashPrompt(command, language) {
   const title = command === "propose" ? "Propose a new FET/OpenSpec change" : "Fast-forward FET/OpenSpec artifact creation";
   const commandLine = command === "propose" ? "fet propose <change-id-or-description>" : "fet ff --change <change-id>";
   return renderManagedSlashPrompt(
@@ -2494,7 +2865,7 @@ function renderFastForwardSlashPrompt(command) {
     command === "propose" ? "Create a change and generate required OpenSpec artifacts" : "Generate required OpenSpec artifacts for a change",
     `${title}.
 
-Input after the slash command may be a change id or a description of what the user wants to build.
+Input after the slash command may be a change id or a description of what the user wants to build. For ff, it may be omitted when the active OpenSpec change is unambiguous.
 
 Steps:
 
@@ -2517,11 +2888,15 @@ Output:
 - Change id and location.
 - Artifacts created.
 - Current status.
-- Next recommended command, usually /prompts:fet-apply <change-id>.`
+- Next recommended command, usually /prompts:fet-apply <change-id>.`,
+    void 0,
+    language
   );
 }
-function renderManagedSlashPrompt(command, description, body) {
+function renderManagedSlashPrompt(command, description, body, argumentHint, language = DEFAULT_LANGUAGE) {
   const policyCommand = command.split(/\s+/)[1] ?? command;
+  const argumentHintLine = argumentHint ? `argument-hint: ${argumentHint}
+` : "";
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -2532,10 +2907,11 @@ FET:END -->
 
 ---
 description: ${description}
-argument-hint: command arguments
----
+${argumentHintLine}---
+
+${renderIdeModelPolicy(policyCommand, language)}
 
-${renderIdeModelPolicy(policyCommand)}
+${languageInstruction(language)}
 
 If GitNexus graph context is available, consult it before broad source scans and use it to narrow the files you read. If it is unavailable, continue normally.
 
@@ -2553,16 +2929,16 @@ var CodexAdapter = class {
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
-  async planInstall(_projectRoot) {
+  async planInstall(_projectRoot, language) {
     return {
       tool: this.tool,
       files: [
-        ...[codexGuideFile(), ...codexCommandFiles()].map((file) => ({
+        ...[codexGuideFile(language), ...codexCommandFiles(language)].map((file) => ({
           ...file,
           managed: true,
           root: "project"
         })),
-        ...codexSlashPromptFiles().map((file) => ({
+        ...codexSlashPromptFiles(language).map((file) => ({
           ...file,
           managed: true,
           root: "codex-home"
@@ -2649,13 +3025,13 @@ import { mkdir as mkdir8, readFile as readFile13, stat as stat7 } from "fs/promi
 import { dirname as dirname8, join as join16 } from "path";
 
 // src/adapters/cursor/templates.ts
-function cursorSkillFiles() {
+function cursorSkillFiles(language = DEFAULT_LANGUAGE) {
   return FET_ADAPTER_COMMANDS.map((command) => ({
     path: `.cursor/skills/fet-${command}/SKILL.md`,
-    content: renderSkill(command)
+    content: renderSkill(command, language)
   }));
 }
-function cursorRuleFile() {
+function cursorRuleFile(language = DEFAULT_LANGUAGE) {
   return {
     path: ".cursor/rules/fet-context.mdc",
     content: `<!-- FET:MANAGED
@@ -2666,22 +3042,24 @@ adapterVersion: 1
 FET:END -->
 
 ---
-description: Load FET project context for implementation tasks
+description: ${language === "en" ? "Load FET project context for implementation tasks" : "\u4E3A\u5B9E\u73B0\u4EFB\u52A1\u52A0\u8F7D FET \u9879\u76EE\u4E0A\u4E0B\u6587"}
 alwaysApply: false
 ---
 
+${languageInstruction(language)}
+
 \u5F53\u7528\u6237\u8BF7\u6C42\u4FEE\u6539\u9879\u76EE\u3001\u5B9E\u73B0 OpenSpec change\u3001\u8FD0\u884C FET \u5DE5\u4F5C\u6D41\u6216\u89E3\u91CA\u9879\u76EE\u7ED3\u6784\u65F6\uFF0C\u4F18\u5148\u9605\u8BFB\uFF1A
 
 - AGENTS.md
 - openspec/config.yaml
-- GitNexus code graph context, when available. Prefer it before broad repository scans; if it is unavailable, continue normally.
-- \u5F53\u524D change \u76EE\u5F55\u4E0B\u7684 OpenSpec \u89C4\u5212\u4EA7\u7269
+- \u53EF\u7528\u65F6\u7684 GitNexus \u4EE3\u7801\u56FE\u4E0A\u4E0B\u6587\u3002\u4F18\u5148\u7528\u5B83\u7F29\u5C0F\u8303\u56F4\uFF1B\u4E0D\u53EF\u7528\u65F6\u6309\u666E\u901A FET/OpenSpec \u5DE5\u4F5C\u6D41\u7EE7\u7EED\u3002
+- \u5F53\u524D change \u76EE\u5F55\u4E0B\u7684 OpenSpec \u89C4\u5212\u4EA7\u7269\u3002
 
-\u5982\u679C\u7528\u6237\u8F93\u5165\u7C7B\u4F3C \`/fet apply\` \u7684\u8BF7\u6C42\uFF0CCursor \u5F53\u524D\u7248\u672C\u672A\u5FC5\u4F1A\u628A\u672C\u6587\u4EF6\u6CE8\u518C\u4E3A\u539F\u751F slash command\u3002\u6B64\u65F6\u8BF7\u628A\u5B83\u5F53\u4F5C\u5DE5\u4F5C\u6D41\u610F\u56FE\uFF0C\u5E76\u63D0\u793A\u7528\u6237\u5728\u7EC8\u7AEF\u6267\u884C\u5BF9\u5E94\u7684 \`fet <cmd>\` \u547D\u4EE4\u3002
+\u5982\u679C\u7528\u6237\u8F93\u5165\u7C7B\u4F3C \`/fet apply\` \u7684\u8BF7\u6C42\uFF0C\u8BF7\u628A\u5B83\u89C6\u4E3A\u5DE5\u4F5C\u6D41\u610F\u56FE\uFF0C\u5E76\u63D0\u793A\u6216\u6267\u884C\u5BF9\u5E94\u7684\u7EC8\u7AEF\u547D\u4EE4 \`fet <cmd>\`\u3002
 `
   };
 }
-function renderSkill(command) {
+function renderSkill(command, language) {
   const usage = renderFetAdapterUsage(command, command === "passthrough" ? "[...args]" : "");
   if (command === "fill-context") {
     return `<!-- FET:MANAGED
@@ -2694,22 +3072,22 @@ FET:END -->
 
 ---
 name: fet-fill-context
-description: Fill FET AGENTS.md placeholders with Cursor AI
+description: ${language === "en" ? "Fill FET AGENTS.md placeholders with Cursor AI" : "\u4F7F\u7528 Cursor AI \u586B\u5145 FET AGENTS.md \u5360\u4F4D\u7B26"}
 disable-model-invocation: false
 ---
 
-Run \`fet fill-context\` first if the IDE commands need refreshing.
+${renderIdeModelPolicy(command, language)}
 
-${renderIdeModelPolicy(command)}
+${languageInstruction(language)}
 
-If GitNexus code graph context is available in Cursor, prefer it before broad repository scans. If it is unavailable, continue normally.
+\u5982\u679C IDE \u547D\u4EE4\u9700\u8981\u5237\u65B0\uFF0C\u5148\u8FD0\u884C \`fet fill-context\`\u3002
 
-Then read:
+\u7136\u540E\u9605\u8BFB\uFF1A
 
 - AGENTS.md
 - openspec/config.yaml
 
-Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content. Inspect README files, package scripts, routes, tests, source layout, and existing conventions before writing. Preserve FET managed markers and do not modify business code.
+\u68C0\u67E5 README\u3001package scripts\u3001\u8DEF\u7531\u3001\u6D4B\u8BD5\u3001\u6E90\u7801\u7ED3\u6784\u548C\u73B0\u6709\u7EA6\u5B9A\u540E\uFF0C\u628A AGENTS.md \u4E2D\u6BCF\u4E2A \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u7B80\u6D01\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
 `;
   }
   return `<!-- FET:MANAGED
@@ -2722,15 +3100,15 @@ FET:END -->
 
 ---
 name: fet-${command}
-description: Run FET-managed OpenSpec ${command} workflow from the terminal
+description: ${language === "en" ? `Run FET-managed OpenSpec ${command} workflow from the terminal` : `\u4ECE\u7EC8\u7AEF\u8FD0\u884C FET \u6258\u7BA1\u7684 OpenSpec ${command} \u5DE5\u4F5C\u6D41`}
 disable-model-invocation: true
 ---
 
-${renderIdeModelPolicy(command)}
+${renderIdeModelPolicy(command, language)}
 
-If GitNexus code graph context is available in Cursor, prefer it before broad repository scans. If it is unavailable, continue normally.
+${languageInstruction(language)}
 
-\u6CE8\u610F\uFF1A\u6B64\u6587\u4EF6\u91C7\u7528 Cursor Skill \u76EE\u5F55\u7ED3\u6784\u3002\u5B83\u63D0\u4F9B \`/fet-${command}\` \u98CE\u683C\u7684\u5DE5\u4F5C\u6D41\u8BF4\u660E\uFF0C\u4E0D\u627F\u8BFA\u6CE8\u518C \`/fet ${command}\` \u8FD9\u79CD\u5E26\u7A7A\u683C\u7684\u539F\u751F slash command\u3002
+\u6B64\u6587\u4EF6\u91C7\u7528 Cursor Skill \u76EE\u5F55\u7ED3\u6784\uFF0C\u63D0\u4F9B \`/fet-${command}\` \u98CE\u683C\u7684\u5DE5\u4F5C\u6D41\u8BF4\u660E\uFF0C\u4E0D\u627F\u8BFA\u6CE8\u518C \`/fet ${command}\` \u8FD9\u79CD\u5E26\u7A7A\u683C\u7684\u539F\u751F slash command\u3002
 
 \u8BF7\u5728\u7EC8\u7AEF\u4E2D\u6267\u884C\uFF1A
 
@@ -2738,7 +3116,7 @@ If GitNexus code graph context is available in Cursor, prefer it before broad re
 ${usage}
 \`\`\`
 
-\u6267\u884C\u524D\u8BF7\u786E\u8BA4\u5DF2\u9605\u8BFB AGENTS.md \u4E0E openspec/config.yaml\u3002
+\u6267\u884C\u524D\u8BF7\u786E\u8BA4\u5DF2\u9605\u8BFB AGENTS.md \u548C openspec/config.yaml\u3002
 `;
 }
 
@@ -2752,10 +3130,10 @@ var CursorAdapter = class {
       reason: "Cursor adapter is available for any project"
     };
   }
-  async planInstall(_projectRoot) {
+  async planInstall(_projectRoot, language) {
     return {
       tool: this.tool,
-      files: [...cursorSkillFiles(), cursorRuleFile()].map((file) => ({
+      files: [...cursorSkillFiles(language), cursorRuleFile(language)].map((file) => ({
         ...file,
         managed: true
       }))
@@ -2770,7 +3148,7 @@ var CursorAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
           code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
-          message: "Cursor \u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728\u4E14\u4E0D\u5F52 FET \u7BA1\u7406",
+          message: "Cursor \u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u4E14\u4E0D\u7531 FET \u7BA1\u7406\u3002",
           details: { path: file.path },
           suggestedCommand: "fet init --yes"
         });
@@ -2795,7 +3173,7 @@ var CursorAdapter = class {
       checks.push({
         id: `cursor:${file.path}`,
         status: !content ? "warn" : managed && versionMatches ? "pass" : "warn",
-        message: !content ? `${file.path} \u7F3A\u5931` : !managed ? `${file.path} \u5B58\u5728\u4F46\u4E0D\u5F52 FET \u7BA1\u7406` : !versionMatches ? `${file.path} adapterVersion \u5DF2\u8FC7\u671F` : `${file.path} \u5B58\u5728\u4E14\u7248\u672C\u5339\u914D`,
+        message: !content ? `${file.path} \u7F3A\u5931` : !managed ? `${file.path} \u5DF2\u5B58\u5728\uFF0C\u4F46\u4E0D\u7531 FET \u7BA1\u7406` : !versionMatches ? `${file.path} adapterVersion \u5DF2\u8FC7\u671F` : `${file.path} \u5DF2\u5B58\u5728\u4E14\u7248\u672C\u5339\u914D`,
         suggestedCommand: !content || !managed || !versionMatches ? "fet init" : void 0
       });
     }
@@ -3238,10 +3616,12 @@ var ProjectScanner = class {
 
 // src/cli/output.ts
 var OutputWriter = class {
-  constructor(json) {
+  constructor(json, language = "zh-CN") {
     this.json = json;
+    this.language = language;
   }
   json;
+  language;
   info(message, details) {
     if (!this.json) {
       process.stdout.write(`${message}${formatDetails(details)}
@@ -3254,10 +3634,8 @@ var OutputWriter = class {
 `);
       return;
     }
-    if (!this.json) {
-      process.stderr.write(`\u8B66\u544A\uFF1A${message}${formatDetails(details)}
+    process.stderr.write(`${this.language === "en" ? "Warning" : "\u8B66\u544A"}\uFF1A${message}${formatDetails(details)}
 `);
-    }
   }
   error(error) {
     if (this.json) {
@@ -3265,17 +3643,17 @@ var OutputWriter = class {
 `);
       return;
     }
-    process.stderr.write(`FET \u65E0\u6CD5\u7EE7\u7EED\uFF1A${error.message}
+    process.stderr.write(`${this.language === "en" ? "FET cannot continue" : "FET \u65E0\u6CD5\u7EE7\u7EED"}\uFF1A${error.message}
 `);
     if (error.details !== void 0) {
       process.stderr.write(`
-\u8BE6\u60C5\uFF1A
+${this.language === "en" ? "Details" : "\u8BE6\u60C5"}\uFF1A
 ${formatBlock(error.details)}
 `);
     }
     if (error.suggestedCommand) {
       process.stderr.write(`
-\u5EFA\u8BAE\uFF1A
+${this.language === "en" ? "Suggestion" : "\u5EFA\u8BAE"}\uFF1A
   ${error.suggestedCommand}
 `);
     }
@@ -3289,11 +3667,13 @@ ${formatBlock(error.details)}
     process.stdout.write(`${result.summary}
 `);
     for (const warning of result.warnings ?? []) {
-      process.stdout.write(`\u8B66\u544A\uFF1A${warning}
+      process.stdout.write(`${this.language === "en" ? "Warning" : "\u8B66\u544A"}\uFF1A${warning}
 `);
     }
     if (result.nextSteps?.length) {
-      process.stdout.write("\n\u4E0B\u4E00\u6B65\uFF1A\n");
+      process.stdout.write(`
+${this.language === "en" ? "Next steps" : "\u4E0B\u4E00\u6B65"}\uFF1A
+`);
       for (const step of result.nextSteps) {
         process.stdout.write(`  ${step}
 `);
@@ -3318,7 +3698,10 @@ function formatBlock(details) {
 async function createCommandContext(command, options) {
   const projectRoot = resolve(options.cwd ?? process.cwd());
   const project = await detectProjectIdentity(projectRoot);
-  const output = new OutputWriter(Boolean(options.json));
+  const stateStore = new StateStore(projectRoot, FET_VERSION, project);
+  const savedState = await stateStore.readGlobal();
+  const language = normalizeLanguage(options.lang ?? savedState?.language.current);
+  const output = new OutputWriter(Boolean(options.json), language);
   return {
     command,
     cwd: projectRoot,
@@ -3328,9 +3711,11 @@ async function createCommandContext(command, options) {
     verbose: Boolean(options.verbose),
     yes: Boolean(options.yes),
     changeId: options.change,
+    language,
+    explicitLanguage: options.lang !== void 0,
     fetVersion: FET_VERSION,
     output,
-    stateStore: new StateStore(projectRoot, FET_VERSION, project),
+    stateStore,
     openSpec: new DefaultOpenSpecAdapter(),
     scanner: new ProjectScanner(),
     toolAdapters: [new CursorAdapter(), new CodexAdapter()]
@@ -3339,25 +3724,33 @@ async function createCommandContext(command, options) {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("fet").description("Frontend workflow orchestration tool built around OpenSpec.").enablePositionalOptions().version(FET_VERSION).option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
+program.name("fet").description("\u56F4\u7ED5 OpenSpec \u7684\u524D\u7AEF\u5F00\u53D1\u5DE5\u4F5C\u6D41\u7F16\u6392\u5DE5\u5177\u3002").enablePositionalOptions().version(FET_VERSION).option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--lang <language>", "\u6307\u5B9A FET \u4EA4\u4E92\u4FE1\u606F\u548C\u751F\u6210\u4EA7\u7269\u8BED\u8A00\uFF0C\u9ED8\u8BA4 zh-CN").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
 addGlobalOptions(program.command("init")).description("\u521D\u59CB\u5316 FET + OpenSpec").action(wrap("init", initCommand));
 addGlobalOptions(program.command("update-context")).description("\u66F4\u65B0\u9879\u76EE\u4E0A\u4E0B\u6587").action(wrap("update-context", updateContextCommand));
-addGlobalOptions(program.command("fill-context")).description("Refresh IDE prompts for filling AGENTS.md placeholders").action(wrap("fill-context", fillContextCommand));
-var graph = addGlobalOptions(program.command("graph").description("Manage optional GitNexus code graph support"));
+addGlobalOptions(program.command("fill-context")).description("\u5237\u65B0 IDE \u586B\u5145 AGENTS.md \u5360\u4F4D\u7B26\u7684\u63D0\u793A\u6587\u4EF6").action(wrap("fill-context", fillContextCommand));
+var graph = addGlobalOptions(program.command("graph").description("\u7BA1\u7406\u53EF\u9009\u7684 GitNexus \u4EE3\u7801\u56FE\u652F\u6301"));
 for (const action of ["status", "setup", "doctor", "handoff"]) {
-  addGlobalOptions(graph.command(action).description(`Run fet graph ${action}`)).action(wrap("graph", (ctx) => graphCommand(ctx, action)));
+  addGlobalOptions(graph.command(action).description(`\u8FD0\u884C fet graph ${action}`)).action(wrap("graph", (ctx) => graphCommand(ctx, action)));
 }
 for (const action of ["init", "refresh"]) {
-  addGlobalOptions(graph.command(`${action} [args...]`).description(`Run GitNexus analyze for graph ${action}`).allowUnknownOption(true).passThroughOptions()).action(wrap("graph", (ctx, args = []) => graphCommand(ctx, action, args)));
+  addGlobalOptions(
+    graph.command(`${action} [args...]`).description(`\u901A\u8FC7 GitNexus analyze \u6267\u884C graph ${action}`).allowUnknownOption(true).passThroughOptions()
+  ).action(wrap("graph", (ctx, args = []) => graphCommand(ctx, action, args)));
 }
 addGlobalOptions(program.command("doctor").description("\u8BCA\u65AD\u72B6\u6001\u3001\u914D\u7F6E\u4E0E\u4E00\u81F4\u6027").option("--fix-lock", "\u6E05\u7406 FET \u9501\u6587\u4EF6")).action(
   wrap("doctor", (ctx, options) => doctorCommand(ctx, { fixLock: Boolean(options.fixLock) }))
 );
-addGlobalOptions(program.command("verify").description("\u6700\u7EC8\u8D28\u91CF\u9A8C\u8BC1").option("--done", "\u58F0\u660E\u624B\u52A8\u9A8C\u8BC1\u5DF2\u5B8C\u6210").option("--auto", "\u751F\u6210\u6216\u6267\u884C\u81EA\u52A8\u9A8C\u8BC1\u8BA1\u5212")).action(wrap("verify", verifyCommand));
+addGlobalOptions(program.command("verify").description("\u6700\u7EC8\u8D28\u91CF\u9A8C\u8BC1").option("--done", "\u58F0\u660E\u624B\u52A8\u9A8C\u8BC1\u5DF2\u5B8C\u6210").option("--auto", "\u751F\u6210\u6216\u6267\u884C\u81EA\u52A8\u9A8C\u8BC1\u8BA1\u5212")).action(
+  wrap("verify", verifyCommand)
+);
 for (const command of ["explore", "propose", "new", "continue", "ff", "apply", "sync", "archive", "bulk-archive", "onboard"]) {
-  addGlobalOptions(program.command(`${command} [args...]`).description(`\u4EE3\u7406\u6267\u884C openspec ${command}`).allowUnknownOption(true).passThroughOptions()).action(wrap(command, (ctx, args = []) => proxyCommand(ctx, command, args)));
+  addGlobalOptions(program.command(`${command} [args...]`).description(`\u4EE3\u7406\u6267\u884C openspec ${command}`).allowUnknownOption(true).passThroughOptions()).action(
+    wrap(command, (ctx, args = []) => proxyCommand(ctx, command, args))
+  );
 }
-addGlobalOptions(program.command("passthrough <command> [args...]").description("\u900F\u4F20\u6682\u672A\u63A5\u7BA1\u7684 OpenSpec \u547D\u4EE4").allowUnknownOption(true).passThroughOptions()).action(wrap("passthrough", (ctx, command, args = []) => passthroughCommand(ctx, command, args)));
+addGlobalOptions(program.command("passthrough <command> [args...]").description("\u900F\u4F20\u6682\u672A\u63A5\u7BA1\u7684 OpenSpec \u547D\u4EE4").allowUnknownOption(true).passThroughOptions()).action(
+  wrap("passthrough", (ctx, command, args = []) => passthroughCommand(ctx, command, args))
+);
 program.parseAsync(process.argv).catch((error) => {
   const json = process.argv.includes("--json");
   const output = new OutputWriter(json);
@@ -3371,7 +3764,7 @@ function wrap(command, handler) {
     const opts = isCommandLike(maybeCommand) ? { ...maybeCommand.parent?.opts(), ...maybeCommand.opts() } : program.opts();
     const ctx = await createCommandContext(command, { ...opts, ...extractGlobalOptions(args) });
     try {
-      await confirmModelPolicyRecommendation(ctx);
+      await handleModelPolicyRecommendation(ctx);
       await warnIfContextPlaceholdersRemain(ctx);
       await handler(ctx, ...args);
     } catch (error) {
@@ -3381,45 +3774,53 @@ function wrap(command, handler) {
     }
   };
 }
-async function confirmModelPolicyRecommendation(ctx) {
+async function handleModelPolicyRecommendation(ctx) {
   const mismatch = getCommandModelPolicyMismatch(ctx.command);
   if (!mismatch) {
     return;
   }
-  const warning = formatModelPolicyMismatch(mismatch);
-  ctx.output.warn(`${warning} You can stop now to switch models, or continue this command.`);
-  if (ctx.yes || ctx.json || !process.stdin.isTTY || !process.stderr.isTTY) {
+  const warning = formatModelPolicyMismatch(mismatch, ctx.language);
+  const policyMode = getModelPolicyMode();
+  ctx.output.warn(`${warning} ${renderModelPolicyActionHint(policyMode, ctx.language)}`);
+  if (policyMode !== "confirm" || ctx.yes || ctx.json || !process.stdin.isTTY || !process.stderr.isTTY) {
     return;
   }
   const rl = createInterface({ input: process.stdin, output: process.stderr });
   try {
-    const answer = (await rl.question("Continue anyway? [y/N] ")).trim().toLowerCase();
+    const question = ctx.language === "en" ? "Continue anyway? [y/N] " : "\u4ECD\u7136\u7EE7\u7EED\uFF1F[y/N] ";
+    const answer = (await rl.question(question)).trim().toLowerCase();
     if (answer !== "y" && answer !== "yes") {
       throw new FetError({
         code: "USER_CANCELLED" /* UserCancelled */,
-        message: "Command cancelled so you can switch IDE model.",
+        message: ctx.language === "en" ? "Command cancelled so you can switch IDE model." : "\u547D\u4EE4\u5DF2\u53D6\u6D88\uFF0C\u4F60\u53EF\u4EE5\u5148\u5207\u6362 IDE \u6A21\u578B\u3002",
         details: { command: ctx.command, detected: mismatch.detected, recommended: mismatch.recommended },
-        suggestedCommand: `Switch IDE model, then rerun fet ${ctx.command}.`
+        suggestedCommand: ctx.language === "en" ? `Switch IDE model, then rerun fet ${ctx.command}.` : `\u5207\u6362 IDE \u6A21\u578B\u540E\u91CD\u65B0\u8FD0\u884C fet ${ctx.command}\u3002`
       });
     }
   } finally {
     rl.close();
   }
 }
+function renderModelPolicyActionHint(policyMode, language) {
+  if (policyMode === "confirm") {
+    return language === "en" ? "Choose whether to continue this command or stop and switch models." : "\u8BF7\u9009\u62E9\u7EE7\u7EED\u6267\u884C\u672C\u547D\u4EE4\uFF0C\u6216\u505C\u6B62\u540E\u624B\u52A8\u5207\u6362\u6A21\u578B\u3002";
+  }
+  return language === "en" ? "This is advisory; the command will continue. Set FET_MODEL_POLICY=confirm if you want an explicit stop/continue prompt." : "\u8BE5\u63D0\u9192\u4EC5\u4F5C\u4E3A\u5EFA\u8BAE\uFF0C\u547D\u4EE4\u4F1A\u7EE7\u7EED\u6267\u884C\u3002\u5982\u9700\u663E\u5F0F\u9009\u62E9\u505C\u6B62\u6216\u7EE7\u7EED\uFF0C\u53EF\u8BBE\u7F6E FET_MODEL_POLICY=confirm\u3002";
+}
 async function warnIfContextPlaceholdersRemain(ctx) {
   if (["init", "update-context", "fill-context", "doctor"].includes(ctx.command)) {
     return;
   }
   const count2 = await countAgentsLlmPlaceholders(ctx.projectRoot);
   if (count2 > 0) {
-    ctx.output.warn(renderAgentsPlaceholderWarning(count2));
+    ctx.output.warn(renderAgentsPlaceholderWarning(count2, ctx.language));
   }
 }
 function isCommandLike(value) {
   return value instanceof Command;
 }
 function addGlobalOptions(command) {
-  return command.option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
+  return command.option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--lang <language>", "\u6307\u5B9A FET \u4EA4\u4E92\u4FE1\u606F\u548C\u751F\u6210\u4EA7\u7269\u8BED\u8A00\uFF0C\u9ED8\u8BA4 zh-CN").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
 }
 function extractGlobalOptions(args) {
   const values = args.flatMap((arg) => Array.isArray(arg) ? arg : []);
@@ -3439,6 +3840,11 @@ function extractGlobalOptions(args) {
       index += 1;
     } else if (value.startsWith("--change=")) {
       options.change = value.slice("--change=".length);
+    } else if (value === "--lang" && typeof values[index + 1] === "string") {
+      options.lang = values[index + 1];
+      index += 1;
+    } else if (value.startsWith("--lang=")) {
+      options.lang = value.slice("--lang=".length);
     } else if (value === "--yes") {
       options.yes = true;
     } else if (value === "--json") {