codealmanac 0.2.5 → 0.2.6

package/dist/{chunk-GFUB57IT.js → chunk-VXDPUOQ5.js}

@@ -1,53 +1,113 @@
 #!/usr/bin/env node
 import {
   runHookInstall
-} from "./chunk-447U3GQJ.js";
+} from "./chunk-PDFS5VFE.js";
 import {
   buildProviderModelChoices,
   buildProviderSetupView,
-  getProviderLabel,
   parseAgentSelection
-} from "./chunk-BGUID5BS.js";
+} from "./chunk-J7DNV2DH.js";
 import {
+  disabledAgentProviderMessage,
+  formatEnabledAgentProviderList,
   isAgentProviderId,
+  isEnabledAgentProviderId,
   readConfig,
   writeConfig
-} from "./chunk-P5WGG4FJ.js";
+} from "./chunk-3E7JNMTZ.js";
+
+// src/agent/providers/codex-instructions.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var CODEX_INSTRUCTIONS_START = "<!-- codealmanac:start -->";
+var CODEX_INSTRUCTIONS_END = "<!-- codealmanac:end -->";
+var CODEX_INSTRUCTIONS_BODY = `${CODEX_INSTRUCTIONS_START}
+## codealmanac
+
+Use codealmanac before answering codebase questions:
+- Search the wiki for relevant context.
+- Read matching pages before making claims about the codebase.
+- Update the wiki when implementation decisions, workflows, invariants, or gotchas change.
+
+${CODEX_INSTRUCTIONS_END}`;
+async function ensureCodexInstructions(codexDir) {
+  await mkdir(codexDir, { recursive: true });
+  const agentsPath = await resolveCodexAgentsPath(codexDir);
+  let existing = "";
+  if (existsSync(agentsPath)) {
+    existing = await readFile(agentsPath, "utf8");
+  }
+  const next = upsertManagedBlock(
+    existing,
+    CODEX_INSTRUCTIONS_START,
+    CODEX_INSTRUCTIONS_END,
+    CODEX_INSTRUCTIONS_BODY
+  );
+  if (next === existing) return false;
+  await writeFile(agentsPath, next, "utf8");
+  return true;
+}
+async function resolveCodexAgentsPath(codexDir) {
+  const overridePath = path.join(codexDir, "AGENTS.override.md");
+  if (existsSync(overridePath)) {
+    try {
+      const body = await readFile(overridePath, "utf8");
+      if (body.trim().length > 0) return overridePath;
+    } catch {
+    }
+  }
+  return path.join(codexDir, "AGENTS.md");
+}
+function hasCodexInstructions(contents) {
+  return contents.includes(CODEX_INSTRUCTIONS_START) && contents.includes(CODEX_INSTRUCTIONS_END);
+}
+function upsertManagedBlock(contents, start, end, block) {
+  const startIndex = contents.indexOf(start);
+  const endIndex = contents.indexOf(end);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const afterEnd = endIndex + end.length;
+    return `${contents.slice(0, startIndex)}${block}${contents.slice(afterEnd)}`;
+  }
+  const sep = contents.length === 0 ? "" : contents.endsWith("\n") ? "\n" : "\n\n";
+  return `${contents}${sep}${block}
+`;
+}
 
 // src/commands/setup.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { spawn } from "child_process";
 import {
   copyFile,
-  mkdir,
-  readFile,
-  writeFile
+  mkdir as mkdir2,
+  readFile as readFile2,
+  writeFile as writeFile2
 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { homedir as homedir2 } from "os";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/setup/install-path.ts
 import { execFile } from "child_process";
 import { createRequire } from "module";
 import { homedir } from "os";
-import path from "path";
+import path2 from "path";
 import { fileURLToPath } from "url";
 function detectCurrentInstallPath() {
   try {
     const req = createRequire(import.meta.url);
     const here = fileURLToPath(import.meta.url);
-    let dir = path.dirname(here);
+    let dir = path2.dirname(here);
     for (let i = 0; i < 6; i++) {
-      const pkgPath = path.join(dir, "package.json");
+      const pkgPath = path2.join(dir, "package.json");
       try {
         const raw = req("fs").readFileSync(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.name === "codealmanac") return dir;
       } catch {
       }
-      const parent = path.dirname(dir);
+      const parent = path2.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -58,8 +118,8 @@ function detectCurrentInstallPath() {
 function detectEphemeral(installPath) {
   if (installPath.length === 0) return false;
   const home = homedir();
-  if (installPath.startsWith(path.join(home, ".npm", "_npx"))) return true;
-  if (installPath.startsWith(path.join(home, ".local", "share", "pnpm", "dlx"))) return true;
+  if (installPath.startsWith(path2.join(home, ".npm", "_npx"))) return true;
+  if (installPath.startsWith(path2.join(home, ".local", "share", "pnpm", "dlx"))) return true;
   if (installPath.startsWith("/tmp/")) return true;
   if (installPath.startsWith("/var/folders/")) return true;
   return false;
@@ -86,8 +146,8 @@ function spawnGlobalInstall() {
 }
 
 // src/commands/setup/next-steps.ts
-import { existsSync, readdirSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import path3 from "path";
 var RST = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
@@ -142,8 +202,8 @@ function countExistingPages(cwd) {
   try {
     let dir = cwd;
     for (let i = 0; i < 10; i++) {
-      const pagesDir = path2.join(dir, ".almanac", "pages");
-      if (existsSync(pagesDir)) {
+      const pagesDir = path3.join(dir, ".almanac", "pages");
+      if (existsSync2(pagesDir)) {
         try {
           const entries = readdirSync(pagesDir);
           return entries.filter((e) => e.endsWith(".md")).length;
@@ -151,7 +211,7 @@ function countExistingPages(cwd) {
           return 0;
         }
       }
-      const parent = path2.dirname(dir);
+      const parent = path3.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -191,7 +251,7 @@ function printBanner(out) {
 `);
   }
   out.write(`
-${WHITE_BOLD2}  Install provider integrations${RST2}
+${WHITE_BOLD2}  Set up your automatic codebase wiki${RST2}
 `);
 }
 function printBadge(out) {
@@ -224,13 +284,25 @@ async function runSetup(options = {}) {
   }
   printBanner(out);
   printBadge(out);
-  const agentChoice = await chooseDefaultAgent({
-    out,
-    interactive,
-    requested: options.agent,
-    requestedModel: options.model,
-    spawnCli: options.spawnCli
-  });
+  let agentChoice;
+  try {
+    agentChoice = await chooseDefaultAgent({
+      out,
+      interactive,
+      requested: options.agent,
+      requestedModel: options.model,
+      spawnCli: options.spawnCli
+    });
+  } catch (err) {
+    if (isSetupInterrupted(err)) {
+      return {
+        stdout: "",
+        stderr: "almanac: setup cancelled\n",
+        exitCode: 130
+      };
+    }
+    throw err;
+  }
   if (!agentChoice.ok) {
     return {
       stdout: "",
@@ -241,7 +313,7 @@ async function runSetup(options = {}) {
   }
   stepDone(
     out,
-    `Default provider: ${WHITE_BOLD2}${agentChoice.provider}${RST2} (${agentChoice.model ?? "provider default"})`
+    `Agent: ${WHITE_BOLD2}${agentChoice.provider}${RST2} (${agentChoice.model ?? "provider default"})`
   );
   out.write(BAR + "\n");
   const ephem = options.installPath !== void 0 ? options.installPath !== null ? detectEphemeral(options.installPath) : false : detectEphemeral(detectCurrentInstallPath());
@@ -281,7 +353,7 @@ async function runSetup(options = {}) {
   } else if (interactive) {
     hookAction = await confirm(
       out,
-      "Install auto-capture hooks for supported agents?",
+      "Keep your codebase wiki up to date automatically?",
       true
     );
   }
@@ -294,27 +366,26 @@ async function runSetup(options = {}) {
       stableHooksDir: options.stableHooksDir
     });
     if (res.exitCode !== 0) {
-      stepActive(out, `Auto-capture hook: ${res.stderr.trim()}`);
+      stepActive(out, `SessionEnd hook: ${res.stderr.trim()}`);
       return {
         stdout: "",
         stderr: res.stderr,
         exitCode: res.exitCode
       };
     }
-    hookResultLine = res.stdout.includes("already installed") ? `Auto-capture hooks ${DIM2}already installed${RST2}` : `Auto-capture hooks installed`;
+    hookResultLine = res.stdout.includes("already installed") ? `Auto-capture hooks ${DIM2}already installed${RST2}` : `Auto-capture installed`;
     stepDone(out, hookResultLine);
   } else {
-    stepSkipped(out, `Auto-capture hooks ${DIM2}skipped${RST2}`);
+    stepSkipped(out, `Auto-capture ${DIM2}skipped${RST2}`);
   }
   out.write(BAR + "\n");
   let guidesAction = "install";
-  const providerLabel = getProviderLabel(agentChoice.provider);
   if (options.skipGuides === true) {
     guidesAction = "skip";
   } else if (interactive) {
     guidesAction = await confirm(
       out,
-      `Install the codealmanac guide for ${providerLabel}?`,
+      "Add codealmanac instructions for your AI agents?",
       true
     );
   }
@@ -322,12 +393,11 @@ async function runSetup(options = {}) {
   if (guidesAction === "install") {
     try {
       const summary = await installGuides({
-        provider: agentChoice.provider,
-        claudeDir: options.claudeDir ?? path3.join(homedir2(), ".claude"),
-        guidesDir: options.guidesDir ?? resolveGuidesDir(),
-        cwd: process.cwd()
+        claudeDir: options.claudeDir ?? path4.join(homedir2(), ".claude"),
+        codexDir: options.codexDir ?? path4.join(homedir2(), ".codex"),
+        guidesDir: options.guidesDir ?? resolveGuidesDir()
       });
-      guidesSummary = summary.anyChanges ? `Guide installed for ${summary.providerLabel} (${summary.filesWritten.join(", ")})` : `Guide for ${summary.providerLabel} ${DIM2}already installed${RST2}`;
+      guidesSummary = summary.anyChanges ? `Agent instructions added` : `Agent instructions ${DIM2}already added${RST2}`;
       stepDone(out, guidesSummary);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -339,14 +409,13 @@ async function runSetup(options = {}) {
       };
     }
   } else {
-    stepSkipped(out, `Guides ${DIM2}skipped${RST2}`);
+    stepSkipped(out, `Agent instructions ${DIM2}skipped${RST2}`);
   }
   out.write(BAR + "\n");
   stepDone(out, `${BLUE2}Setup complete${RST2}`);
   out.write("\n");
   const existingPageCount = countExistingPages(process.cwd());
   printNextSteps(out, existingPageCount);
-  printProviderNextSteps(out);
   return { stdout: "", stderr: "", exitCode: 0 };
 }
 async function chooseDefaultAgent(args) {
@@ -357,34 +426,66 @@ async function chooseDefaultAgent(args) {
     view = await buildProviderSetupView({ config, spawnCli: args.spawnCli });
   }
   if (args.interactive && args.requested === void 0 && view !== null) {
-    args.out.write("  Choose default provider for bootstrap/capture:\n");
-    view.choices.forEach((choice, index) => {
-      const tag = choice.recommended ? " recommended" : "";
-      const status = choice.ready ? "ready" : "not ready";
-      const detail = choice.account ?? choice.fixCommand ?? choice.detail;
-      args.out.write(
-        `    ${index + 1}. ${choice.label.padEnd(6)} ${status.padEnd(9)}${tag}  ${detail}
-`
-      );
-    });
-    selected = (await promptText(
-      args.out,
-      "Default provider",
-      view.recommendedProvider
-    )).toLowerCase();
-    const number = Number.parseInt(selected, 10);
-    if (Number.isInteger(number) && number >= 1 && number <= view.choices.length) {
-      selected = view.choices[number - 1]?.id ?? selected;
+    while (true) {
+      const choice = await selectChoice({
+        out: args.out,
+        title: "Choose your agent",
+        help: "Choose the AI agent codealmanac should use.",
+        choices: view.choices.map((choice2) => ({
+          value: choice2,
+          line: formatProviderChoice(choice2),
+          aliases: [choice2.id, choice2.label.toLowerCase()]
+        })),
+        defaultIndex: Math.max(
+          0,
+          view.choices.findIndex(
+            (choice2) => choice2.id === view?.recommendedProvider
+          )
+        )
+      });
+      if (choice.ready) {
+        selected = choice.id;
+        break;
+      }
+      if (choice.readiness === "not-authenticated" && choice.fixCommand !== null) {
+        const command = choice.fixCommand.startsWith("run: ") ? choice.fixCommand.slice("run: ".length) : choice.fixCommand;
+        const runLogin = await confirm(
+          args.out,
+          `${choice.label} sign-in is needed. Run '${command}' now?`,
+          true
+        );
+        if (runLogin === "install") {
+          const login = await runLoginCommand(command);
+          if (!login.ok) {
+            stepActive(args.out, `${choice.label} login failed: ${login.error}`);
+          }
+          view = await buildProviderSetupView({ config, spawnCli: args.spawnCli });
+          const refreshed = view.choices.find((next) => next.id === choice.id);
+          if (refreshed?.ready === true) {
+            selected = refreshed.id;
+            break;
+          }
+        }
+        continue;
+      }
+      showUnavailableProvider(args.out, choice);
+      await waitForEnter(args.out, "Press Enter to choose a different agent.");
     }
   }
   const parsed = parseAgentSelection(selected);
   if (parsed.provider === null || !isAgentProviderId(parsed.provider)) {
     return {
       ok: false,
-      error: `unknown agent '${selected}'. Expected one of: claude, codex, cursor.`
+      error: `unknown agent '${selected}'. Expected one of: ${formatEnabledAgentProviderList()}.`
     };
   }
   const provider = parsed.provider;
+  if (!isEnabledAgentProviderId(provider)) {
+    return {
+      ok: false,
+      error: disabledAgentProviderMessage(provider)
+    };
+  }
   let selectedChoice = view?.choices.find((choice) => choice.id === provider);
   if (args.interactive && selectedChoice !== void 0 && !selectedChoice.ready && selectedChoice.fixCommand?.startsWith("run: ") === true) {
     const command = selectedChoice.fixCommand.slice("run: ".length);
@@ -403,6 +504,12 @@ async function chooseDefaultAgent(args) {
       }
     }
   }
+  if (selectedChoice !== void 0 && !selectedChoice.ready) {
+    return {
+      ok: false,
+      error: `${selectedChoice.label} is not ready: ${selectedChoice.fixCommand ?? selectedChoice.detail}`
+    };
+  }
   const requestedModel = args.requestedModel ?? parsed.model;
   const model = requestedModel ?? await chooseProviderModel({
     out: args.out,
@@ -422,47 +529,210 @@ async function chooseDefaultAgent(args) {
       }
     }
   });
-  if (!args.interactive || args.requested !== void 0) {
+  if ((!args.interactive || args.requested !== void 0) && selectedChoice !== void 0) {
     const detail = selectedChoice?.ready === true ? "ready" : selectedChoice?.fixCommand ?? selectedChoice?.detail ?? "status unknown";
     stepDone(args.out, `Agent readiness: ${detail}`);
   }
   return { ok: true, provider, model };
 }
 async function chooseProviderModel(args) {
-  const choices = args.choice?.modelChoices ?? buildProviderModelChoices(args.provider, args.configuredModel);
+  const choices = args.choice?.modelChoices ?? await buildProviderModelChoices(args.provider, args.configuredModel);
   const recommended = choices.find((choice) => choice.recommended) ?? choices.find((choice) => choice.source === "provider-default");
   if (!args.interactive) {
     return args.configuredModel ?? recommended?.value ?? null;
   }
-  args.out.write(`  Choose model for ${getProviderLabel(args.provider)}:
-`);
-  choices.forEach((choice, index) => {
-    const marker = choice.recommended ? " recommended" : "";
-    const current = choice.value === args.configuredModel ? " current" : "";
-    args.out.write(
-      `    ${index + 1}. ${choice.label}${marker}${current}
-`
-    );
-  });
   const currentIndex = choices.findIndex(
     (choice) => choice.value === args.configuredModel
   );
   const recommendedIndex = choices.findIndex((choice) => choice.recommended);
-  const defaultIndex = currentIndex >= 0 ? currentIndex + 1 : recommendedIndex >= 0 ? recommendedIndex + 1 : 1;
-  const selected = await promptText(args.out, "Model", String(defaultIndex));
-  const number = Number.parseInt(selected, 10);
-  let modelChoice;
-  if (Number.isInteger(number) && number >= 1 && number <= choices.length) {
-    modelChoice = choices[number - 1];
-  } else {
-    modelChoice = choices.find((choice) => choice.value === selected);
-  }
+  const defaultIndex = Math.max(
+    0,
+    currentIndex >= 0 ? currentIndex : recommendedIndex >= 0 ? recommendedIndex : 0
+  );
+  const modelChoice = await selectChoice({
+    out: args.out,
+    title: `Choose ${providerDisplayName(args.provider)} model`,
+    choices: choices.map((choice) => ({
+      value: choice,
+      line: formatModelChoice(choice, args.configuredModel),
+      aliases: choice.value === null ? ["default", "provider default"] : [String(choice.value)]
+    })),
+    defaultIndex
+  });
   if (modelChoice?.source === "custom") {
-    const custom = await promptText(args.out, "Custom model id", "");
+    const custom = await promptText(args.out, "Model name", "");
     return custom.length > 0 ? custom : recommended?.value ?? null;
   }
   return modelChoice?.value ?? recommended?.value ?? null;
 }
+async function selectChoice(args) {
+  const selected = clampIndex(args.defaultIndex, args.choices.length);
+  if (canUseRawSelect()) {
+    return await selectChoiceRaw({ ...args, defaultIndex: selected });
+  }
+  renderSelect(args.out, {
+    title: args.title,
+    help: args.help,
+    choices: args.choices,
+    selected,
+    raw: false
+  });
+  const answer = await promptText(args.out, "Select", String(selected + 1));
+  const index = Number.parseInt(answer, 10);
+  if (Number.isInteger(index) && index >= 1 && index <= args.choices.length) {
+    return args.choices[index - 1].value;
+  }
+  const normalized = answer.trim().toLowerCase();
+  const matched = args.choices.find(
+    (choice) => choice.aliases?.some((alias) => alias.toLowerCase() === normalized)
+  );
+  return (matched ?? args.choices[selected]).value;
+}
+async function selectChoiceRaw(args) {
+  return new Promise((resolve, reject) => {
+    let selected = args.defaultIndex;
+    let renderedLines = 0;
+    const input = process.stdin;
+    const render = () => {
+      if (renderedLines > 0) {
+        args.out.write(`\x1B[${renderedLines}A\x1B[0J`);
+      }
+      renderedLines = renderSelect(args.out, {
+        title: args.title,
+        help: args.help,
+        choices: args.choices,
+        selected,
+        raw: true
+      });
+    };
+    const cleanup = () => {
+      input.removeListener("data", onData);
+      input.setRawMode?.(false);
+      input.pause();
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString("utf8");
+      if (key === "") {
+        cleanup();
+        args.out.write("\n");
+        reject(new SetupInterruptedError());
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        args.out.write("\n");
+        resolve(args.choices[selected].value);
+        return;
+      }
+      if (key === "\x1B[A") {
+        selected = selected === 0 ? args.choices.length - 1 : selected - 1;
+        render();
+      } else if (key === "\x1B[B") {
+        selected = selected === args.choices.length - 1 ? 0 : selected + 1;
+        render();
+      }
+    };
+    input.setRawMode?.(true);
+    input.resume();
+    input.on("data", onData);
+    render();
+  });
+}
+function renderSelect(out, args) {
+  let lines = 0;
+  out.write(`  ${WHITE_BOLD2}${args.title}${RST2}
+`);
+  lines++;
+  if (args.help !== void 0) {
+    out.write(`  ${DIM2}${args.help}${RST2}
+`);
+    lines++;
+  }
+  out.write("\n");
+  lines++;
+  args.choices.forEach((choice, index) => {
+    const pointer = index === args.selected ? `${BLUE2}\u203A${RST2}` : " ";
+    out.write(`  ${pointer} ${choice.line}
+`);
+    lines++;
+  });
+  const hint = args.raw ? `Use \u2191/\u2193 to move, Enter to select` : `Type a number or name, then press Enter`;
+  out.write(`
+  ${DIM2}${hint}${RST2}
+`);
+  lines += 2;
+  return lines;
+}
+var SetupInterruptedError = class extends Error {
+  constructor() {
+    super("setup interrupted");
+  }
+};
+function isSetupInterrupted(err) {
+  return err instanceof SetupInterruptedError;
+}
+function canUseRawSelect() {
+  const input = process.stdin;
+  return process.stdin.isTTY === true && typeof input.setRawMode === "function";
+}
+function clampIndex(index, length) {
+  if (length <= 0) return 0;
+  if (index < 0) return 0;
+  if (index >= length) return length - 1;
+  return index;
+}
+function formatProviderChoice(choice) {
+  const status = providerStatusLabel(choice);
+  const detail = providerDetailLabel(choice);
+  const tag = choice.recommended ? `  ${DIM2}recommended${RST2}` : "";
+  return `${choice.label.padEnd(8)} ${status.padEnd(15)} ${detail}${tag}`;
+}
+function providerStatusLabel(choice) {
+  if (choice.ready) {
+    return choice.detail === "ANTHROPIC_API_KEY set" ? "API key set" : "signed in";
+  }
+  return choice.readiness === "missing" ? "not installed" : "sign in needed";
+}
+function providerDetailLabel(choice) {
+  if (choice.ready) return choice.account ?? choice.detail;
+  if (choice.fixCommand === null) return choice.detail;
+  return choice.fixCommand.startsWith("run: ") ? choice.fixCommand.slice("run: ".length) : choice.fixCommand;
+}
+function showUnavailableProvider(out, choice) {
+  if (choice.readiness === "missing") {
+    out.write(
+      `
+  ${WHITE_BOLD2}${choice.label} is not installed.${RST2}
+  ${providerDetailLabel(choice)}
+
+`
+    );
+    return;
+  }
+  out.write(
+    `
+  ${WHITE_BOLD2}${choice.label} is not signed in.${RST2}
+  Run: ${providerDetailLabel(choice)}
+
+`
+  );
+}
+function formatModelChoice(choice, configuredModel) {
+  const marker = choice.recommended ? `  ${DIM2}recommended${RST2}` : choice.value === configuredModel ? `  ${DIM2}current${RST2}` : "";
+  const label = choice.source === "provider-default" && choice.value !== null ? friendlyModelLabel(choice.value) : choice.label;
+  return `${label}${marker}`;
+}
+function friendlyModelLabel(value) {
+  if (value === "claude-sonnet-4-6") return "Sonnet 4.6";
+  if (value === "claude-opus-4-7") return "Opus 4.7";
+  if (value === "claude-haiku-4-5-20251001") return "Haiku 4.5";
+  return value;
+}
+function providerDisplayName(provider) {
+  if (provider === "claude") return "Claude";
+  if (provider === "codex") return "Codex";
+  return "Cursor";
+}
 async function runLoginCommand(command) {
   return new Promise((resolve) => {
     const child = spawn(command, {
@@ -481,83 +751,35 @@ async function runLoginCommand(command) {
     });
   });
 }
-var CODEX_BLOCK_START = "<!-- codealmanac:start -->";
-var CODEX_BLOCK_END = "<!-- codealmanac:end -->";
 async function installGuides(options) {
-  const srcMini = path3.join(options.guidesDir, "mini.md");
-  const srcRef = path3.join(options.guidesDir, "reference.md");
-  if (!existsSync2(srcMini)) {
+  await mkdir2(options.claudeDir, { recursive: true });
+  const srcMini = path4.join(options.guidesDir, "mini.md");
+  const srcRef = path4.join(options.guidesDir, "reference.md");
+  if (!existsSync3(srcMini)) {
     throw new Error(`missing bundled guide: ${srcMini}`);
   }
-  if (!existsSync2(srcRef)) {
+  if (!existsSync3(srcRef)) {
     throw new Error(`missing bundled guide: ${srcRef}`);
   }
-  switch (options.provider) {
-    case "claude":
-      return await installClaudeGuides(options, srcMini, srcRef);
-    case "codex":
-      return await installCodexGuides(srcMini, srcRef);
-    case "cursor":
-      return await installCursorGuides(options.cwd, srcMini);
-  }
-}
-async function installClaudeGuides(options, srcMini, srcRef) {
-  await mkdir(options.claudeDir, { recursive: true });
-  const destMini = path3.join(options.claudeDir, "codealmanac.md");
-  const destRef = path3.join(options.claudeDir, "codealmanac-reference.md");
+  const destMini = path4.join(options.claudeDir, "codealmanac.md");
+  const destRef = path4.join(options.claudeDir, "codealmanac-reference.md");
   const miniChanged = await copyIfChanged(srcMini, destMini);
   const refChanged = await copyIfChanged(srcRef, destRef);
-  const claudeMd = path3.join(options.claudeDir, "CLAUDE.md");
+  const claudeMd = path4.join(options.claudeDir, "CLAUDE.md");
   const importChanged = await ensureImport(claudeMd);
+  const codexChanged = await ensureCodexInstructions(options.codexDir);
   const filesWritten = [];
   if (miniChanged) filesWritten.push("codealmanac.md");
   if (refChanged) filesWritten.push("codealmanac-reference.md");
   if (importChanged) filesWritten.push("CLAUDE.md");
-  return {
-    providerLabel: "Claude",
-    anyChanges: filesWritten.length > 0,
-    filesWritten
-  };
-}
-async function installCodexGuides(srcMini, srcRef) {
-  const codexDir = path3.join(homedir2(), ".codex");
-  await mkdir(codexDir, { recursive: true });
-  const destMini = path3.join(codexDir, "codealmanac.md");
-  const destRef = path3.join(codexDir, "codealmanac-reference.md");
-  const miniChanged = await copyIfChanged(srcMini, destMini);
-  const refChanged = await copyIfChanged(srcRef, destRef);
-  const agentsChanged = await ensureManagedBlock(
-    path3.join(codexDir, "AGENTS.md"),
-    codexGuideBlock()
-  );
-  const filesWritten = [];
-  if (miniChanged) filesWritten.push("codealmanac.md");
-  if (refChanged) filesWritten.push("codealmanac-reference.md");
-  if (agentsChanged) filesWritten.push("AGENTS.md");
-  return {
-    providerLabel: "Codex",
-    anyChanges: filesWritten.length > 0,
-    filesWritten
-  };
-}
-async function installCursorGuides(cwd, srcMini) {
-  const rulesDir = path3.join(cwd, ".cursor", "rules");
-  await mkdir(rulesDir, { recursive: true });
-  const mini = await readFile(srcMini, "utf8");
-  const dest = path3.join(rulesDir, "codealmanac.mdc");
-  const body = "---\ndescription: Use codealmanac wiki context during coding work\nalwaysApply: true\n---\n\n" + mini;
-  const changed = await writeIfChanged(dest, body);
-  return {
-    providerLabel: "Cursor",
-    anyChanges: changed,
-    filesWritten: changed ? [".cursor/rules/codealmanac.mdc"] : []
-  };
+  if (codexChanged) filesWritten.push("AGENTS.md");
+  return { anyChanges: filesWritten.length > 0, filesWritten };
 }
 async function copyIfChanged(src, dest) {
-  const srcBytes = await readFile(src);
-  if (existsSync2(dest)) {
+  const srcBytes = await readFile2(src);
+  if (existsSync3(dest)) {
     try {
-      const destBytes = await readFile(dest);
+      const destBytes = await readFile2(dest);
       if (srcBytes.equals(destBytes)) return false;
     } catch {
     }
@@ -565,56 +787,17 @@ async function copyIfChanged(src, dest) {
   await copyFile(src, dest);
   return true;
 }
-async function writeIfChanged(dest, body) {
-  if (existsSync2(dest)) {
-    try {
-      if (await readFile(dest, "utf8") === body) return false;
-    } catch {
-    }
-  }
-  await writeFile(dest, body, "utf8");
-  return true;
-}
-async function ensureManagedBlock(file, block) {
-  let existing = "";
-  if (existsSync2(file)) existing = await readFile(file, "utf8");
-  const pattern = new RegExp(
-    `${escapeRegex(CODEX_BLOCK_START)}[\\s\\S]*?${escapeRegex(CODEX_BLOCK_END)}`
-  );
-  const next = pattern.test(existing) ? existing.replace(pattern, block.trimEnd()) : `${existing.trimEnd()}${existing.trim().length > 0 ? "\n\n" : ""}${block.trimEnd()}
-`;
-  const normalized = next.endsWith("\n") ? next : `${next}
-`;
-  if (normalized === existing) return false;
-  await writeFile(file, normalized, "utf8");
-  return true;
-}
-function codexGuideBlock() {
-  return [
-    CODEX_BLOCK_START,
-    "# codealmanac",
-    "",
-    "This machine has codealmanac installed: a local wiki for codebases.",
-    "Before codealmanac/wiki-related work, read `~/.codex/codealmanac.md`.",
-    "For the full command reference, read `~/.codex/codealmanac-reference.md` on demand.",
-    CODEX_BLOCK_END,
-    ""
-  ].join("\n");
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 var IMPORT_LINE = "@~/.claude/codealmanac.md";
 async function ensureImport(claudeMdPath) {
   let existing = "";
-  if (existsSync2(claudeMdPath)) {
-    existing = await readFile(claudeMdPath, "utf8");
+  if (existsSync3(claudeMdPath)) {
+    existing = await readFile2(claudeMdPath, "utf8");
   }
   if (hasImportLine(existing)) return false;
   const sep = existing.length === 0 ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
   const body = `${existing}${sep}${IMPORT_LINE}
 `;
-  await writeFile(claudeMdPath, body, "utf8");
+  await writeFile2(claudeMdPath, body, "utf8");
   return true;
 }
 function hasImportLine(contents) {
@@ -664,14 +847,17 @@ function promptText(out, question, defaultValue) {
     process.stdin.on("data", onData);
   });
 }
+async function waitForEnter(out, message) {
+  await promptText(out, message, "");
+}
 function resolveGuidesDir() {
-  const here = path3.dirname(fileURLToPath2(import.meta.url));
+  const here = path4.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path3.resolve(here, "..", "guides"),
+    path4.resolve(here, "..", "guides"),
     // dist layout
-    path3.resolve(here, "..", "..", "guides"),
+    path4.resolve(here, "..", "..", "guides"),
     // src layout
-    path3.resolve(here, "..", "..", "..", "guides")
+    path4.resolve(here, "..", "..", "..", "guides")
   ];
   for (const dir of candidates) {
     if (looksLikeGuidesDir(dir)) return dir;
@@ -679,7 +865,7 @@ function resolveGuidesDir() {
   try {
     const require2 = createRequire2(import.meta.url);
     const pkgJson = require2.resolve("codealmanac/package.json");
-    const guides = path3.join(path3.dirname(pkgJson), "guides");
+    const guides = path4.join(path4.dirname(pkgJson), "guides");
     if (looksLikeGuidesDir(guides)) return guides;
   } catch {
   }
@@ -688,24 +874,15 @@ function resolveGuidesDir() {
   );
 }
 function looksLikeGuidesDir(dir) {
-  return existsSync2(path3.join(dir, "mini.md"));
-}
-function printProviderNextSteps(out) {
-  out.write(`  ${DIM2}Change provider/model later:${RST2}
-`);
-  out.write(`  ${DIM2}  almanac agents list${RST2}
-`);
-  out.write(`  ${DIM2}  almanac agents use <claude|codex|cursor>${RST2}
-`);
-  out.write(
-    `  ${DIM2}  almanac agents model <provider> <model|--default>${RST2}
-
-`
-  );
+  return existsSync3(path4.join(dir, "mini.md"));
 }
 
 export {
+  CODEX_INSTRUCTIONS_START,
+  CODEX_INSTRUCTIONS_END,
+  resolveCodexAgentsPath,
+  hasCodexInstructions,
   runSetup,
   IMPORT_LINE
 };
-//# sourceMappingURL=chunk-GFUB57IT.js.map
+//# sourceMappingURL=chunk-VXDPUOQ5.js.map