@nick848/fet 1.0.1 → 1.0.3

package/dist/cli/index.js

@@ -182,7 +182,7 @@ function count(content, needle) {
 
 // src/templates/agents-md.ts
 function renderAgentsMd(scan) {
-  const commands2 = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
+  const commands = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
   const routes = scan.routes.map((route) => `| ${route.path} | ${route.source} | ${route.confidence}${route.inferred ? " inferred" : ""} |`).join("\n");
   const workspaces = scan.project.workspaces.map((workspace) => `| ${workspace.name} | ${workspace.path} | ${workspace.source} |`).join("\n");
   return `# Project Context
@@ -206,7 +206,7 @@ ${workspaces || "| root | . | inferred |"}
 
 | Name | Command | Source |
 |------|---------|--------|
-${commands2 || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
+${commands || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
 
 ## Structure
 
@@ -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({
@@ -1081,12 +1238,13 @@ async function resolveChangeId(ctx) {
 // src/cli/context.ts
 import { resolve } from "path";
 
-// src/adapters/cursor/index.ts
-import { mkdir as mkdir5, readFile as readFile9, stat as stat5 } from "fs/promises";
-import { dirname as dirname5, join as join10 } from "path";
+// src/adapters/codex/index.ts
+import { mkdir as mkdir6, readFile as readFile12, stat as stat5 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname6, join as join12 } from "path";
 
-// src/adapters/cursor/templates.ts
-var commands = [
+// src/adapters/commands.ts
+var FET_WORKFLOW_COMMANDS = [
   "explore",
   "propose",
   "new",
@@ -1099,8 +1257,683 @@ var commands = [
   "bulk-archive",
   "onboard"
 ];
+var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, "fill-context", "passthrough"];
+
+// src/adapters/codex/templates.ts
+function codexGuideFile() {
+  return {
+    path: ".codex/fet/context.md",
+    content: `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+FET:END -->
+
+# FET For Codex
+
+Before doing FET or OpenSpec work in Codex, read:
+
+- AGENTS.md
+- openspec/config.yaml
+- the active change files under openspec/changes/<change-id>/, when a change is selected
+
+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/.
+`
+  };
+}
+function codexCommandFiles() {
+  return FET_ADAPTER_COMMANDS.map((command) => ({
+    path: `.codex/fet/commands/${command}.md`,
+    content: renderCommand(command)
+  }));
+}
+function codexSlashPromptFiles() {
+  return FET_ADAPTER_COMMANDS.map((command) => ({
+    path: `prompts/fet-${command}.md`,
+    content: renderSlashPrompt(command)
+  }));
+}
+function renderCommand(command) {
+  if (command === "fill-context") {
+    return renderFillContextCommand();
+  }
+  if (command === "passthrough") {
+    return renderPassthroughCommand();
+  }
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: fet ${command}
+FET:END -->
+
+# fet ${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.
+
+Then run:
+
+\`\`\`sh
+fet ${command}
+\`\`\`
+
+If the command needs a change id, pass it with \`--change <change-id>\` or use the active OpenSpec change from the user's request.
+
+After the command completes, report the important next steps from the FET output and keep any generated OpenSpec artifacts in the normal project workflow.
+`;
+}
+function renderPassthroughCommand() {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: fet passthrough <openspec-command>
+FET:END -->
+
+# fet 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.
+
+Then run:
+
+\`\`\`sh
+fet passthrough <openspec-command> [...args]
+\`\`\`
+
+This preserves the FET entry point while allowing access to unmanaged or newly added OpenSpec commands. Passthrough does not update FET lifecycle state.
+`;
+}
+function renderSlashPrompt(command) {
+  if (command === "continue") {
+    return renderContinueSlashPrompt();
+  }
+  if (command === "ff" || command === "propose") {
+    return renderFastForwardSlashPrompt(command);
+  }
+  if (command === "explore") {
+    return renderExploreSlashPrompt();
+  }
+  if (command === "new") {
+    return renderNewSlashPrompt();
+  }
+  if (command === "apply") {
+    return renderApplySlashPrompt();
+  }
+  if (command === "verify") {
+    return renderVerifySlashPrompt();
+  }
+  if (command === "sync") {
+    return renderSyncSlashPrompt();
+  }
+  if (command === "archive") {
+    return renderArchiveSlashPrompt();
+  }
+  if (command === "bulk-archive") {
+    return renderBulkArchiveSlashPrompt();
+  }
+  if (command === "onboard") {
+    return renderOnboardSlashPrompt();
+  }
+  if (command === "fill-context") {
+    return renderFillContextSlashPrompt();
+  }
+  if (command === "passthrough") {
+    return renderPassthroughSlashPrompt();
+  }
+  const usage = command === "passthrough" ? "fet passthrough <openspec-command> [...args]" : `fet ${command} [...args]`;
+  const shellCommand = command === "passthrough" ? "fet passthrough $ARGUMENTS" : `fet ${command} $ARGUMENTS`;
+  const description = command === "passthrough" ? "Run an unmanaged OpenSpec command through FET passthrough" : `Run the FET-managed OpenSpec ${command} workflow`;
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: ${usage}
+FET:END -->
+
+---
+description: ${description}
+argument-hint: command arguments
+---
+
+Use FET as the entry point for this OpenSpec workflow.
+
+Before running the command, make sure the relevant project context is loaded from AGENTS.md and openspec/config.yaml. If a change id is needed and was not provided, infer it from the active FET/OpenSpec state when unambiguous; otherwise ask the user for the change id.
+
+Run:
+
+\`\`\`sh
+${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]",
+    "Create a new FET/OpenSpec change scaffold",
+    `Create a new FET-managed OpenSpec change scaffold.
+
+Input after the slash command should be a kebab-case change id or a short description.
+
+Steps:
+
+1. Load project context from AGENTS.md and openspec/config.yaml.
+2. If no input was provided, ask what change the user wants to build or fix.
+3. Derive a kebab-case change id when the user provided a description.
+4. Create the change through FET:
+   \`\`\`sh
+   fet new <change-id>
+   \`\`\`
+5. Show current artifact status:
+   \`\`\`sh
+   fet passthrough status --change <change-id>
+   \`\`\`
+6. Get the first ready artifact instructions:
+   \`\`\`sh
+   fet continue <first-ready-artifact-id> --change <change-id>
+   \`\`\`
+
+Guardrails:
+- Do not create artifact files in /prompts:fet-new.
+- If the change already exists, suggest /prompts:fet-continue <change-id>.
+- Show the change location and the next command to create the first artifact.`
+  );
+}
+function renderApplySlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet apply [...args]",
+    "Implement tasks from a FET/OpenSpec change",
+    `Implement a FET-managed OpenSpec change.
+
+Input after the slash command should identify the change, for example a change id or --change <change-id>.
+
+Steps:
+
+1. Resolve the change id. If ambiguous, ask the user.
+2. Run the native OpenSpec apply flow through FET:
+   \`\`\`sh
+   fet apply --change <change-id> --json
+   \`\`\`
+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.
+   - Follow proposal, specs, design, and tasks.
+   - Mark each completed task checkbox in tasks.md from \`- [ ]\` to \`- [x]\`.
+   - Pause and ask if a task is ambiguous or reveals a design conflict.
+6. After completing or pausing, summarize completed tasks, remaining tasks, and blockers.
+
+Guardrails:
+- Never skip reading OpenSpec artifacts before implementation.
+- Do not mark a task complete until the code change is actually done.
+- Do not run sync or archive from apply.`
+  );
+}
+function renderVerifySlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet verify [...args]",
+    "Verify a FET/OpenSpec change before sync or archive",
+    `Verify a FET-managed OpenSpec change.
+
+Input after the slash command should identify the change. If the user passes --done, declare verification complete only after checks have been performed or explicitly accepted by the user.
+
+Steps:
+
+1. Resolve the change id. If ambiguous, ask the user.
+2. Generate FET verification instructions:
+   \`\`\`sh
+   fet verify --change <change-id>
+   \`\`\`
+3. Read openspec/changes/<change-id>/.fet/verify-instructions.md.
+4. Read available artifacts for the change: proposal.md, design.md, tasks.md, and delta specs.
+5. Verify:
+   - Completeness: tasks and required artifacts are present and checked off where appropriate.
+   - Correctness: implementation evidence matches specs and proposal.
+   - Coherence: code follows design decisions and project patterns.
+6. Report critical issues, warnings, and suggestions with file references.
+7. If there are no critical issues, or the user explicitly accepts the remaining risk, mark FET verification done:
+   \`\`\`sh
+   fet verify --done --change <change-id>
+   \`\`\`
+
+Guardrails:
+- Do not run --done before producing a verification assessment.
+- Treat incomplete tasks or missing required behavior as critical unless user explicitly accepts them.
+- Suggest /prompts:fet-sync <change-id> and /prompts:fet-archive <change-id> only after verification is done.`
+  );
+}
+function renderSyncSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet sync [...args]",
+    "Sync delta specs and validate a FET/OpenSpec change",
+    `Sync a FET-managed OpenSpec change.
+
+Input after the slash command should identify the change.
+
+Steps:
+
+1. Resolve the change id. If ambiguous, ask the user.
+2. Confirm FET verification is complete or run /prompts:fet-verify <change-id> first.
+3. Find delta specs under openspec/changes/<change-id>/specs/*/spec.md.
+4. If delta specs exist, intelligently merge them into openspec/specs/<capability>/spec.md:
+   - Add ADDED requirements.
+   - Apply MODIFIED requirements without deleting unrelated existing scenarios.
+   - Remove REMOVED requirements.
+   - Apply RENAMED requirements.
+   - Preserve main-spec content not mentioned in the delta.
+5. If no delta specs exist, state that there is nothing to merge.
+6. Run the FET sync gate and strict OpenSpec validation:
+   \`\`\`sh
+   fet sync --change <change-id>
+   \`\`\`
+7. Summarize updated capabilities and validation result.
+
+Guardrails:
+- Read both delta and main specs before editing.
+- Make sync idempotent where possible.
+- If FET reports verify is not done, stop and run/ask for verification instead of bypassing the gate.`
+  );
+}
+function renderArchiveSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet archive [...args]",
+    "Archive a verified FET/OpenSpec change",
+    `Archive a FET-managed OpenSpec change.
+
+Input after the slash command should identify the change.
+
+Steps:
+
+1. Resolve the change id. If ambiguous, ask the user.
+2. Check artifact and task status:
+   \`\`\`sh
+   fet passthrough status --change <change-id> --json
+   \`\`\`
+3. If tasks or required artifacts are incomplete, show the warning and ask whether to continue.
+4. If delta specs exist, assess whether they have been synced. If not, recommend /prompts:fet-sync <change-id> before archiving.
+5. Confirm FET verification is complete. If not, run or suggest /prompts:fet-verify <change-id>.
+6. Archive through FET:
+   \`\`\`sh
+   fet archive --change <change-id>
+   \`\`\`
+7. Report archive result, sync status, and any warnings.
+
+Guardrails:
+- Do not move change directories manually; use fet archive.
+- Do not bypass the FET verify gate.
+- Ask before archiving with incomplete tasks or unsynced delta specs.`
+  );
+}
+function renderBulkArchiveSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet bulk-archive [...args]",
+    "Archive multiple FET/OpenSpec changes safely",
+    `Bulk archive FET-managed OpenSpec changes.
+
+Steps:
+
+1. List active changes:
+   \`\`\`sh
+   fet passthrough status --json
+   \`\`\`
+2. Ask the user which changes to archive. Do not auto-select.
+3. For each selected change:
+   - Check artifact/task status.
+   - Confirm verification is done.
+   - Recommend sync if delta specs are unsynced.
+   - Run \`fet archive --change <change-id>\`.
+4. If \`fet bulk-archive\` reports that the current OpenSpec version does not support a native bulk command, archive selected changes one by one through \`fet archive --change <change-id>\`.
+5. Summarize successes, skipped changes, and failures.
+
+Guardrails:
+- Never archive all changes without explicit user selection.
+- Do not bypass verify or warnings for individual changes.
+- Continue with remaining selected changes if one archive fails, then report the failure clearly.`
+  );
+}
+function renderOnboardSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet onboard [...args]",
+    "Load FET/OpenSpec onboarding context",
+    `Onboard the user or Codex into the FET/OpenSpec workflow for this project.
+
+Steps:
+
+1. Read AGENTS.md and openspec/config.yaml.
+2. Run FET onboarding:
+   \`\`\`sh
+   fet onboard $ARGUMENTS
+   \`\`\`
+3. Summarize:
+   - Project context.
+   - Available active changes.
+   - Core commands: new, continue, ff, apply, verify, sync, archive.
+   - Where Codex prompts live.
+
+Guardrails:
+- Do not create or modify artifacts during onboard.
+- Use this command to orient the session, then suggest the next concrete FET command.`
+  );
+}
+function renderPassthroughSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet passthrough <openspec-command> [...args]",
+    "Run an unmanaged OpenSpec command through FET",
+    `Run an OpenSpec command that FET does not manage as a first-class workflow command.
+
+Steps:
+
+1. Identify the OpenSpec command and arguments from the user's input.
+2. Run it through FET:
+   \`\`\`sh
+   fet passthrough <openspec-command> [...args]
+   \`\`\`
+3. Report the output and whether FET lifecycle state was updated.
+
+Guardrails:
+- Do not call openspec directly unless FET passthrough itself is unavailable.
+- Remember that passthrough does not update FET lifecycle state.
+- For managed workflows, prefer the specific FET prompt instead of passthrough.`
+  );
+}
+function renderExploreSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet explore [...args]",
+    "Explore requirements for a FET/OpenSpec change",
+    `Enter exploration mode for a FET-managed OpenSpec change.
+
+Use this command for thinking and proposal shaping, not application implementation.
+
+Input after the slash command may be a change id, a feature idea, or a problem description.
+
+Steps:
+
+1. Load project context from AGENTS.md and openspec/config.yaml.
+2. Check existing changes:
+   \`\`\`sh
+   fet passthrough status --json
+   \`\`\`
+3. If the input names an existing change, read its current artifacts under openspec/changes/<change-id>/.
+4. If the input is a new idea and the user wants to capture it, derive a kebab-case change id and create the change:
+   \`\`\`sh
+   fet new <change-id>
+   \`\`\`
+5. Run the native OpenSpec exploration flow through FET so clarification prompts stay interactive:
+   \`\`\`sh
+   fet explore --change <change-id>
+   \`\`\`
+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.
+- Ask a clarifying question if the proposal would otherwise be mostly guesswork.
+- Creating or updating OpenSpec artifacts is allowed when the user asks to capture the thinking.
+- After creating proposal.md, show the path and suggest /prompts:fet-continue <change-id> for the next artifact.`
+  );
+}
+function renderContinueSlashPrompt() {
+  return renderManagedSlashPrompt(
+    "fet continue [...args]",
+    "Create the next FET/OpenSpec artifact",
+    `Continue a FET-managed OpenSpec change by creating exactly one ready artifact.
+
+Input after the slash command should be a change id, optionally followed by an artifact id.
+
+Steps:
+
+1. Load project context from AGENTS.md and openspec/config.yaml.
+2. Resolve the change id. If it is missing and cannot be inferred unambiguously, ask the user.
+3. Check status:
+   \`\`\`sh
+   fet passthrough status --change <change-id> --json
+   \`\`\`
+4. Pick the first artifact whose status is ready, unless the user specified an artifact id.
+5. Run the native OpenSpec continue flow through FET:
+   \`\`\`sh
+   fet continue <artifact-id> --change <change-id> --json
+   \`\`\`
+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:
+   \`\`\`sh
+   fet passthrough status --change <change-id>
+   \`\`\`
+
+Output:
+- State which artifact was created.
+- Show the file path.
+- Show the current status and what to run next.
+
+Guardrails:
+- Create one artifact per invocation.
+- Never skip dependency order.
+- Ask the user if instructions are ambiguous enough that a useful artifact cannot be written.`
+  );
+}
+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",
+    `${title}.
+
+Input after the slash command may be a change id or a description of what the user wants to build.
+
+Steps:
+
+1. Load project context from AGENTS.md and openspec/config.yaml.
+2. Resolve the change id or description. If ambiguous, ask the user.
+3. Run the native OpenSpec ${command} flow through FET:
+   \`\`\`sh
+   ${commandLine}
+   \`\`\`
+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.
+- Use template as structure, filling it with concrete project-specific content.
+- Do not copy context/rules wrapper text into artifact files.
+- Verify each file exists after writing.
+
+Output:
+- Change id and location.
+- Artifacts created.
+- Current status.
+- Next recommended command, usually /prompts:fet-apply <change-id>.`
+  );
+}
+function renderManagedSlashPrompt(command, description, body) {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+command: ${command}
+FET:END -->
+
+---
+description: ${description}
+argument-hint: command arguments
+---
+
+${body}
+`;
+}
+
+// src/adapters/codex/index.ts
+var CodexAdapter = class {
+  tool = "codex";
+  adapterVersion = 1;
+  async detect(projectRoot) {
+    return {
+      detected: await exists3(join12(projectRoot, ".codex")) || await exists3(join12(projectRoot, "AGENTS.md")),
+      reason: "Codex adapter is available for projects that use AGENTS.md"
+    };
+  }
+  async planInstall(_projectRoot) {
+    return {
+      tool: this.tool,
+      files: [
+        ...[codexGuideFile(), ...codexCommandFiles()].map((file) => ({
+          ...file,
+          managed: true,
+          root: "project"
+        })),
+        ...codexSlashPromptFiles().map((file) => ({
+          ...file,
+          managed: true,
+          root: "codex-home"
+        }))
+      ]
+    };
+  }
+  async install(projectRoot, plan, force = false) {
+    const written = [];
+    const skipped = [];
+    for (const file of plan.files) {
+      const target = resolveTarget(projectRoot, file);
+      const displayPath = displayPathFor(file);
+      const existing = await readExisting(target);
+      if (existing && !existing.includes("FET:MANAGED") && !force) {
+        throw new FetError({
+          code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
+          message: "Codex adapter file already exists and is not managed by FET",
+          details: { path: displayPath },
+          suggestedCommand: "fet init --yes"
+        });
+      }
+      if (existing && !existing.includes("FET:MANAGED") && force) {
+        await createBackup(target);
+      }
+      await mkdir6(dirname6(target), { recursive: true });
+      await atomicWrite(target, file.content);
+      written.push(displayPath);
+    }
+    return { tool: this.tool, written, skipped };
+  }
+  async doctor(projectRoot) {
+    const plan = await this.planInstall(projectRoot);
+    const checks = [];
+    for (const file of plan.files) {
+      const target = resolveTarget(projectRoot, file);
+      const displayPath = displayPathFor(file);
+      const content = await readExisting(target);
+      const managed = Boolean(content?.includes("FET:MANAGED"));
+      const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
+      checks.push({
+        id: `codex:${displayPath}`,
+        status: !content ? "warn" : managed && versionMatches ? "pass" : "warn",
+        message: !content ? `${displayPath} is missing` : !managed ? `${displayPath} exists but is not managed by FET` : !versionMatches ? `${displayPath} adapterVersion is stale` : `${displayPath} is managed by FET`,
+        suggestedCommand: !content || !managed || !versionMatches ? "fet init" : void 0
+      });
+    }
+    return checks;
+  }
+};
+function resolveTarget(projectRoot, file) {
+  if (file.root === "codex-home") {
+    return join12(resolveCodexHome(), file.path);
+  }
+  return join12(projectRoot, file.path);
+}
+function displayPathFor(file) {
+  if (file.root === "codex-home") {
+    return `$CODEX_HOME/${file.path.replaceAll("\\", "/")}`;
+  }
+  return file.path;
+}
+function resolveCodexHome() {
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join12(homedir(), ".codex");
+}
+async function readExisting(path) {
+  try {
+    return await readFile12(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists3(path) {
+  try {
+    await stat5(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/cursor/index.ts
+import { mkdir as mkdir7, readFile as readFile13, stat as stat6 } from "fs/promises";
+import { dirname as dirname7, join as join13 } from "path";
+
+// src/adapters/cursor/templates.ts
 function cursorSkillFiles() {
-  return commands.map((command) => ({
+  return FET_ADAPTER_COMMANDS.map((command) => ({
     path: `.cursor/skills/fet-${command}/SKILL.md`,
     content: renderSkill(command)
   }));
@@ -1131,12 +1964,38 @@ 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}
 generator: cursor-adapter
 adapterVersion: 1
-command: fet ${command}
+command: ${usage}
 FET:END -->
 
 ---
@@ -1150,7 +2009,7 @@ disable-model-invocation: true
 \u8BF7\u5728\u7EC8\u7AEF\u4E2D\u6267\u884C\uFF1A
 
 \`\`\`sh
-fet ${command}
+${usage}
 \`\`\`
 
 \u6267\u884C\u524D\u8BF7\u786E\u8BA4\u5DF2\u9605\u8BFB AGENTS.md \u4E0E openspec/config.yaml\u3002
@@ -1163,7 +2022,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists3(join10(projectRoot, ".cursor")),
+      detected: await exists4(join13(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -1180,8 +2039,8 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join10(projectRoot, file.path);
-      const existing = await readExisting(target);
+      const target = join13(projectRoot, file.path);
+      const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
           code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
@@ -1193,7 +2052,7 @@ var CursorAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && force) {
         await createBackup(target);
       }
-      await mkdir5(dirname5(target), { recursive: true });
+      await mkdir7(dirname7(target), { recursive: true });
       await atomicWrite(target, file.content);
       written.push(file.path);
     }
@@ -1203,8 +2062,8 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join10(projectRoot, file.path);
-      const content = await readExisting(target);
+      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}`));
       checks.push({
@@ -1217,16 +2076,16 @@ var CursorAdapter = class {
     return checks;
   }
 };
-async function readExisting(path) {
+async function readExisting2(path) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists3(path) {
+async function exists4(path) {
   try {
-    await stat5(path);
+    await stat6(path);
     return true;
   } catch {
     return false;
@@ -1238,43 +2097,45 @@ import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
 
 // src/openspec/inspector.ts
-import { readdir, stat as stat6 } from "fs/promises";
-import { join as join11 } from "path";
+import { readdir, stat as stat7 } from "fs/promises";
+import { join as join14 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join11(projectRoot, "openspec");
-  const changesPath = join11(openspecPath, "changes");
-  const archivePath = join11(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 exists4(openspecPath),
-    changes: await listDirectories(changesPath),
-    archived: await listDirectories(archivePath)
+    exists: await exists5(openspecPath),
+    changes: await listDirectories(changesPath, { exclude: ["archive"] }),
+    archived: [.../* @__PURE__ */ new Set([...await listDirectories(legacyArchivePath), ...await listDirectories(changesArchivePath)])]
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join11(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join11(changePath, "tasks.md");
-  const specsPath = join11(changePath, "specs");
+  const changePath = join14(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join14(changePath, "tasks.md");
+  const specsPath = join14(changePath, "specs");
   return {
     changeId,
-    exists: await exists4(changePath),
-    hasProposal: await exists4(join11(changePath, "proposal.md")),
-    hasTasks: await exists4(tasksPath),
-    hasSpecs: await exists4(specsPath),
+    exists: await exists5(changePath),
+    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 [];
   }
 }
-async function exists4(path) {
+async function exists5(path) {
   try {
-    await stat6(path);
+    await stat7(path);
     return true;
   } catch {
     return false;
@@ -1433,12 +2294,12 @@ function parseCommands(help) {
 }
 
 // src/scanner/package.ts
-import { readFile as readFile10, stat as stat7 } from "fs/promises";
-import { join as join12 } 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 readFile10(join12(projectRoot, "package.json"), "utf8"));
+    return JSON.parse(await readFile14(join15(projectRoot, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -1504,7 +2365,7 @@ function detectFramework(pkg) {
 }
 async function detectLanguage(projectRoot, pkg) {
   const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  if (deps.typescript || await exists5(join12(projectRoot, "tsconfig.json"))) {
+  if (deps.typescript || await exists6(join15(projectRoot, "tsconfig.json"))) {
     return "typescript";
   }
   return "javascript";
@@ -1519,7 +2380,7 @@ async function detectWorkspaces(projectRoot, pkg) {
     return packageWorkspaces;
   }
   try {
-    const workspace = parse2(await readFile10(join12(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    const workspace = parse2(await readFile14(join15(projectRoot, "pnpm-workspace.yaml"), "utf8"));
     return (workspace?.packages ?? []).map((path) => ({
       name: path,
       path,
@@ -1539,7 +2400,7 @@ async function detectLockManagers(projectRoot) {
   ];
   const found = [];
   for (const [file, manager] of lockFiles) {
-    if (await exists5(join12(projectRoot, file))) {
+    if (await exists6(join15(projectRoot, file))) {
       found.push(manager);
     }
   }
@@ -1554,9 +2415,9 @@ function normalizeWorkspaces(workspaces) {
 function scriptCommand(packageManager, name) {
   return packageManager === "npm" ? `npm run ${name}` : `${packageManager} ${name}`;
 }
-async function exists5(path) {
+async function exists6(path) {
   try {
-    await stat7(path);
+    await stat8(path);
     return true;
   } catch {
     return false;
@@ -1564,14 +2425,14 @@ async function exists5(path) {
 }
 
 // src/scanner/routes.ts
-import { readdir as readdir2, stat as stat8 } from "fs/promises";
-import { join as join13, relative, sep } from "path";
+import { readdir as readdir2, stat as stat9 } from "fs/promises";
+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 = join13(projectRoot, candidate);
-    if (!await exists6(root)) {
+    const root = join16(projectRoot, candidate);
+    if (!await exists7(root)) {
       continue;
     }
     for (const file of await listFiles(root)) {
@@ -1598,7 +2459,7 @@ async function listFiles(root) {
   const entries = await readdir2(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join13(root, entry.name);
+    const path = join16(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -1607,9 +2468,9 @@ async function listFiles(root) {
   }
   return files;
 }
-async function exists6(path) {
+async function exists7(path) {
   try {
-    await stat8(path);
+    await stat9(path);
     return true;
   } catch {
     return false;
@@ -1741,7 +2602,7 @@ async function createCommandContext(command, options) {
     stateStore: new StateStore(projectRoot, FET_VERSION, project),
     openSpec: new DefaultOpenSpecAdapter(),
     scanner: new ProjectScanner(),
-    toolAdapters: [new CursorAdapter()]
+    toolAdapters: [new CursorAdapter(), new CodexAdapter()]
   };
 }
 
@@ -1750,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) }))
 );