@nick848/fet 1.0.3 → 1.0.4

package/dist/cli/index.js

@@ -5,11 +5,12 @@ import {
 } from "../chunk-FZOVNHE7.js";
 
 // src/cli/index.ts
+import { createInterface } from "readline/promises";
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { readFile as readFile5, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/fs/atomic-write.ts
 import { dirname } from "path";
@@ -115,6 +116,48 @@ async function writeInitJournal(projectRoot, journal) {
   );
 }
 
+// src/gitnexus.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function detectGitNexus(env = process.env) {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const executable = env.FET_GITNEXUS_EXECUTABLE?.trim() || "gitnexus";
+  try {
+    const { stdout, stderr } = await execFileAsync(executable, ["--version"], { shell: process.platform === "win32" });
+    return {
+      installed: true,
+      executablePath: executable,
+      version: (stdout.trim() || stderr.trim() || "unknown").split(/\r?\n/)[0] ?? "unknown",
+      checkedAt
+    };
+  } catch (error) {
+    return {
+      installed: false,
+      executablePath: executable,
+      version: null,
+      checkedAt,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function toGitNexusState(detection, previous) {
+  return {
+    provider: "gitnexus",
+    installed: detection.installed,
+    executablePath: detection.installed ? detection.executablePath : null,
+    version: detection.version,
+    checkedAt: detection.checkedAt,
+    recommendationShownAt: previous?.recommendationShownAt ?? null
+  };
+}
+function renderGitNexusRecommendation(state) {
+  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.";
+}
+
 // src/version.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname as dirname4, join as join4, parse } from "path";
@@ -144,6 +187,7 @@ 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);
 }
@@ -163,11 +207,41 @@ function replaceManagedRegion(existing, 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}
-${generatedAuto}
+${mergeAutoRegion(existingAuto, generatedAuto)}
 ${AUTO_END}${after}`;
 }
+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;
+  }
+  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 [];
+  }
+  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);
@@ -325,8 +399,8 @@ ${block}
 }
 
 // src/commands/update-context.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/config/yaml.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -345,23 +419,43 @@ async function mergeFetConfig(configPath, renderedFetYaml) {
   return doc.toString();
 }
 
+// src/context-placeholders.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var AGENTS_LLM_PLACEHOLDER_PATTERN = /\[NEEDS? LLM INPUT\]/g;
+async function countAgentsLlmPlaceholders(projectRoot) {
+  try {
+    const content = await readFile4(join5(projectRoot, "AGENTS.md"), "utf8");
+    return [...content.matchAll(AGENTS_LLM_PLACEHOLDER_PATTERN)].length;
+  } catch {
+    return 0;
+  }
+}
+function renderAgentsPlaceholderWarning(count2) {
+  return `AGENTS.md still contains ${count2} LLM placeholder(s). Run fet fill-context first so your IDE AI can replace them. Continuing current command.`;
+}
+
 // 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 () => updateContextFiles(ctx)
+    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"
+    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 = join5(ctx.projectRoot, "AGENTS.md");
-  const configPath = join5(ctx.projectRoot, "openspec", "config.yaml");
+  const agentsPath = join6(ctx.projectRoot, "AGENTS.md");
+  const configPath = join6(ctx.projectRoot, "openspec", "config.yaml");
   const existingAgents = await readOptional(agentsPath);
   const warnings = [...scan.warnings];
   if (existingAgents && hasInvalidManagedAutoRegion(existingAgents)) {
@@ -388,6 +482,10 @@ async function updateContextFiles(ctx) {
   }
   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,
@@ -399,7 +497,7 @@ async function updateContextFiles(ctx) {
 }
 async function readOptional(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch {
     return null;
   }
@@ -407,7 +505,8 @@ async function readOptional(path) {
 
 // src/commands/init.ts
 async function initCommand(ctx) {
-  const alreadyInitialized = await exists(join6(ctx.projectRoot, "openspec", "config.yaml"));
+  const alreadyInitialized = await exists(join7(ctx.projectRoot, "openspec", "config.yaml"));
+  let warnings = [];
   await withProjectLock(
     ctx.projectRoot,
     { command: "init", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
@@ -423,9 +522,17 @@ async function initCommand(ctx) {
         }
       }
       const contextResult = await updateContextFiles(ctx);
+      warnings = contextResult.warnings;
       await ensureGitignore(ctx);
       const state = await ctx.stateStore.getOrCreateGlobal();
       state.openspec = identity;
+      state.graph ??= {};
+      const gitnexus = toGitNexusState(await detectGitNexus(), state.graph.gitnexus);
+      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);
@@ -439,26 +546,24 @@ async function initCommand(ctx) {
       journal.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       await writeInitJournal(ctx.projectRoot, journal);
       await ctx.stateStore.writeGlobal(state);
-      for (const warning of contextResult.warnings) {
-        ctx.output.warn(warning);
-      }
     }
   );
   ctx.output.result({
     ok: true,
     command: "init",
     summary: "FET \u521D\u59CB\u5316\u5B8C\u6210\u3002",
+    warnings,
     nextSteps: ["\u4F7F\u7528 fet propose/new \u521B\u5EFA OpenSpec change", "\u4F7F\u7528 fet doctor \u68C0\u67E5\u9879\u76EE\u72B6\u6001"]
   });
 }
 async function ensureGitignore(ctx) {
-  const gitignorePath = join6(ctx.projectRoot, ".gitignore");
+  const gitignorePath = join7(ctx.projectRoot, ".gitignore");
   const existing = await readOptional2(gitignorePath);
   await atomicWrite(gitignorePath, mergeGitignore(existing));
 }
 async function readOptional2(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch {
     return null;
   }
@@ -473,19 +578,20 @@ async function exists(path) {
 }
 
 // src/commands/doctor.ts
-import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile7, stat as stat3 } from "fs/promises";
+import { join as join8 } from "path";
 async function doctorCommand(ctx, options = {}) {
   const checks = [];
   checks.push(await checkOpenSpec(ctx));
   checks.push(await checkState(ctx));
-  checks.push(await checkFile("agents", join7(ctx.projectRoot, "AGENTS.md"), "AGENTS.md \u7F3A\u5931", "fet update-context"));
-  checks.push(await checkFile("config", join7(ctx.projectRoot, "openspec", "config.yaml"), "openspec/config.yaml \u7F3A\u5931", "fet init"));
-  checks.push(await checkPlaceholders(join7(ctx.projectRoot, "AGENTS.md")));
+  checks.push(await checkFile("agents", join8(ctx.projectRoot, "AGENTS.md"), "AGENTS.md \u7F3A\u5931", "fet update-context"));
+  checks.push(await checkFile("config", join8(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 = join7(ctx.projectRoot, "openspec", ".fet.lock");
+  const lockPath = join8(ctx.projectRoot, "openspec", ".fet.lock");
   if (await exists2(lockPath)) {
     if (options.fixLock) {
       await clearLock(ctx.projectRoot);
@@ -503,6 +609,25 @@ async function doctorCommand(ctx, options = {}) {
     data: checks
   });
 }
+async function checkGitNexus(ctx) {
+  const global = await ctx.stateStore.readGlobal();
+  const state = toGitNexusState(await detectGitNexus(), global?.graph?.gitnexus);
+  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"})`
+  } : {
+    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"
+  };
+}
 async function checkOpenSpec(ctx) {
   try {
     const identity = await ctx.openSpec.resolveExecutable();
@@ -522,10 +647,10 @@ async function checkState(ctx) {
 async function checkFile(id, path, missing, suggestedCommand) {
   return await exists2(path) ? { id, status: "pass", message: `${id} \u5B58\u5728` } : { id, status: "warn", message: missing, suggestedCommand };
 }
-async function checkPlaceholders(path) {
+async function checkPlaceholders(projectRoot) {
   try {
-    const content = await readFile6(path, "utf8");
-    const count2 = [...content.matchAll(/\[NEEDS? LLM INPUT\]/g)].length;
+    await readFile7(join8(projectRoot, "AGENTS.md"), "utf8");
+    const count2 = await countAgentsLlmPlaceholders(projectRoot);
     return count2 ? {
       id: "context-placeholders",
       status: "warn",
@@ -546,15 +671,14 @@ async function exists2(path) {
 }
 
 // src/commands/fill-context.ts
-import { mkdir as mkdir3, readFile as readFile7 } from "fs/promises";
-import { dirname as dirname5, join as join8 } from "path";
-var placeholderPattern = /\[NEEDS? LLM INPUT\]/g;
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname5, join as join9 } from "path";
 async function fillContextCommand(ctx) {
   await withProjectLock(
     ctx.projectRoot,
     { command: "fill-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
     async () => {
-      const handoffPath = join8(ctx.projectRoot, ".fet", "fill-context.md");
+      const handoffPath = join9(ctx.projectRoot, ".fet", "fill-context.md");
       await mkdir3(dirname5(handoffPath), { recursive: true });
       await atomicWrite(handoffPath, renderGenericHandoff());
       for (const adapter of ctx.toolAdapters) {
@@ -573,7 +697,7 @@ async function fillContextCommand(ctx) {
       }
     }
   );
-  const placeholders = await countPlaceholders(join8(ctx.projectRoot, "AGENTS.md"));
+  const placeholders = await countAgentsLlmPlaceholders(ctx.projectRoot);
   ctx.output.result({
     ok: true,
     command: "fill-context",
@@ -608,23 +732,15 @@ Use the IDE AI to complete FET-generated placeholders.
 6. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
 `;
 }
-async function countPlaceholders(path) {
-  try {
-    const content = await readFile7(path, "utf8");
-    return [...content.matchAll(placeholderPattern)].length;
-  } catch {
-    return 0;
-  }
-}
 
 // src/commands/proxy.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/state/project.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
 async function detectProjectIdentity(projectRoot) {
   const [gitRoot, branch, headCommit] = await Promise.all([
     git(projectRoot, ["rev-parse", "--show-toplevel"]),
@@ -640,7 +756,7 @@ async function detectProjectIdentity(projectRoot) {
 }
 async function git(cwd, args) {
   try {
-    const { stdout } = await execFileAsync("git", args, { cwd });
+    const { stdout } = await execFileAsync2("git", args, { cwd });
     return stdout.trim() || null;
   } catch {
     return null;
@@ -649,7 +765,7 @@ async function git(cwd, args) {
 
 // src/state/store.ts
 import { mkdir as mkdir4, readFile as readFile8 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/state/schema.ts
 var phases = ["explore", "propose", "implement", "verify", "sync", "archive"];
@@ -670,6 +786,7 @@ function createGlobalState(fetVersion, project) {
       scannerVersion: 1
     },
     toolAdapters: {},
+    graph: {},
     verifyAuthorization: null,
     lastDoctor: null
   };
@@ -757,7 +874,7 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir4(join9(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir4(join10(this.projectRoot, "openspec"), { recursive: true });
     await atomicWrite(this.globalPath(), `${JSON.stringify(state, null, 2)}
 `);
   }
@@ -778,15 +895,15 @@ var StateStore = class {
   }
   async writeChange(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir4(join9(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
+    await mkdir4(join10(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
     await atomicWrite(this.changePath(state.changeId), `${JSON.stringify(state, null, 2)}
 `);
   }
   globalPath() {
-    return join9(this.projectRoot, "openspec", "fet-state.json");
+    return join10(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join9(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join10(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -903,7 +1020,7 @@ async function createChangelogEntry(projectRoot, changeId) {
   };
 }
 async function appendChangelog(projectRoot, entry) {
-  const changelogPath = join10(projectRoot, "CHANGELOG.md");
+  const changelogPath = join11(projectRoot, "CHANGELOG.md");
   const existing = await readOptional3(changelogPath);
   const block = `updateTime: ${entry.updateTime}
 \u66F4\u65B0\u5185\u5BB9:${entry.content}
@@ -914,12 +1031,12 @@ ${block}` : block;
   await atomicWrite(changelogPath, next);
 }
 async function readChangeRequirement(projectRoot, changeId) {
-  const changeRoot = join10(projectRoot, "openspec", "changes", changeId);
-  const proposal = await readOptional3(join10(changeRoot, "proposal.md"));
+  const changeRoot = join11(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional3(join11(changeRoot, "proposal.md"));
   if (proposal) {
     return summarizeMarkdown(proposal);
   }
-  const readme = await readOptional3(join10(changeRoot, "README.md"));
+  const readme = await readOptional3(join11(changeRoot, "README.md"));
   if (readme) {
     return summarizeMarkdown(readme);
   }
@@ -1064,7 +1181,7 @@ async function assertVerified(ctx) {
 // src/commands/verify.ts
 import { createHash } from "crypto";
 import { mkdir as mkdir5, readFile as readFile11, stat as stat4 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -1131,8 +1248,8 @@ async function verifyCommand(ctx, options) {
 async function writeInstructions(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join11(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
-  const instructionsPath = join11(dir, "verify-instructions.md");
+  const dir = join12(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join12(dir, "verify-instructions.md");
   await mkdir5(dir, { recursive: true });
   await atomicWrite(instructionsPath, renderVerifyInstructions(changeId, generatedAt));
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -1149,7 +1266,7 @@ async function writeInstructions(ctx, changeId) {
 async function markDone(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
   const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
-  const instructionsPath = join11(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
+  const instructionsPath = join12(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
   const instructions = await readInstructions(instructionsPath, changeId);
   const instructionsGeneratedAt = readFrontMatterValue(instructions, "generatedAt") ?? declaredAt;
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -1235,13 +1352,76 @@ async function resolveChangeId(ctx) {
   });
 }
 
+// src/model-policy.ts
+var HIGH_COST_MODEL_PATTERNS = [
+  /gpt[-_ ]?5\.5/i,
+  /glm[-_ ]?5(?:\.1)?/i,
+  /claude.*opus/i,
+  /opus/i,
+  /claude.*sonnet/i,
+  /sonnet/i
+];
+var MODEL_ENV_KEYS = ["FET_IDE_MODEL", "FET_MODEL", "CODEX_MODEL", "CURSOR_MODEL", "OPENCODE_MODEL", "OPENAI_MODEL", "ANTHROPIC_MODEL"];
+function detectCurrentModel(env = process.env) {
+  for (const key of MODEL_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (value) {
+      return { source: key, name: value };
+    }
+  }
+  return null;
+}
+function isHighCostModel(model) {
+  return HIGH_COST_MODEL_PATTERNS.some((pattern) => pattern.test(model));
+}
+function getCommandModelPolicyMismatch(command, env = process.env) {
+  if (env.FET_MODEL_POLICY === "off" || env.FET_SKIP_MODEL_POLICY === "1") {
+    return null;
+  }
+  const detected = detectCurrentModel(env);
+  if (!detected) {
+    return null;
+  }
+  const highCost = isHighCostModel(detected.name);
+  if (command === "apply") {
+    if (!highCost) {
+      return {
+        command,
+        detected,
+        recommended: "high-cost",
+        reason: "fet apply is the implementation phase and is recommended to use a high-capability/high-cost model."
+      };
+    }
+    return null;
+  }
+  if (highCost) {
+    return {
+      command,
+      detected,
+      recommended: "low-cost",
+      reason: `fet ${command} is not the implementation phase and is recommended to use a lower-cost model.`
+    };
+  }
+  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 renderIdeModelPolicy(command) {
+  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 "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.";
+}
+
 // src/cli/context.ts
 import { resolve } from "path";
 
 // src/adapters/codex/index.ts
 import { mkdir as mkdir6, readFile as readFile12, stat as stat5 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname6, join as join12 } from "path";
+import { dirname as dirname6, join as join13 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -1278,6 +1458,8 @@ Before doing FET or OpenSpec work in Codex, read:
 - openspec/config.yaml
 - 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.
+
 Use the terminal command \`fet <command>\` as the source of truth for workflow transitions. These files are Codex-readable guidance; they do not register native slash commands.
 
 Command guides live in .codex/fet/commands/.
@@ -1313,8 +1495,12 @@ FET:END -->
 
 # fet ${command}
 
+${renderIdeModelPolicy(command)}
+
 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.
 
+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:
 
 \`\`\`sh
@@ -1337,8 +1523,12 @@ FET:END -->
 
 # fet passthrough
 
+${renderIdeModelPolicy("passthrough")}
+
 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.
 
+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:
 
 \`\`\`sh
@@ -1405,6 +1595,8 @@ 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.
 
+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:
 
 \`\`\`sh
@@ -1425,8 +1617,12 @@ FET:END -->
 
 # fet fill-context
 
+${renderIdeModelPolicy("fill-context")}
+
 Use this command to complete FET-generated project context placeholders with Codex.
 
+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:
 
 \`\`\`sh
@@ -1809,6 +2005,7 @@ Output:
   );
 }
 function renderManagedSlashPrompt(command, description, body) {
+  const policyCommand = command.split(/\s+/)[1] ?? command;
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -1822,6 +2019,10 @@ description: ${description}
 argument-hint: command arguments
 ---
 
+${renderIdeModelPolicy(policyCommand)}
+
+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.
+
 ${body}
 `;
 }
@@ -1832,7 +2033,7 @@ var CodexAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists3(join12(projectRoot, ".codex")) || await exists3(join12(projectRoot, "AGENTS.md")),
+      detected: await exists3(join13(projectRoot, ".codex")) || await exists3(join13(projectRoot, "AGENTS.md")),
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
@@ -1898,9 +2099,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join12(resolveCodexHome(), file.path);
+    return join13(resolveCodexHome(), file.path);
   }
-  return join12(projectRoot, file.path);
+  return join13(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -1909,7 +2110,7 @@ function displayPathFor(file) {
   return file.path;
 }
 function resolveCodexHome() {
-  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join12(homedir(), ".codex");
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join13(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
@@ -1929,7 +2130,7 @@ async function exists3(path) {
 
 // src/adapters/cursor/index.ts
 import { mkdir as mkdir7, readFile as readFile13, stat as stat6 } from "fs/promises";
-import { dirname as dirname7, join as join13 } from "path";
+import { dirname as dirname7, join as join14 } from "path";
 
 // src/adapters/cursor/templates.ts
 function cursorSkillFiles() {
@@ -1957,6 +2158,7 @@ alwaysApply: false
 
 - 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
 
 \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
@@ -1982,6 +2184,10 @@ disable-model-invocation: false
 
 Run \`fet fill-context\` first if the IDE commands need refreshing.
 
+${renderIdeModelPolicy(command)}
+
+If GitNexus code graph context is available in Cursor, prefer it before broad repository scans. If it is unavailable, continue normally.
+
 Then read:
 
 - AGENTS.md
@@ -2004,6 +2210,10 @@ description: Run FET-managed OpenSpec ${command} workflow from the terminal
 disable-model-invocation: true
 ---
 
+${renderIdeModelPolicy(command)}
+
+If GitNexus code graph context is available in Cursor, prefer it before broad repository scans. If it is unavailable, continue normally.
+
 \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
 
 \u8BF7\u5728\u7EC8\u7AEF\u4E2D\u6267\u884C\uFF1A
@@ -2022,7 +2232,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists4(join13(projectRoot, ".cursor")),
+      detected: await exists4(join14(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -2039,7 +2249,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join13(projectRoot, file.path);
+      const target = join14(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -2062,7 +2272,7 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join13(projectRoot, file.path);
+      const target = join14(projectRoot, file.path);
       const content = await readExisting2(target);
       const managed = Boolean(content?.includes("FET:MANAGED"));
       const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
@@ -2093,17 +2303,17 @@ async function exists4(path) {
 }
 
 // src/openspec/adapter.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
 
 // src/openspec/inspector.ts
 import { readdir, stat as stat7 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join14(projectRoot, "openspec");
-  const changesPath = join14(openspecPath, "changes");
-  const legacyArchivePath = join14(openspecPath, "archive");
-  const changesArchivePath = join14(changesPath, "archive");
+  const openspecPath = join15(projectRoot, "openspec");
+  const changesPath = join15(openspecPath, "changes");
+  const legacyArchivePath = join15(openspecPath, "archive");
+  const changesArchivePath = join15(changesPath, "archive");
   return {
     exists: await exists5(openspecPath),
     changes: await listDirectories(changesPath, { exclude: ["archive"] }),
@@ -2111,13 +2321,13 @@ async function inspectOpenSpecProject(projectRoot) {
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join14(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join14(changePath, "tasks.md");
-  const specsPath = join14(changePath, "specs");
+  const changePath = join15(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join15(changePath, "tasks.md");
+  const specsPath = join15(changePath, "specs");
   return {
     changeId,
     exists: await exists5(changePath),
-    hasProposal: await exists5(join14(changePath, "proposal.md")),
+    hasProposal: await exists5(join15(changePath, "proposal.md")),
     hasTasks: await exists5(tasksPath),
     hasSpecs: await exists5(specsPath),
     tasksPath,
@@ -2143,9 +2353,9 @@ async function exists5(path) {
 }
 
 // src/openspec/resolver.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 async function resolveOpenSpecExecutable() {
   const executablePath = await findExecutable();
   const version = await readVersion(executablePath);
@@ -2192,7 +2402,7 @@ async function readVersion(executablePath) {
   }
 }
 function exec(command, args) {
-  return execFileAsync2(command, args, { shell: process.platform === "win32" });
+  return execFileAsync3(command, args, { shell: process.platform === "win32" });
 }
 
 // src/openspec/runner.ts
@@ -2238,7 +2448,7 @@ async function runOpenSpec(executablePath, command, args, options) {
 }
 
 // src/openspec/adapter.ts
-var execFileAsync3 = promisify3(execFile3);
+var execFileAsync4 = promisify4(execFile4);
 var DefaultOpenSpecAdapter = class {
   identity;
   async resolveExecutable() {
@@ -2250,7 +2460,7 @@ var DefaultOpenSpecAdapter = class {
     const executable = identity.executablePath === "npx openspec" ? "npx" : identity.executablePath;
     const args = identity.executablePath === "npx openspec" ? ["openspec", "--help"] : ["--help"];
     try {
-      const { stdout } = await execFileAsync3(executable, args, { shell: process.platform === "win32" });
+      const { stdout } = await execFileAsync4(executable, args, { shell: process.platform === "win32" });
       return {
         version: identity.version,
         commands: parseCommands(stdout),
@@ -2295,11 +2505,11 @@ function parseCommands(help) {
 
 // src/scanner/package.ts
 import { readFile as readFile14, stat as stat8 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { parse as parse2 } from "yaml";
 async function readPackageJson(projectRoot) {
   try {
-    return JSON.parse(await readFile14(join15(projectRoot, "package.json"), "utf8"));
+    return JSON.parse(await readFile14(join16(projectRoot, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -2365,7 +2575,7 @@ function detectFramework(pkg) {
 }
 async function detectLanguage(projectRoot, pkg) {
   const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  if (deps.typescript || await exists6(join15(projectRoot, "tsconfig.json"))) {
+  if (deps.typescript || await exists6(join16(projectRoot, "tsconfig.json"))) {
     return "typescript";
   }
   return "javascript";
@@ -2380,7 +2590,7 @@ async function detectWorkspaces(projectRoot, pkg) {
     return packageWorkspaces;
   }
   try {
-    const workspace = parse2(await readFile14(join15(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    const workspace = parse2(await readFile14(join16(projectRoot, "pnpm-workspace.yaml"), "utf8"));
     return (workspace?.packages ?? []).map((path) => ({
       name: path,
       path,
@@ -2400,7 +2610,7 @@ async function detectLockManagers(projectRoot) {
   ];
   const found = [];
   for (const [file, manager] of lockFiles) {
-    if (await exists6(join15(projectRoot, file))) {
+    if (await exists6(join16(projectRoot, file))) {
       found.push(manager);
     }
   }
@@ -2426,12 +2636,12 @@ async function exists6(path) {
 
 // src/scanner/routes.ts
 import { readdir as readdir2, stat as stat9 } from "fs/promises";
-import { join as join16, relative, sep } from "path";
+import { join as join17, relative, sep } from "path";
 async function scanRoutes(projectRoot) {
   const candidates = ["src/routes", "src/pages", "app", "pages"];
   const routes = [];
   for (const candidate of candidates) {
-    const root = join16(projectRoot, candidate);
+    const root = join17(projectRoot, candidate);
     if (!await exists7(root)) {
       continue;
     }
@@ -2459,7 +2669,7 @@ async function listFiles(root) {
   const entries = await readdir2(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join16(root, entry.name);
+    const path = join17(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -2523,6 +2733,11 @@ var OutputWriter = class {
     }
   }
   warn(message, details) {
+    if (this.json) {
+      process.stderr.write(`${JSON.stringify({ ok: true, warning: message, details }, null, 2)}
+`);
+      return;
+    }
     if (!this.json) {
       process.stderr.write(`\u8B66\u544A\uFF1A${message}${formatDetails(details)}
 `);
@@ -2633,6 +2848,8 @@ 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 warnIfContextPlaceholdersRemain(ctx);
       await handler(ctx, ...args);
     } catch (error) {
       const fetError = toFetError(error);
@@ -2641,6 +2858,40 @@ function wrap(command, handler) {
     }
   };
 }
+async function confirmModelPolicyRecommendation(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) {
+    return;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = (await rl.question("Continue anyway? [y/N] ")).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      throw new FetError({
+        code: "USER_CANCELLED" /* UserCancelled */,
+        message: "Command cancelled so you can switch IDE model.",
+        details: { command: ctx.command, detected: mismatch.detected, recommended: mismatch.recommended },
+        suggestedCommand: `Switch IDE model, then rerun fet ${ctx.command}.`
+      });
+    }
+  } finally {
+    rl.close();
+  }
+}
+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));
+  }
+}
 function isCommandLike(value) {
   return value instanceof Command;
 }