@nick848/fet 1.0.2 → 1.0.3

package/dist/cli/index.js

@@ -473,7 +473,7 @@ async function exists(path) {
 }
 
 // src/commands/doctor.ts
-import { stat as stat3 } from "fs/promises";
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
 import { join as join7 } from "path";
 async function doctorCommand(ctx, options = {}) {
   const checks = [];
@@ -481,6 +481,7 @@ async function doctorCommand(ctx, options = {}) {
   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")));
   for (const adapter of ctx.toolAdapters) {
     checks.push(...await adapter.doctor(ctx.projectRoot));
   }
@@ -521,6 +522,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(path) {
+  try {
+    const content = await readFile6(path, "utf8");
+    const count2 = [...content.matchAll(/\[NEEDS? LLM INPUT\]/g)].length;
+    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,6 +545,82 @@ 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;
+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");
+      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 countPlaceholders(join8(ctx.projectRoot, "AGENTS.md"));
+  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.
+`;
+}
+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";
+
 // src/state/project.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -557,8 +648,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 join9 } from "path";
 
 // src/state/schema.ts
 var phases = ["explore", "propose", "implement", "verify", "sync", "archive"];
@@ -651,7 +742,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 +757,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir3(join8(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir4(join9(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 +778,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(join9(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 join9(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join8(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join9(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -703,11 +794,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 +837,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 +848,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 +896,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 = join10(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 = join10(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional3(join10(changeRoot, "proposal.md"));
+  if (proposal) {
+    return summarizeMarkdown(proposal);
+  }
+  const readme = await readOptional3(join10(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 +981,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 +1031,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 +1063,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 join11 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -974,9 +1131,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 = join11(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join11(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 +1149,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 = join11(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 +1185,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({
@@ -1082,9 +1239,9 @@ async function resolveChangeId(ctx) {
 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 join12 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -1100,7 +1257,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() {
@@ -1140,6 +1297,9 @@ function codexSlashPromptFiles() {
   }));
 }
 function renderCommand(command) {
+  if (command === "fill-context") {
+    return renderFillContextCommand();
+  }
   if (command === "passthrough") {
     return renderPassthroughCommand();
   }
@@ -1219,6 +1379,9 @@ function renderSlashPrompt(command) {
   if (command === "onboard") {
     return renderOnboardSlashPrompt();
   }
+  if (command === "fill-context") {
+    return renderFillContextSlashPrompt();
+  }
   if (command === "passthrough") {
     return renderPassthroughSlashPrompt();
   }
@@ -1251,6 +1414,62 @@ ${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
+
+Use this command to complete FET-generated project context placeholders with Codex.
+
+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 +1513,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 +1721,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 +1751,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 +1776,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 +1787,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.
@@ -1621,7 +1832,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(join12(projectRoot, ".codex")) || await exists3(join12(projectRoot, "AGENTS.md")),
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
@@ -1660,7 +1871,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 +1898,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join10(resolveCodexHome(), file.path);
+    return join12(resolveCodexHome(), file.path);
   }
-  return join10(projectRoot, file.path);
+  return join12(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -1698,11 +1909,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 ?? join12(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile12(path, "utf8");
   } catch {
     return null;
   }
@@ -1717,8 +1928,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 join13 } from "path";
 
 // src/adapters/cursor/templates.ts
 function cursorSkillFiles() {
@@ -1754,6 +1965,31 @@ 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.
+
+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}
@@ -1786,7 +2022,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists4(join11(projectRoot, ".cursor")),
+      detected: await exists4(join13(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -1803,7 +2039,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join11(projectRoot, file.path);
+      const target = join13(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -1816,7 +2052,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 +2062,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 = join13(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 +2078,7 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch {
     return null;
   }
@@ -1862,35 +2098,37 @@ import { promisify as promisify3 } from "util";
 
 // src/openspec/inspector.ts
 import { readdir, stat as stat7 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join12(projectRoot, "openspec");
-  const changesPath = join12(openspecPath, "changes");
-  const archivePath = join12(openspecPath, "archive");
+  const openspecPath = join14(projectRoot, "openspec");
+  const changesPath = join14(openspecPath, "changes");
+  const legacyArchivePath = join14(openspecPath, "archive");
+  const changesArchivePath = join14(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 = join14(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join14(changePath, "tasks.md");
+  const specsPath = join14(changePath, "specs");
   return {
     changeId,
     exists: await exists5(changePath),
-    hasProposal: await exists5(join12(changePath, "proposal.md")),
+    hasProposal: await exists5(join14(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 [];
   }
@@ -2056,12 +2294,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 join15 } 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(join15(projectRoot, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -2127,7 +2365,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(join15(projectRoot, "tsconfig.json"))) {
     return "typescript";
   }
   return "javascript";
@@ -2142,7 +2380,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(join15(projectRoot, "pnpm-workspace.yaml"), "utf8"));
     return (workspace?.packages ?? []).map((path) => ({
       name: path,
       path,
@@ -2162,7 +2400,7 @@ async function detectLockManagers(projectRoot) {
   ];
   const found = [];
   for (const [file, manager] of lockFiles) {
-    if (await exists6(join13(projectRoot, file))) {
+    if (await exists6(join15(projectRoot, file))) {
       found.push(manager);
     }
   }
@@ -2188,12 +2426,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 join16, 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 = join16(projectRoot, candidate);
     if (!await exists7(root)) {
       continue;
     }
@@ -2221,7 +2459,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 = join16(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -2373,6 +2611,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) }))
 );