@nick848/fet 1.0.5 → 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,836 +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]
-
-## Routes
+// 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 -->
 
-| Route | Source | Confidence |
-|-------|--------|------------|
-${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
+# FET Fill Context
 
-## Conventions
+Use the IDE AI to complete FET-generated placeholders.
 
-[NEEDS LLM INPUT]
+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 -->
 
-## Scanner Metadata
+# FET \u586B\u5145\u4E0A\u4E0B\u6587
 
-- Generated At: ${scan.generatedAt}
-- FET Version: ${FET_VERSION}
-- Scanner Version: ${scan.scannerVersion}
-- Warnings: ${scan.warnings.length ? scan.warnings.join("; ") : "none"}
-${AUTO_END}
+\u4F7F\u7528 IDE AI \u8865\u9F50 FET \u751F\u6210\u7684\u9879\u76EE\u4E0A\u4E0B\u6587\u5360\u4F4D\u7B26\u3002
 
-${USER_BEGIN}
-## Notes For AI
+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
+`;
+}
 
-[NEEDS LLM INPUT]
-${USER_END}
-`;
+// 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;
+  }
 }
-
-// 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
+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()
       }
     }
   });
 }
-
-// src/templates/verify-instructions.ts
-function renderVerifyInstructions(changeId, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  return `---
+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
-fetVersion: ${FET_VERSION}
-generatedAt: ${generatedAt}
-changeId: ${changeId}
-purpose: manual-verify
----
+generator: graph-setup
+FET:END -->
 
-# Verify Instructions
+# FET Graph Setup
 
-\u8BF7\u6309\u987A\u5E8F\u5B8C\u6210\u4EE5\u4E0B\u68C0\u67E5\uFF1A
+GitNexus graph support is optional. FET does not install GitNexus automatically and does not require graph support for OpenSpec workflows.
 
-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
+Current status:
 
-\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+- Installed: ${state.installed ? "yes" : "no"}
+- Executable: ${state.executablePath ?? "gitnexus"}
+- Version: ${state.version ?? "unknown"}
+- Graph path: ${state.graphPath ?? ".gitnexus"}
+- Graph exists: ${state.graphExists ? "yes" : "no"}
 
-\`\`\`sh
-fet verify --done --change ${changeId}
-\`\`\`
-`;
-}
+Suggested setup flow:
 
-// src/templates/gitignore.ts
-var BEGIN = "# FET:BEGIN LOCAL STATE";
-var END = "# 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 = `${BEGIN}
-${RULES.join("\n")}
-${END}`;
-  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)}`;
-  }
-  return `${existing.replace(/\s*$/, "")}
+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.
 
-${block}
+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/commands/update-context.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join7 } from "path";
+# FET Graph Handoff
 
-// 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();
-}
+Use GitNexus graph context as an optional first pass before broad repository scans.
 
-// 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;
-  }
+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 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.`;
+function firstLine(value) {
+  return value.trim().split(/\r?\n/)[0]?.trim() || null;
 }
 
-// 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 existingAgents = await readOptional(agentsPath);
-  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"
-      });
+// 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}`);
     }
-    const backupPath = await createBackup(agentsPath);
-    if (backupPath) {
-      warnings.push(`\u5DF2\u5907\u4EFD\u975E\u6258\u7BA1 AGENTS.md \u5230 ${backupPath}`);
+    if (currentDir === root) {
+      throw new Error("\u65E0\u6CD5\u5B9A\u4F4D FET package.json");
     }
-  }
-  await atomicWrite(agentsPath, replaceManagedRegion(existingAgents, renderAgentsMd(scan)));
-  await atomicWrite(configPath, await mergeFetConfig(configPath, renderFetConfig(scan)));
-  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;
+    currentDir = dirname6(currentDir);
   }
 }
 
-// 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" })));
-      }
-      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"]
-  });
+// 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);
 }
-async function ensureGitignore(ctx) {
-  const gitignorePath = join8(ctx.projectRoot, ".gitignore");
-  const existing = await readOptional2(gitignorePath);
-  await atomicWrite(gitignorePath, mergeGitignore(existing));
+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);
 }
-async function readOptional2(path) {
-  try {
-    return await readFile6(path, "utf8");
-  } catch {
-    return null;
+function replaceManagedRegion(existing, generated) {
+  if (!existing) {
+    return generated;
   }
-}
-async function exists(path) {
-  try {
-    await stat3(path);
-    return true;
-  } catch {
-    return false;
+  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}`;
 }
-
-// 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));
+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;
   }
-  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" });
+  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();
     }
-  }
-  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
-  });
+    return section.raw.trim();
+  }).join("\n\n");
 }
-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);
-  }
-  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 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;
 }
-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 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 };
+  });
 }
-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 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 content.slice(start + AUTO_BEGIN.length, end).trim();
 }
-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 count(content, needle) {
+  return content.split(needle).length - 1;
 }
-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" };
+
+// src/templates/agents-md.ts
+function renderAgentsMd(scan, language = "zh-CN") {
+  if (language === "en") {
+    return renderAgentsMdEn(scan);
   }
+  return renderAgentsMdZh(scan);
 }
-async function exists2(path) {
-  try {
-    await stat4(path);
-    return true;
-  } catch {
-    return false;
-  }
+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
+
+${AUTO_BEGIN}
+## \u9879\u76EE\u5FEB\u7167
+
+- \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"}
+
+## \u5DE5\u4F5C\u533A
+
+| \u540D\u79F0 | \u8DEF\u5F84 | \u6765\u6E90 |
+|------|------|--------|
+${workspaces || "| root | . | inferred |"}
+
+## \u547D\u4EE4
+
+| \u540D\u79F0 | \u547D\u4EE4 | \u6765\u6E90 |
+|------|---------|--------|
+${commands || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
+
+## \u7ED3\u6784
+
+[NEEDS LLM INPUT]
+
+## \u8DEF\u7531
+
+| \u8DEF\u7531 | \u6765\u6E90 | \u7F6E\u4FE1\u5EA6 |
+|-------|--------|------------|
+${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
+
+## \u7EA6\u5B9A
+
+[NEEDS LLM INPUT]
+
+## AI \u5DE5\u4F5C\u6307\u5357
+
+- \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
+
+## \u626B\u63CF\u5143\u6570\u636E
+
+- \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}
+
+${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/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 });
-        }
+${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]
+
+## 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/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
       }
     }
-  );
-  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"
-    }
   });
 }
-function renderGenericHandoff() {
+
+// 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)}`;
+  }
+  return `${existing.replace(/\s*$/, "")}
+
+${block}
+`;
+}
+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)}
+`;
+}
+function renderKarpathyFetHandoff(language = "zh-CN") {
   return `<!-- FET:MANAGED
 schemaVersion: 1
-generator: fill-context
+generator: karpathy-skills
 FET:END -->
 
-# FET Fill Context
-
-Use the IDE AI to complete FET-generated placeholders.
+# ${language === "en" ? "Andrej Karpathy Inspired Coding Guidelines" : "\u53D7 Andrej Karpathy \u542F\u53D1\u7684\u7F16\u7801\u6307\u5357"}
 
-1. Read AGENTS.md and openspec/config.yaml.
-2. Inspect README files, package scripts, routes, tests, source layout, and project conventions.
-3. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content.
-4. Preserve FET managed markers.
-5. Do not modify business code.
-6. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
+${renderKarpathyGuidelinesBody(language)}
 `;
 }
-
-// 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;
-  }
-}
-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
-    }
-  });
-}
-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);
-  });
-  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
-    }
-  });
+function renderManagedBlock(content) {
+  return `${BEGIN}
+${content}
+${END}`;
 }
-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()
-      }
-    }
-  });
+function renderKarpathyClaudeGuidelines() {
+  return `# Andrej Karpathy Inspired Coding Guidelines
+
+${renderKarpathyGuidelinesBody()}`;
 }
-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);
+function renderKarpathyGuidelinesBody(language = "zh-CN") {
+  if (language === "en") {
+    return renderKarpathyGuidelinesBodyEn();
   }
-  return {
-    state,
-    gitnexusStatus: gitnexusStatus ? {
-      exitCode: gitnexusStatus.exitCode,
-      command: gitnexusStatus.command,
-      stdout: gitnexusStatus.stdout.trim(),
-      stderr: gitnexusStatus.stderr.trim()
-    } : null
-  };
+  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`;
 }
-async function writeHandoffFile(path, content) {
-  await mkdir4(dirname6(path), { recursive: true });
-  await atomicWrite(path, content);
+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
+
+- 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 renderGraphSetupHandoff(state) {
-  return `<!-- FET:MANAGED
-schemaVersion: 1
-generator: graph-setup
-FET:END -->
 
-# FET Graph Setup
+// 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
+---
 
-GitNexus graph support is optional. FET does not install GitNexus automatically and does not require graph support for OpenSpec workflows.
+# Verify Instructions
 
-Current status:
+\u8BF7\u6309\u987A\u5E8F\u5B8C\u6210\u4EE5\u4E0B\u68C0\u67E5\uFF1A
 
-- Installed: ${state.installed ? "yes" : "no"}
-- Executable: ${state.executablePath ?? "gitnexus"}
-- Version: ${state.version ?? "unknown"}
-- Graph path: ${state.graphPath ?? ".gitnexus"}
-- Graph exists: ${state.graphExists ? "yes" : "no"}
+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
 
-Suggested setup flow:
+\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
 
-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.
+\`\`\`sh
+fet verify --done --change ${changeId}
+\`\`\`
+`;
+}
 
-Guardrails:
+// 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*$/, "")}
 
-- 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.
+${block}
 `;
 }
-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:
+// src/commands/update-context.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join10 } from "path";
 
-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.
+// 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();
+}
 
-When producing OpenSpec artifacts:
+// 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: 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 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}`);
+    }
+  }
+  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"
+    );
+  }
+  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 readOptional(path) {
+  try {
+    return await readFile6(path, "utf8");
+  } catch {
+    return null;
+  }
+}
 
-- 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.
-`;
+// 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 firstLine(value) {
-  return value.trim().split(/\r?\n/)[0]?.trim() || null;
+async function ensureGitignore(ctx) {
+  const gitignorePath = join11(ctx.projectRoot, ".gitignore");
+  const existing = await readOptional2(gitignorePath);
+  await atomicWrite(gitignorePath, mergeGitignore(existing));
+}
+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
@@ -1096,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) {
@@ -1106,6 +1389,10 @@ function createGlobalState(fetVersion, project) {
     createdAt: now,
     updatedAt: now,
     project,
+    language: {
+      current: DEFAULT_LANGUAGE,
+      updatedAt: now
+    },
     openspec: null,
     activeChangeId: null,
     openChangeIds: [],
@@ -1129,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: [],
@@ -1146,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");
   }
@@ -1427,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":
@@ -1458,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;
@@ -1703,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);
@@ -1733,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
@@ -1780,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
@@ -1792,10 +2118,15 @@ FET:END -->
 
 # FET For Codex
 
+## \u8BED\u8A00
+
+${languageInstruction(language)}
+
 Before doing FET or OpenSpec work in Codex, read:
 
 - AGENTS.md
 - openspec/config.yaml
+- .codex/fet/karpathy-guidelines.md
 - the active change files under openspec/changes/<change-id>/, when a change is selected
 
 If GitNexus code graph context is available in the IDE or MCP tools, prefer it before broad repository scans. Use it to identify relevant modules, dependencies, and insertion points, then read only the concrete source files needed. If GitNexus is unavailable, continue with the normal FET/OpenSpec workflow.
@@ -1806,27 +2137,49 @@ Command guides live in .codex/fet/commands/.
 `
   };
 }
-function codexCommandFiles() {
-  return FET_ADAPTER_COMMANDS.map((command) => ({
-    path: `.codex/fet/commands/${command}.md`,
-    content: renderCommand(command)
-  }));
+function codexCommandFiles(language = DEFAULT_LANGUAGE) {
+  return [
+    codexKarpathyGuidelinesFile(language),
+    ...FET_ADAPTER_COMMANDS.map((command) => ({
+      path: `.codex/fet/commands/${command}.md`,
+      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 renderCommand(command) {
+function codexKarpathyGuidelinesFile(language) {
+  return {
+    path: ".codex/fet/karpathy-guidelines.md",
+    content: `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+FET:END -->
+
+# Andrej Karpathy Inspired Coding Guidelines
+
+${renderKarpathyGuidelinesBody(language)}
+`
+  };
+}
+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
@@ -1839,10 +2192,14 @@ 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.
 
+Also read .codex/fet/karpathy-guidelines.md and follow it unless it conflicts with the user's latest request or OpenSpec artifacts.
+
 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.
 
 Then run:
@@ -1856,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}
@@ -1867,10 +2258,14 @@ 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.
 
+Also read .codex/fet/karpathy-guidelines.md and follow it unless it conflicts with the user's latest request or OpenSpec artifacts.
+
 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.
 
 Then run:
@@ -1882,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
@@ -1895,10 +2290,14 @@ 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.
 
+Also read .codex/fet/karpathy-guidelines.md and follow it unless it conflicts with the user's latest request or OpenSpec artifacts.
+
 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.
 
 Run:
@@ -1912,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-");
@@ -1963,13 +2365,14 @@ FET:END -->
 
 ---
 description: ${description}
-argument-hint: command arguments
 ---
 
 Use FET as the entry point for this OpenSpec workflow.
 
 Before running the command, make sure the relevant project context is loaded from AGENTS.md and openspec/config.yaml. If a change id is needed and was not provided, infer it from the active FET/OpenSpec state when unambiguous; otherwise ask the user for the change id.
 
+Also read .codex/fet/karpathy-guidelines.md and follow it unless it conflicts with the user's latest request or OpenSpec artifacts.
+
 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.
 
 Run:
@@ -1981,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}
@@ -1992,10 +2477,14 @@ 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.
 
+Also read .codex/fet/karpathy-guidelines.md and follow it unless it conflicts with the user's latest request or OpenSpec artifacts.
+
 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.
 
 First run:
@@ -2007,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",
@@ -2020,16 +2509,17 @@ Steps:
    fet fill-context
    \`\`\`
 2. Read AGENTS.md and openspec/config.yaml.
-3. Inspect the project to understand:
+3. Read .codex/fet/karpathy-guidelines.md.
+4. Inspect the project to understand:
    - source structure and major modules
    - framework and routing conventions
    - scripts, test commands, and build commands
    - coding conventions and project-specific patterns
    - important docs such as README files
-4. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete, concise project-specific content.
-5. Preserve FET managed markers such as \`FET:BEGIN AUTO\`, \`FET:END AUTO\`, \`FET:BEGIN USER\`, and \`FET:END USER\`.
-6. Do not modify business code.
-7. Run:
+5. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete, concise project-specific content.
+6. Preserve FET managed markers such as \`FET:BEGIN AUTO\`, \`FET:END AUTO\`, \`FET:BEGIN USER\`, and \`FET:END USER\`.
+7. Do not modify business code.
+8. Run:
    \`\`\`sh
    fet doctor
    \`\`\`
@@ -2038,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",
@@ -2070,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
@@ -2100,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>
@@ -2133,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:
@@ -2165,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
@@ -2195,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",
@@ -2222,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",
@@ -2236,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.
@@ -2246,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",
@@ -2267,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",
@@ -2302,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
@@ -2324,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.
@@ -2342,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(
@@ -2353,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:
 
@@ -2376,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}
@@ -2391,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.
 
@@ -2412,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"
@@ -2508,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
@@ -2525,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
@@ -2553,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
@@ -2581,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
 
@@ -2597,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
 `;
 }
 
@@ -2611,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
       }))
@@ -2629,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"
         });
@@ -2654,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
       });
     }
@@ -3097,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)}
@@ -3113,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) {
@@ -3124,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}
 `);
     }
@@ -3148,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}
 `);
@@ -3177,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,
@@ -3187,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()]
@@ -3198,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);
@@ -3230,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) {
@@ -3240,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 : []);
@@ -3298,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") {