@nick848/fet 1.0.2 → 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,18 +578,20 @@ async function exists(path) {
 }
 
 // src/commands/doctor.ts
-import { 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 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);
@@ -502,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();
@@ -521,6 +647,20 @@ 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(projectRoot) {
+  try {
+    await readFile7(join8(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" };
+  }
+}
 async function exists2(path) {
   try {
     await stat3(path);
@@ -530,10 +670,77 @@ async function exists2(path) {
   }
 }
 
+// src/commands/fill-context.ts
+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 = join9(ctx.projectRoot, ".fet", "fill-context.md");
+      await mkdir3(dirname5(handoffPath), { recursive: true });
+      await atomicWrite(handoffPath, renderGenericHandoff());
+      for (const adapter of ctx.toolAdapters) {
+        const plan = await adapter.planInstall(ctx.projectRoot);
+        const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
+        const state = await ctx.stateStore.getOrCreateGlobal();
+        state.toolAdapters[adapter.tool] = {
+          adapterVersion: adapter.adapterVersion,
+          installed: true,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await ctx.stateStore.writeGlobal(state);
+        if (ctx.verbose) {
+          ctx.output.info(`Updated ${adapter.tool} adapter`, { written: result.written });
+        }
+      }
+    }
+  );
+  const placeholders = await countAgentsLlmPlaceholders(ctx.projectRoot);
+  ctx.output.result({
+    ok: true,
+    command: "fill-context",
+    summary: placeholders ? `Found ${placeholders} AGENTS.md placeholder(s). Use your IDE AI to fill them.` : "No AGENTS.md placeholders found. IDE fill-context commands were refreshed.",
+    nextSteps: placeholders ? [
+      "Cursor: run /fet-fill-context",
+      "Codex: run /prompts:fet-fill-context",
+      "OpenCode or other IDEs: open .fet/fill-context.md or run fet fill-context for handoff instructions"
+    ] : ["Run fet doctor to confirm project context health"],
+    data: {
+      placeholders,
+      cursorCommand: "/fet-fill-context",
+      codexCommand: "/prompts:fet-fill-context"
+    }
+  });
+}
+function renderGenericHandoff() {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+generator: fill-context
+FET:END -->
+
+# FET Fill Context
+
+Use the IDE AI to complete FET-generated placeholders.
+
+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.
+`;
+}
+
+// src/commands/proxy.ts
+import { readFile as readFile10 } from "fs/promises";
+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"]),
@@ -549,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;
@@ -557,8 +764,8 @@ async function git(cwd, args) {
 }
 
 // src/state/store.ts
-import { mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
-import { join as join8 } from "path";
+import { mkdir as mkdir4, readFile as readFile8 } from "fs/promises";
+import { join as join10 } from "path";
 
 // src/state/schema.ts
 var phases = ["explore", "propose", "implement", "verify", "sync", "archive"];
@@ -579,6 +786,7 @@ function createGlobalState(fetVersion, project) {
       scannerVersion: 1
     },
     toolAdapters: {},
+    graph: {},
     verifyAuthorization: null,
     lastDoctor: null
   };
@@ -651,7 +859,7 @@ var StateStore = class {
   project;
   async readGlobal() {
     try {
-      const value = JSON.parse(await readFile6(this.globalPath(), "utf8"));
+      const value = JSON.parse(await readFile8(this.globalPath(), "utf8"));
       assertGlobalState(value);
       return value;
     } catch (error) {
@@ -666,13 +874,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir3(join8(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir4(join10(this.projectRoot, "openspec"), { recursive: true });
     await atomicWrite(this.globalPath(), `${JSON.stringify(state, null, 2)}
 `);
   }
   async readChange(changeId) {
     try {
-      const value = JSON.parse(await readFile6(this.changePath(changeId), "utf8"));
+      const value = JSON.parse(await readFile8(this.changePath(changeId), "utf8"));
       assertChangeState(value);
       return value;
     } catch (error) {
@@ -687,15 +895,15 @@ var StateStore = class {
   }
   async writeChange(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir3(join8(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 join8(this.projectRoot, "openspec", "fet-state.json");
+    return join10(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join8(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join10(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -703,11 +911,11 @@ function isNotFound(error) {
 }
 
 // src/state/tasks.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 async function readCompletedTaskIds(tasksPath) {
   let content;
   try {
-    content = await readFile7(tasksPath, "utf8");
+    content = await readFile9(tasksPath, "utf8");
   } catch {
     return [];
   }
@@ -746,6 +954,8 @@ async function proxyCommand(ctx, command, args) {
         await assertVerified(ctx);
       }
       const mapped = await mapOpenSpecCommand(ctx, command, openSpecArgs);
+      const targetChangeId = command === "archive" ? mapped.args[0] ?? ctx.changeId ?? null : ctx.changeId ?? null;
+      const changelogEntry = command === "archive" && targetChangeId ? await createChangelogEntry(ctx.projectRoot, targetChangeId) : null;
       const result = await ctx.openSpec.run(mapped.command, mapped.args, { cwd: ctx.projectRoot, stdio: ctx.json ? "pipe" : "inherit" });
       if (result.exitCode !== 0) {
         throw new FetError({
@@ -755,15 +965,25 @@ async function proxyCommand(ctx, command, args) {
           recoverable: true
         });
       }
+      if (changelogEntry) {
+        await appendChangelog(ctx.projectRoot, changelogEntry);
+      }
       const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
       const state = await ctx.stateStore.getOrCreateGlobal();
       state.openChangeIds = inspection.changes;
-      if (ctx.changeId && inspection.changes.includes(ctx.changeId)) {
-        state.activeChangeId = ctx.changeId;
-      } else if (state.activeChangeId && !inspection.changes.includes(state.activeChangeId)) {
-        state.activeChangeId = inspection.changes.length === 1 ? inspection.changes[0] ?? null : null;
-      } else if (!state.activeChangeId && inspection.changes.length === 1) {
-        state.activeChangeId = inspection.changes[0] ?? null;
+      if (command === "archive") {
+        if (!state.activeChangeId || state.activeChangeId === targetChangeId || !inspection.changes.includes(state.activeChangeId)) {
+          state.activeChangeId = null;
+        }
+        state.verifyAuthorization = null;
+      } else {
+        if (ctx.changeId && inspection.changes.includes(ctx.changeId)) {
+          state.activeChangeId = ctx.changeId;
+        } else if (state.activeChangeId && !inspection.changes.includes(state.activeChangeId)) {
+          state.activeChangeId = inspection.changes.length === 1 ? inspection.changes[0] ?? null : null;
+        } else if (!state.activeChangeId && inspection.changes.length === 1) {
+          state.activeChangeId = inspection.changes[0] ?? null;
+        }
       }
       await ctx.stateStore.writeGlobal(state);
       const changeId = ctx.changeId ?? state.activeChangeId;
@@ -793,6 +1013,58 @@ async function proxyCommand(ctx, command, args) {
     summary: `fet ${command} \u5B8C\u6210\u3002`
   });
 }
+async function createChangelogEntry(projectRoot, changeId) {
+  return {
+    updateTime: formatLocalTimestamp(/* @__PURE__ */ new Date()),
+    content: await readChangeRequirement(projectRoot, changeId)
+  };
+}
+async function appendChangelog(projectRoot, entry) {
+  const changelogPath = join11(projectRoot, "CHANGELOG.md");
+  const existing = await readOptional3(changelogPath);
+  const block = `updateTime: ${entry.updateTime}
+\u66F4\u65B0\u5185\u5BB9:${entry.content}
+`;
+  const next = existing?.trimEnd() ? `${existing.trimEnd()}
+
+${block}` : block;
+  await atomicWrite(changelogPath, next);
+}
+async function readChangeRequirement(projectRoot, changeId) {
+  const changeRoot = join11(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional3(join11(changeRoot, "proposal.md"));
+  if (proposal) {
+    return summarizeMarkdown(proposal);
+  }
+  const readme = await readOptional3(join11(changeRoot, "README.md"));
+  if (readme) {
+    return summarizeMarkdown(readme);
+  }
+  return changeId;
+}
+function summarizeMarkdown(content) {
+  const normalized = content.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("<!--") && !line.startsWith("---")).join(" ");
+  return normalized || "\u672A\u63D0\u4F9B\u53D8\u66F4\u9700\u6C42";
+}
+async function readOptional3(path) {
+  try {
+    return await readFile10(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function formatLocalTimestamp(date) {
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
 async function passthroughCommand(ctx, command, args) {
   const result = await ctx.openSpec.run(command, stripFetOptions(args), { cwd: ctx.projectRoot, stdio: ctx.json ? "pipe" : "inherit" });
   if (result.exitCode !== 0) {
@@ -826,32 +1098,37 @@ function stripFetOptions(args) {
 async function mapOpenSpecCommand(ctx, command, args) {
   switch (command) {
     case "propose":
-    case "new":
-      return { command: "new", args: args[0] === "change" ? args : ["change", ...args] };
     case "continue":
-      return { command: "instructions", args: [...withoutUndefined(args[0] ? [args[0]] : ["proposal"]), "--change", await requireChangeId(ctx)] };
     case "ff":
-      return { command: "status", args: ["--change", await requireChangeId(ctx)] };
     case "apply":
-      return { command: "instructions", args: ["apply", "--change", await requireChangeId(ctx)] };
     case "sync":
-      return { command: "validate", args: [ctx.changeId ?? args[0] ?? await requireChangeId(ctx), "--type", "change", "--strict"] };
+    case "bulk-archive":
+    case "explore":
+    case "onboard":
+      return { command, args: withGlobalChange(ctx, args) };
+    case "new":
+      return { command: "new", args: args[0] === "change" ? args : ["change", ...args] };
     case "archive":
       return { command: "archive", args: [ctx.changeId ?? args[0] ?? await requireChangeId(ctx), ...args.slice(ctx.changeId ? 0 : 1)] };
+    /*
     case "bulk-archive":
       throw new FetError({
-        code: "INVALID_ARGUMENTS" /* InvalidArguments */,
-        message: "OpenSpec 1.2.0 \u4E0D\u63D0\u4F9B bulk-archive \u9876\u5C42\u547D\u4EE4",
-        suggestedCommand: "\u9010\u4E2A\u6267\u884C fet archive --change <change-id>"
+        code: ErrorCode.InvalidArguments,
+        message: "OpenSpec 1.2.0 不提供 bulk-archive 顶层命令",
+        suggestedCommand: "逐个执行 fet archive --change <change-id>"
       });
     case "explore":
-      return { command: "instructions", args: ["proposal", "--change", await requireChangeId(ctx)] };
+      return { command: "explore", args: ctx.changeId ? ["--change", ctx.changeId, ...args] : args };
     case "onboard":
       return { command: "instructions", args: [] };
+    */
     default:
       return { command, args };
   }
 }
+function withGlobalChange(ctx, args) {
+  return ctx.changeId ? ["--change", ctx.changeId, ...args] : args;
+}
 async function requireChangeId(ctx) {
   if (ctx.changeId) {
     return ctx.changeId;
@@ -871,9 +1148,6 @@ async function requireChangeId(ctx) {
     suggestedCommand: "\u6DFB\u52A0 --change <change-id>"
   });
 }
-function withoutUndefined(values) {
-  return values.filter(Boolean);
-}
 async function assertVerified(ctx) {
   const global = await ctx.stateStore.getOrCreateGlobal();
   const changeId = ctx.changeId ?? global.activeChangeId;
@@ -906,8 +1180,8 @@ async function assertVerified(ctx) {
 
 // src/commands/verify.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir4, readFile as readFile8, stat as stat4 } from "fs/promises";
-import { join as join9 } from "path";
+import { mkdir as mkdir5, readFile as readFile11, stat as stat4 } from "fs/promises";
+import { join as join12 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -974,9 +1248,9 @@ async function verifyCommand(ctx, options) {
 async function writeInstructions(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join9(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
-  const instructionsPath = join9(dir, "verify-instructions.md");
-  await mkdir4(dir, { recursive: true });
+  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");
   state.currentPhase = "verify";
@@ -992,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 = join9(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");
@@ -1028,7 +1302,7 @@ async function assertChangeExists(ctx, changeId) {
 async function readInstructions(path, changeId) {
   try {
     await stat4(path);
-    const content = await readFile8(path, "utf8");
+    const content = await readFile11(path, "utf8");
     const fileChangeId = readFrontMatterValue(content, "changeId");
     if (fileChangeId !== changeId) {
       throw new FetError({
@@ -1078,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 mkdir5, readFile as readFile9, stat as stat5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile12, stat as stat5 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname5, join as join10 } from "path";
+import { dirname as dirname6, join as join13 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -1100,7 +1437,7 @@ var FET_WORKFLOW_COMMANDS = [
   "bulk-archive",
   "onboard"
 ];
-var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, "passthrough"];
+var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, "fill-context", "passthrough"];
 
 // src/adapters/codex/templates.ts
 function codexGuideFile() {
@@ -1121,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/.
@@ -1140,6 +1479,9 @@ function codexSlashPromptFiles() {
   }));
 }
 function renderCommand(command) {
+  if (command === "fill-context") {
+    return renderFillContextCommand();
+  }
   if (command === "passthrough") {
     return renderPassthroughCommand();
   }
@@ -1153,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
@@ -1177,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
@@ -1219,6 +1569,9 @@ function renderSlashPrompt(command) {
   if (command === "onboard") {
     return renderOnboardSlashPrompt();
   }
+  if (command === "fill-context") {
+    return renderFillContextSlashPrompt();
+  }
   if (command === "passthrough") {
     return renderPassthroughSlashPrompt();
   }
@@ -1242,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
@@ -1251,6 +1606,66 @@ ${shellCommand}
 After it completes, summarize the important FET output and next steps.
 `;
 }
+function renderFillContextCommand() {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: fet fill-context
+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
+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() {
+  return renderManagedSlashPrompt(
+    "fet fill-context",
+    "Fill FET AGENTS.md placeholders with Codex",
+    `Complete FET-generated project context placeholders.
+
+Steps:
+
+1. Refresh FET IDE handoff files:
+   \`\`\`sh
+   fet fill-context
+   \`\`\`
+2. Read AGENTS.md and openspec/config.yaml.
+3. 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:
+   \`\`\`sh
+   fet doctor
+   \`\`\`
+   Confirm that no AGENTS.md placeholder warning remains.
+
+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.`
+  );
+}
 function renderNewSlashPrompt() {
   return renderManagedSlashPrompt(
     "fet new [...args]",
@@ -1294,11 +1709,11 @@ Input after the slash command should identify the change, for example a change i
 Steps:
 
 1. Resolve the change id. If ambiguous, ask the user.
-2. Get FET-managed apply instructions:
+2. Run the native OpenSpec apply flow through FET:
    \`\`\`sh
    fet apply --change <change-id> --json
    \`\`\`
-3. Read all context files named by the instructions output. If JSON output is unavailable, read the files referenced by the terminal output and the artifacts under openspec/changes/<change-id>/.
+3. Follow the native apply output. If JSON output is unavailable, read the files referenced by the terminal output and the artifacts under openspec/changes/<change-id>/.
 4. If apply is blocked because required artifacts are missing, stop and suggest /prompts:fet-continue <change-id> or /prompts:fet-ff <change-id>.
 5. Implement pending tasks one by one:
    - Keep code changes minimal and scoped to the task.
@@ -1502,11 +1917,11 @@ Steps:
    \`\`\`sh
    fet new <change-id>
    \`\`\`
-5. Get proposal instructions through FET:
+5. Run the native OpenSpec exploration flow through FET so clarification prompts stay interactive:
    \`\`\`sh
    fet explore --change <change-id>
    \`\`\`
-6. If the user asks to generate or capture the proposal, create openspec/changes/<change-id>/proposal.md using the instruction/template/output path from FET/OpenSpec. Fill the proposal from the conversation and project context.
+6. If OpenSpec or the user asks to generate or capture the proposal, create openspec/changes/<change-id>/proposal.md using the interactive answers, conversation, and project context.
 
 Guardrails:
 - Do not write application code in explore mode.
@@ -1532,11 +1947,11 @@ Steps:
    fet passthrough status --change <change-id> --json
    \`\`\`
 4. Pick the first artifact whose status is ready, unless the user specified an artifact id.
-5. Get FET-managed instructions:
+5. Run the native OpenSpec continue flow through FET:
    \`\`\`sh
    fet continue <artifact-id> --change <change-id> --json
    \`\`\`
-6. Parse the instructions output. Use its template, instruction, dependencies, and outputPath.
+6. Follow the native continue output. When it provides template, instruction, dependencies, and outputPath, use those fields.
 7. Read dependency files before writing.
 8. Create the artifact file at outputPath. Do not copy context/rules wrapper text into the artifact; use those fields only as constraints.
 9. Verify the file exists, then run:
@@ -1557,6 +1972,7 @@ Guardrails:
 }
 function renderFastForwardSlashPrompt(command) {
   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(
     `fet ${command} [...args]`,
     command === "propose" ? "Create a change and generate required OpenSpec artifacts" : "Generate required OpenSpec artifacts for a change",
@@ -1567,22 +1983,13 @@ Input after the slash command may be a change id or a description of what the us
 Steps:
 
 1. Load project context from AGENTS.md and openspec/config.yaml.
-2. Resolve or create the change:
-   - If this is a new change, derive a kebab-case id and run \`fet new <change-id>\`.
-   - If the change already exists, continue it instead of recreating it.
-3. Check artifact status:
+2. Resolve the change id or description. If ambiguous, ask the user.
+3. Run the native OpenSpec ${command} flow through FET:
    \`\`\`sh
-   fet passthrough status --change <change-id> --json
+   ${commandLine}
    \`\`\`
-4. Loop until the change is apply-ready:
-   - Pick the first artifact whose status is ready.
-   - Run \`fet continue <artifact-id> --change <change-id> --json\`.
-   - Parse template, instruction, dependencies, and outputPath.
-   - Read dependency files.
-   - Write the artifact file at outputPath.
-   - Re-run \`fet passthrough status --change <change-id> --json\`.
-   - Stop when all apply-required artifacts are done, or when no artifact is ready.
-5. If context is unclear, ask one concise question, then continue.
+4. Follow the native output. If it asks for clarification, ask the user rather than inventing details.
+5. If the native output includes artifact paths or templates to write, create only those files and preserve OpenSpec structure.
 
 Artifact rules:
 - Follow the instruction field from OpenSpec/FET for each artifact.
@@ -1598,6 +2005,7 @@ Output:
   );
 }
 function renderManagedSlashPrompt(command, description, body) {
+  const policyCommand = command.split(/\s+/)[1] ?? command;
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -1611,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}
 `;
 }
@@ -1621,7 +2033,7 @@ var CodexAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists3(join10(projectRoot, ".codex")) || await exists3(join10(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"
     };
   }
@@ -1660,7 +2072,7 @@ var CodexAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && force) {
         await createBackup(target);
       }
-      await mkdir5(dirname5(target), { recursive: true });
+      await mkdir6(dirname6(target), { recursive: true });
       await atomicWrite(target, file.content);
       written.push(displayPath);
     }
@@ -1687,9 +2099,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join10(resolveCodexHome(), file.path);
+    return join13(resolveCodexHome(), file.path);
   }
-  return join10(projectRoot, file.path);
+  return join13(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -1698,11 +2110,11 @@ function displayPathFor(file) {
   return file.path;
 }
 function resolveCodexHome() {
-  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join10(homedir(), ".codex");
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join13(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile12(path, "utf8");
   } catch {
     return null;
   }
@@ -1717,8 +2129,8 @@ async function exists3(path) {
 }
 
 // src/adapters/cursor/index.ts
-import { mkdir as mkdir6, readFile as readFile10, stat as stat6 } from "fs/promises";
-import { dirname as dirname6, join as join11 } from "path";
+import { mkdir as mkdir7, readFile as readFile13, stat as stat6 } from "fs/promises";
+import { dirname as dirname7, join as join14 } from "path";
 
 // src/adapters/cursor/templates.ts
 function cursorSkillFiles() {
@@ -1746,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
@@ -1754,6 +2167,35 @@ alwaysApply: false
 }
 function renderSkill(command) {
   const usage = command === "passthrough" ? "fet passthrough <openspec-command> [...args]" : `fet ${command}`;
+  if (command === "fill-context") {
+    return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: cursor-adapter
+adapterVersion: 1
+command: fet fill-context
+FET:END -->
+
+---
+name: fet-fill-context
+description: Fill FET AGENTS.md placeholders with Cursor AI
+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
+- 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.
+`;
+  }
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
@@ -1768,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
@@ -1786,7 +2232,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists4(join11(projectRoot, ".cursor")),
+      detected: await exists4(join14(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -1803,7 +2249,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join11(projectRoot, file.path);
+      const target = join14(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -1816,7 +2262,7 @@ var CursorAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && force) {
         await createBackup(target);
       }
-      await mkdir6(dirname6(target), { recursive: true });
+      await mkdir7(dirname7(target), { recursive: true });
       await atomicWrite(target, file.content);
       written.push(file.path);
     }
@@ -1826,7 +2272,7 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join11(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}`));
@@ -1842,7 +2288,7 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch {
     return null;
   }
@@ -1857,40 +2303,42 @@ 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 join12 } from "path";
+import { join as join15 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join12(projectRoot, "openspec");
-  const changesPath = join12(openspecPath, "changes");
-  const archivePath = join12(openspecPath, "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),
-    archived: await listDirectories(archivePath)
+    changes: await listDirectories(changesPath, { exclude: ["archive"] }),
+    archived: [.../* @__PURE__ */ new Set([...await listDirectories(legacyArchivePath), ...await listDirectories(changesArchivePath)])]
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join12(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join12(changePath, "tasks.md");
-  const specsPath = join12(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(join12(changePath, "proposal.md")),
+    hasProposal: await exists5(join15(changePath, "proposal.md")),
     hasTasks: await exists5(tasksPath),
     hasSpecs: await exists5(specsPath),
     tasksPath,
     changePath
   };
 }
-async function listDirectories(path) {
+async function listDirectories(path, options = {}) {
   try {
     const entries = await readdir(path, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const excluded = new Set(options.exclude ?? []);
+    return entries.filter((entry) => entry.isDirectory() && !excluded.has(entry.name)).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -1905,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);
@@ -1954,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
@@ -2000,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() {
@@ -2012,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),
@@ -2056,12 +2504,12 @@ function parseCommands(help) {
 }
 
 // src/scanner/package.ts
-import { readFile as readFile11, stat as stat8 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile14, stat as stat8 } from "fs/promises";
+import { join as join16 } from "path";
 import { parse as parse2 } from "yaml";
 async function readPackageJson(projectRoot) {
   try {
-    return JSON.parse(await readFile11(join13(projectRoot, "package.json"), "utf8"));
+    return JSON.parse(await readFile14(join16(projectRoot, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -2127,7 +2575,7 @@ function detectFramework(pkg) {
 }
 async function detectLanguage(projectRoot, pkg) {
   const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  if (deps.typescript || await exists6(join13(projectRoot, "tsconfig.json"))) {
+  if (deps.typescript || await exists6(join16(projectRoot, "tsconfig.json"))) {
     return "typescript";
   }
   return "javascript";
@@ -2142,7 +2590,7 @@ async function detectWorkspaces(projectRoot, pkg) {
     return packageWorkspaces;
   }
   try {
-    const workspace = parse2(await readFile11(join13(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    const workspace = parse2(await readFile14(join16(projectRoot, "pnpm-workspace.yaml"), "utf8"));
     return (workspace?.packages ?? []).map((path) => ({
       name: path,
       path,
@@ -2162,7 +2610,7 @@ async function detectLockManagers(projectRoot) {
   ];
   const found = [];
   for (const [file, manager] of lockFiles) {
-    if (await exists6(join13(projectRoot, file))) {
+    if (await exists6(join16(projectRoot, file))) {
       found.push(manager);
     }
   }
@@ -2188,12 +2636,12 @@ async function exists6(path) {
 
 // src/scanner/routes.ts
 import { readdir as readdir2, stat as stat9 } from "fs/promises";
-import { join as join14, 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 = join14(projectRoot, candidate);
+    const root = join17(projectRoot, candidate);
     if (!await exists7(root)) {
       continue;
     }
@@ -2221,7 +2669,7 @@ async function listFiles(root) {
   const entries = await readdir2(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join14(root, entry.name);
+    const path = join17(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -2285,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)}
 `);
@@ -2373,6 +2826,7 @@ 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");
 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));
 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) }))
 );
@@ -2394,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);
@@ -2402,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;
 }