@nick848/fet 1.0.1 → 1.0.2

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
 
@@ -1081,12 +1081,13 @@ async function resolveChangeId(ctx) {
 // src/cli/context.ts
 import { resolve } from "path";
 
-// src/adapters/cursor/index.ts
+// src/adapters/codex/index.ts
 import { mkdir as mkdir5, readFile as readFile9, stat as stat5 } from "fs/promises";
+import { homedir } from "os";
 import { dirname as dirname5, join as join10 } from "path";
 
-// src/adapters/cursor/templates.ts
-var commands = [
+// src/adapters/commands.ts
+var FET_WORKFLOW_COMMANDS = [
   "explore",
   "propose",
   "new",
@@ -1099,8 +1100,629 @@ var commands = [
   "bulk-archive",
   "onboard"
 ];
+var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, "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 === "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 === "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 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. Get FET-managed apply instructions:
+   \`\`\`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>/.
+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. Get proposal instructions through FET:
+   \`\`\`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.
+
+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. Get FET-managed instructions:
+   \`\`\`sh
+   fet continue <artifact-id> --change <change-id> --json
+   \`\`\`
+6. Parse the instructions output. Use its template, instruction, dependencies, and outputPath.
+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";
+  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 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:
+   \`\`\`sh
+   fet passthrough status --change <change-id> --json
+   \`\`\`
+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.
+
+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(join10(projectRoot, ".codex")) || await exists3(join10(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 mkdir5(dirname5(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 join10(resolveCodexHome(), file.path);
+  }
+  return join10(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 ?? join10(homedir(), ".codex");
+}
+async function readExisting(path) {
+  try {
+    return await readFile9(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 mkdir6, readFile as readFile10, stat as stat6 } from "fs/promises";
+import { dirname as dirname6, join as join11 } 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 +1753,13 @@ alwaysApply: false
   };
 }
 function renderSkill(command) {
+  const usage = command === "passthrough" ? "fet passthrough <openspec-command> [...args]" : `fet ${command}`;
   return `<!-- FET:MANAGED
 schemaVersion: 1
 fetVersion: ${FET_VERSION}
 generator: cursor-adapter
 adapterVersion: 1
-command: fet ${command}
+command: ${usage}
 FET:END -->
 
 ---
@@ -1150,7 +1773,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 +1786,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists3(join10(projectRoot, ".cursor")),
+      detected: await exists4(join11(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -1180,8 +1803,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 = join11(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 +1816,7 @@ var CursorAdapter = 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(file.path);
     }
@@ -1203,8 +1826,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 = join11(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 +1840,16 @@ var CursorAdapter = class {
     return checks;
   }
 };
-async function readExisting(path) {
+async function readExisting2(path) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile10(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,28 +1861,28 @@ 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 join12 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join11(projectRoot, "openspec");
-  const changesPath = join11(openspecPath, "changes");
-  const archivePath = join11(openspecPath, "archive");
+  const openspecPath = join12(projectRoot, "openspec");
+  const changesPath = join12(openspecPath, "changes");
+  const archivePath = join12(openspecPath, "archive");
   return {
-    exists: await exists4(openspecPath),
+    exists: await exists5(openspecPath),
     changes: await listDirectories(changesPath),
     archived: await listDirectories(archivePath)
   };
 }
 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 = join12(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join12(changePath, "tasks.md");
+  const specsPath = join12(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(join12(changePath, "proposal.md")),
+    hasTasks: await exists5(tasksPath),
+    hasSpecs: await exists5(specsPath),
     tasksPath,
     changePath
   };
@@ -1272,9 +1895,9 @@ async function listDirectories(path) {
     return [];
   }
 }
-async function exists4(path) {
+async function exists5(path) {
   try {
-    await stat6(path);
+    await stat7(path);
     return true;
   } catch {
     return false;
@@ -1433,12 +2056,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 readFile11, stat as stat8 } from "fs/promises";
+import { join as join13 } 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 readFile11(join13(projectRoot, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -1504,7 +2127,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(join13(projectRoot, "tsconfig.json"))) {
     return "typescript";
   }
   return "javascript";
@@ -1519,7 +2142,7 @@ async function detectWorkspaces(projectRoot, pkg) {
     return packageWorkspaces;
   }
   try {
-    const workspace = parse2(await readFile10(join12(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    const workspace = parse2(await readFile11(join13(projectRoot, "pnpm-workspace.yaml"), "utf8"));
     return (workspace?.packages ?? []).map((path) => ({
       name: path,
       path,
@@ -1539,7 +2162,7 @@ async function detectLockManagers(projectRoot) {
   ];
   const found = [];
   for (const [file, manager] of lockFiles) {
-    if (await exists5(join12(projectRoot, file))) {
+    if (await exists6(join13(projectRoot, file))) {
       found.push(manager);
     }
   }
@@ -1554,9 +2177,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 +2187,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 join14, 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 = join14(projectRoot, candidate);
+    if (!await exists7(root)) {
       continue;
     }
     for (const file of await listFiles(root)) {
@@ -1598,7 +2221,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 = join14(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -1607,9 +2230,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 +2364,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()]
   };
 }