fapony 0.2.1 → 0.3.3

package/src/init-mem.ts

@@ -4,32 +4,10 @@
 // Now fapony owns the mem code (src/mem/) and calls it directly via `fapony mem`.
 // This command's new job: delete legacy .memory/ dirs + warn about package.json refs.
 
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-} from "node:fs";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { DEFAULT_MEM_DIR, FAPONY_DIR, loadConfig } from "./db/index.js";
-
-export function copyDir(src: string, dest: string): string[] {
-  mkdirSync(dest, { recursive: true });
-  const copied: string[] = [];
-  for (const entry of readdirSync(src, { withFileTypes: true })) {
-    const s = join(src, entry.name);
-    const d = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copied.push(...copyDir(s, d));
-    } else {
-      copyFileSync(s, d);
-      copied.push(d);
-    }
-  }
-  return copied;
-}
+import { walkDir } from "./util.js";
 
 export function cmdInitMem(args: string[]): void {
   const force = args.includes("--force");
@@ -52,27 +30,18 @@ export function cmdInitMem(args: string[]): void {
   const root = gitRoot || worktree;
 
   // 1) Find and delete .memory/ directories (legacy layout)
-  const memoryDirs: string[] = [];
-  const walk = (dir: string, depth = 0) => {
-    if (depth > 4) return;
-    if (existsSync(`${dir}/.memory`)) {
-      memoryDirs.push(`${dir}/.memory`);
-    }
-    try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (
-          entry.isDirectory() &&
-          entry.name !== "node_modules" &&
-          (!entry.name.startsWith(".") || entry.name === FAPONY_DIR)
-        ) {
-          walk(join(dir, entry.name), depth + 1);
-        }
-      }
-    } catch {
-      // ignore
-    }
-  };
-  walk(root);
+  const memoryDirs = walkDir(root, {
+    includeDotDirs: [FAPONY_DIR],
+    predicate: (dir) => existsSync(join(dir, ".memory")),
+  }).map((dir) => join(dir, ".memory"));
+
+  // Legacy filenames that may live alongside live logs inside .fapony/.memory/
+  const LEGACY_MEM_FILENAMES = [
+    "mem.ts",
+    "store.ts",
+    "selectors.ts",
+    "render.ts",
+  ];
 
   if (memoryDirs.length === 0) {
     console.log("no legacy .memory/ directories found — already clean");
@@ -90,6 +59,39 @@ export function cmdInitMem(args: string[]): void {
       } catch {
         // unreadable dir — fall through and remove
       }
+      // Inside .fapony/.memory/: remove known legacy .ts files while keeping
+      // live logs. The keep-if-logs guard would preserve the whole directory,
+      // but legacy scaffolding (mem.ts, store.ts, ...) is dead code that
+      // should not linger beside the active log.
+      const isFaponyMemory =
+        d.endsWith(`/${FAPONY_DIR}/.memory`) || d === `${FAPONY_DIR}/.memory`;
+      if (isFaponyMemory && logs.length > 0) {
+        let legacyRemoved = 0;
+        let commandsRemoved = 0;
+        for (const name of LEGACY_MEM_FILENAMES) {
+          const fp = join(d, name);
+          if (existsSync(fp)) {
+            rmSync(fp);
+            legacyRemoved++;
+          }
+        }
+        const commandsDir = join(d, "commands");
+        if (existsSync(commandsDir)) {
+          rmSync(commandsDir, { recursive: true, force: true });
+          commandsRemoved++;
+        }
+        if (legacyRemoved || commandsRemoved) {
+          console.log(
+            `cleaned ${d} — removed ${legacyRemoved} legacy file(s)${
+              commandsRemoved ? " + commands/" : ""
+            } (kept ${logs.length} log file(s): ${logs.join(", ")})`,
+          );
+        } else {
+          console.log(`${d} — already clean (logs: ${logs.join(", ")})`);
+        }
+        kept++;
+        continue;
+      }
       if (logs.length > 0 && !force) {
         console.log(
           `keeping ${d} — has ${logs.length} log file(s): ${logs.join(", ")}`,
@@ -116,42 +118,26 @@ export function cmdInitMem(args: string[]): void {
   }
 
   // 2) Warn about package.json call sites still referencing .memory/mem.ts
-  const warnAboutCallSites = (dir: string, depth = 0) => {
-    if (depth > 4) return;
+  for (const dir of walkDir(root)) {
     const pkg = join(dir, "package.json");
-    if (existsSync(pkg)) {
-      try {
-        const raw = readFileSync(pkg, "utf8");
-        if (raw.includes(".memory/mem.ts")) {
-          console.log(`\n⚠ ${pkg} still references .memory/mem.ts`);
-          console.log(
-            `  update to: "fapony mem <sub>" (e.g. "fapony mem add", "fapony mem close")`,
-          );
-        }
-      } catch {
-        // ignore
-      }
-    }
+    if (!existsSync(pkg)) continue;
     try {
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (
-          entry.isDirectory() &&
-          !entry.name.startsWith(".") &&
-          entry.name !== "node_modules"
-        ) {
-          warnAboutCallSites(join(dir, entry.name), depth + 1);
-        }
+      const raw = readFileSync(pkg, "utf8");
+      if (raw.includes(".memory/mem.ts")) {
+        console.log(`\n⚠ ${pkg} still references .memory/mem.ts`);
+        console.log(
+          `  update to: "fapony mem <sub>" (e.g. "fapony mem add", "fapony mem close")`,
+        );
       }
     } catch {
       // ignore
     }
-  };
-  warnAboutCallSites(root);
+  }
 
   console.log("\nmem commands are now built into fapony:");
   console.log('  fapony mem add <kind> "<text>" --files <files>');
   console.log('  fapony mem close <id> "<text>"');
   console.log("  fapony mem find <word>");
   console.log("  fapony mem kickoff [id|spec.md]");
-  console.log("  fapony mem now");
+  console.log("  fapony mem done | stale");
 }

package/src/init.ts

@@ -95,10 +95,9 @@ work done. Cut at chunk boundaries instead:
 Finish a chunk, before starting the next:
 1. Tick its checkbox + stamp the TL;DR in the plan file
 2. Commit — separate from other chunks
-3. \`verdict_submit\` (fapony MCP), grading what actually happened
-4. \`fapony mem add note "what the next chunk needs" --files f1,f2 <path/to/PLAN-x.md>\`
+3. \`fapony mem add note "what the next chunk needs" --files f1,f2 <path/to/PLAN-x.md>\`
    — use the same plan path every time
-5. Stop. Do not continue to the next chunk in the same session unless told to.
+4. Stop. Do not continue to the next chunk in the same session unless told to.
 
 Next chunk, new session — open with \`fapony mem kickoff <path/to/PLAN-x.md>\` instead
 of carrying the old transcript forward. kickoff already filters to the rows for that plan,
@@ -196,16 +195,6 @@ export function initProject(targetPath: string, config?: Config): void {
 
 const AGENT_RULE_FILES = ["CLAUDE.md", "AGENTS.md"];
 
-function ask(question: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${question} `, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
 export async function cmdInit(args: string[]): Promise<void> {
   const targetPath = args[0];
   if (!targetPath) {
@@ -242,9 +231,16 @@ export async function cmdInit(args: string[]): Promise<void> {
   );
   if (found.length === 0) return;
 
-  const answer = await ask(
-    `\nAppend the memory-logging rules above to ${found.map((f) => relative(targetPath, f)).join(" and ")}? [y/N]`,
-  );
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>((resolve) => {
+    rl.question(
+      `\nAppend the memory-logging rules above to ${found.map((f) => relative(targetPath, f)).join(" and ")}? [y/N] `,
+      (a) => {
+        rl.close();
+        resolve(a.trim());
+      },
+    );
+  });
   if (!isAffirmative(answer)) return;
 
   const snippet = `\n\n${RULES_SNIPPET()}\n`;

package/src/install/antigravity.ts

@@ -0,0 +1,112 @@
+// src/install/antigravity.ts — Google Antigravity install provider
+//
+// Writes mcpServers.fapony to ~/.gemini/config/mcp_config.json (Antigravity's
+// global MCP config) and symlinks skills into ~/.agents/skills/ (Progressive
+// Skills path). No hooks in the first phase — Antigravity's hook surface is
+// still evolving.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { agentsSkillsDir, linkSkills, reportSkills } from "./skills.js";
+import {
+  CURSOR_MCP_ENTRY,
+  defaultExit,
+  type InstallDeps,
+  MCP_KEY,
+} from "./types.js";
+
+/** ~/.gemini — created on first Antigravity launch. */
+export function findGeminiDir(getHome: () => string): string | null {
+  const dir = join(getHome(), ".gemini");
+  return existsSync(dir) ? dir : null;
+}
+
+function isFaponyEntry(entry: unknown): boolean {
+  if (!entry || typeof entry !== "object") return false;
+  const cfg = entry as Record<string, unknown>;
+  return (
+    cfg.command === CURSOR_MCP_ENTRY.command &&
+    JSON.stringify(cfg.args) === JSON.stringify(CURSOR_MCP_ENTRY.args)
+  );
+}
+
+function readJsonObject(path: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export function cmdInstallAntigravity(
+  dryRun: boolean,
+  deps: InstallDeps = {},
+): void {
+  const exitFn = deps.exit ?? defaultExit;
+  const getHome = deps.homedir ?? homedir;
+  const geminiDir = findGeminiDir(getHome);
+
+  if (!geminiDir) {
+    console.error(
+      `Antigravity not found — open Antigravity at least once to create ~/.gemini`,
+    );
+    exitFn(1);
+    return;
+  }
+
+  // --- 1. MCP server (mcpServers.fapony in ~/.gemini/config/mcp_config.json) ---
+  const configDir = join(geminiDir, "config");
+  const mcpPath = join(configDir, "mcp_config.json");
+  let mcp: Record<string, unknown> = {};
+  let mcpIsNew = true;
+  if (existsSync(mcpPath)) {
+    const parsed = readJsonObject(mcpPath);
+    if (!parsed) {
+      console.error(`failed to parse ${mcpPath} — fix or remove it first`);
+      exitFn(1);
+      return;
+    }
+    mcp = parsed;
+    mcpIsNew = false;
+  }
+  const servers = (mcp.mcpServers ?? {}) as Record<string, unknown>;
+  const existing = servers[MCP_KEY];
+  if (existing !== undefined && !isFaponyEntry(existing)) {
+    console.error(
+      `an MCP server named "${MCP_KEY}" exists but points elsewhere — not overwriting.`,
+    );
+    console.error(`  inspect ${mcpPath} and remove it first`);
+    exitFn(1);
+    return;
+  }
+  if (existing !== undefined) {
+    console.error(
+      `✓ mcpServers.${MCP_KEY} already configured — no change needed`,
+    );
+    console.error(`  (${mcpPath})`);
+  } else {
+    const after = {
+      ...mcp,
+      mcpServers: { ...servers, [MCP_KEY]: CURSOR_MCP_ENTRY },
+    };
+    if (dryRun) {
+      console.error(
+        `── dry-run: would ${mcpIsNew ? "create" : "write"} ${mcpPath}${mcpIsNew ? "" : ` (mcpServers.${MCP_KEY})`} ──`,
+      );
+    } else {
+      writeFileSync(mcpPath, `${JSON.stringify(after, null, 2)}\n`, "utf-8");
+      console.error(`✓ added mcpServers.${MCP_KEY} to ${mcpPath}`);
+      console.error(`  restart Antigravity to load the MCP server`);
+    }
+  }
+
+  // --- 2. Skills (~/.agents/skills/) ---
+  const skillsDir = agentsSkillsDir(getHome);
+  const results = linkSkills(skillsDir, dryRun);
+  reportSkills(results, skillsDir, dryRun);
+}

package/src/install/claude.ts

@@ -2,14 +2,7 @@
 //
 // Shells out to `claude mcp add` (never parses/writes ~/.claude.json directly).
 
-import {
-  chmodSync,
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { assertSafe } from "../safety.js";
@@ -151,132 +144,18 @@ export function cmdInstallClaude(
   const skillsDir = claudeSkillsDir(deps.homedir ?? homedir);
   reportSkills(linkSkills(skillsDir, dryRun), skillsDir, dryRun);
 
-  // Wire statusline: copy script + update settings.json.
-  installStatusline(dryRun, deps);
-
   // Wire the Stop hook that refuses to end a turn with ungraded commits,
   // and the Read/Edit hints that annotate reads of large files and edits to
   // files with importers (both annotate-only).
   installClaudeHooks(dryRun, deps);
 }
 
-/**
- * Copy the statusline script to ~/.claude/statusline.sh and add the
- * statusLine field to ~/.claude/settings.json. Best-effort — never fails
- * the install if settings.json is unreadable or has unexpected shape.
- */
-function installStatusline(dryRun: boolean, deps: InstallDeps): void {
-  const home = deps.homedir ? deps.homedir() : homedir();
-  const claudeDir = join(home, ".claude");
-  const scriptSrc = join(INSTALL_ROOT, "statusline", "claude-statusline.sh");
-  const scriptDest = join(claudeDir, "statusline.sh");
-  const settingsPath = join(claudeDir, "settings.json");
-
-  // 1. Copy the statusline script — never overwrite someone else's.
-  // Mirrors the mcp-entry policy above: an existing script that isn't ours
-  // is left alone (the settings guard below will also refuse to repoint it).
-  if (!existsSync(scriptSrc)) {
-    console.error(`  statusline: script not found at ${scriptSrc} — skipping`);
-    return;
-  }
-  if (existsSync(scriptDest)) {
-    let current = "";
-    try {
-      current = readFileSync(scriptDest, "utf-8");
-    } catch {
-      current = "";
-    }
-    if (!current.includes("fapony")) {
-      console.error(
-        `  statusline: ${scriptDest} exists but isn't fapony's — not overwriting.`,
-      );
-      console.error(
-        `  inspect it first, then remove it to let fapony install its own.`,
-      );
-      return;
-    }
-  }
-  try {
-    if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
-    if (!dryRun) copyFileSync(scriptSrc, scriptDest);
-    // Claude Code execs this file — the copy must stay executable.
-    if (!dryRun) chmodSync(scriptDest, 0o755);
-    console.error(
-      `  statusline: ${dryRun ? "would copy" : "copied"} ${scriptDest}`,
-    );
-  } catch (e) {
-    console.error(
-      `  statusline: failed to copy script — ${(e as Error).message}`,
-    );
-    return;
-  }
-
-  // 2. Update settings.json with statusLine field.
-  let settings: Record<string, unknown> = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as Record<
-        string,
-        unknown
-      >;
-    } catch {
-      console.error(
-        `  statusline: ${settingsPath} is unreadable or malformed — skipping settings update`,
-      );
-      return;
-    }
-  }
-
-  // Don't overwrite if already configured (same command path). A foreign
-  // statusLine (someone else's command) is left alone — same policy as the
-  // mcp-entry "points elsewhere" refusal above. Match on our exact dest:
-  // any *statusline.sh substring (e.g. another plugin's script) is not ours.
-  const existing = settings.statusLine as Record<string, unknown> | undefined;
-  if (
-    existing &&
-    existing.type === "command" &&
-    typeof existing.command === "string" &&
-    existing.command === scriptDest
-  ) {
-    console.error(
-      `  statusline: already configured in settings.json — no change`,
-    );
-    return;
-  }
-  if (existing && typeof existing === "object") {
-    console.error(
-      `  statusline: settings.json already has a statusLine that isn't fapony's — not overwriting.`,
-    );
-    console.error(
-      `  inspect it first, then remove it to let fapony wire its own.`,
-    );
-    return;
-  }
-
-  settings.statusLine = {
-    type: "command",
-    command: scriptDest,
-  };
-
-  if (!dryRun) {
-    writeFileSync(
-      settingsPath,
-      `${JSON.stringify(settings, null, 2)}\n`,
-      "utf-8",
-    );
-  }
-  console.error(
-    `  statusline: ${dryRun ? "would write" : "wrote"} statusLine → ${settingsPath}`,
-  );
-}
-
 /**
  * Shared append-to-settings.json hook installer. Both fapony hooks live
  * here now (Stop since PLAN-mem-mcp, PreToolUse read hint since the
  * large-file annotate feature) — the read/write/idempotence/append shape
  * is one implementation with two callers, not a scaffold.
- * Same policy as installStatusline: never touch a hook someone else
- * registered, never fail the install over it.
+ * Never touch a hook someone else registered, never fail the install over it.
  */
 function ensureClaudeHook(
   dryRun: boolean,
@@ -353,6 +232,7 @@ function installClaudeHooks(dryRun: boolean, deps: InstallDeps): void {
   installStopHook(dryRun, deps);
   installReadHintHook(dryRun, deps);
   installEditHintHook(dryRun, deps);
+  installSessionStartHook(dryRun, deps);
 }
 
 function installStopHook(dryRun: boolean, deps: InstallDeps): void {
@@ -395,3 +275,16 @@ function installEditHintHook(dryRun: boolean, deps: InstallDeps): void {
     label: "edit hint",
   });
 }
+
+/**
+ * SessionStart hook: injects `fapony mem kickoff` as context when the repo has
+ * a mem log, and stays silent when it does not. Context only — SessionStart
+ * cannot block, and a repo without mem never sees a line.
+ */
+function installSessionStartHook(dryRun: boolean, deps: InstallDeps): void {
+  ensureClaudeHook(dryRun, deps, {
+    event: "SessionStart",
+    subcommand: "hook-session-start",
+    label: "session start",
+  });
+}

package/src/install/codex.ts

@@ -1,7 +1,7 @@
 // src/install/codex.ts — Codex install provider
 //
 // Reads/writes ~/.codex/config.toml directly for MCP config.
-// Reads/writes ~/.codex/hooks.json for lifecycle hooks (Stop).
+// Reads/writes ~/.codex/hooks.json for lifecycle hooks (Stop, SessionStart).
 // Symlinks skills into ~/.agents/skills/ (same dir as ZCode).
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -46,18 +46,25 @@ function readJsonObject(path: string): Record<string, unknown> | null {
 }
 
 /**
- * Append the fapony Stop hook to ~/.codex/hooks.json.
- * Never replaces other hook groups or foreign entries within the Stop group.
- * Fapony-owned entry is identified by the command string containing "hook-stop".
+ * Append a fapony command hook to one event group in ~/.codex/hooks.json.
+ * Never replaces other hook groups or foreign entries within the group.
+ * A fapony-owned entry is identified by the subcommand string
+ * ("hook-stop" / "hook-session-start") inside its command — per-group
+ * idempotence, so an existing install with only Stop still picks up
+ * SessionStart on the next run.
  */
-function installStopHook(dryRun: boolean, getHome: () => string): void {
+function installCodexHookGroup(
+  dryRun: boolean,
+  getHome: () => string,
+  opts: { event: "Stop" | "SessionStart"; subcommand: string; label: string },
+): void {
   const hooksPath = join(getHome(), ".codex", "hooks.json");
   let config: Record<string, unknown> = {};
   if (existsSync(hooksPath)) {
     const parsed = readJsonObject(hooksPath);
     if (!parsed) {
       console.error(
-        `  stop hook: ${hooksPath} is unreadable or malformed — skipping`,
+        `  ${opts.label}: ${hooksPath} is unreadable or malformed — skipping`,
       );
       return;
     }
@@ -70,45 +77,76 @@ function installStopHook(dryRun: boolean, getHome: () => string): void {
     (typeof hookMap !== "object" || Array.isArray(hookMap))
   ) {
     console.error(
-      `  stop hook: ${hooksPath} has an unexpected "hooks" shape — skipping`,
+      `  ${opts.label}: ${hooksPath} has an unexpected "hooks" shape — skipping`,
     );
     return;
   }
 
   const map = (hookMap ?? {}) as Record<string, unknown>;
-  // Codex Stop array: each element is { matcher?, hooks: [...] }
-  const stop = Array.isArray(map.Stop) ? (map.Stop as unknown[]) : [];
-
-  // Check if fapony stop hook already present (by command string)
-  const serialized = JSON.stringify(stop);
-  if (serialized.includes("hook-stop")) {
-    console.error(`  stop hook: already configured in hooks.json — no change`);
+  // Codex event arrays: each element is { matcher?, hooks: [...] }
+  const group = Array.isArray(map[opts.event])
+    ? (map[opts.event] as unknown[])
+    : [];
+
+  // Check if the fapony hook is already present in this group (by subcommand)
+  const serialized = JSON.stringify(group);
+  if (serialized.includes(opts.subcommand)) {
+    console.error(
+      `  ${opts.label}: already configured in hooks.json — no change`,
+    );
     return;
   }
 
-  const command = `bun ${join(INSTALL_ROOT, "fapony.ts")} hook-stop`;
+  const command = `bun ${join(INSTALL_ROOT, "fapony.ts")} ${opts.subcommand}`;
   const faponyEntry = { hooks: [{ type: "command", command }] };
   const after = {
     ...config,
-    hooks: { ...map, Stop: [...stop, faponyEntry] },
+    hooks: { ...map, [opts.event]: [...group, faponyEntry] },
   };
 
   if (!dryRun) {
     try {
       writeFileSync(hooksPath, `${JSON.stringify(after, null, 2)}\n`, "utf-8");
     } catch (e) {
-      console.error(`  stop hook: failed to write — ${(e as Error).message}`);
+      console.error(
+        `  ${opts.label}: failed to write — ${(e as Error).message}`,
+      );
       return;
     }
   }
   console.error(
-    `  stop hook: ${dryRun ? "would write" : "wrote"} hooks.Stop → ${hooksPath}`,
+    `  ${opts.label}: ${dryRun ? "would write" : "wrote"} hooks.${opts.event} → ${hooksPath}`,
   );
   console.error(
     `    review and trust via Codex /hooks before the hook will run`,
   );
 }
 
+function installStopHook(dryRun: boolean, getHome: () => string): void {
+  installCodexHookGroup(dryRun, getHome, {
+    event: "Stop",
+    subcommand: "hook-stop",
+    label: "stop hook",
+  });
+}
+
+/**
+ * SessionStart hook: injects `fapony mem kickoff` as context when the repo
+ * has a mem log, silent when it does not (cmdHookSessionStart exits quiet).
+ * Same `hookSpecificOutput.additionalContext` contract Claude uses — Codex
+ * SessionStart reads that channel too. No matcher: match-all fires on every
+ * source including `clear` and on versions that send no source at all, where
+ * a `startup|resume` matcher would silently never fire; kickoff is capped at
+ * 4k and costs one cheap spawn, so the /clear path stays fast.
+ */
+function installSessionStartHook(dryRun: boolean, getHome: () => string): void {
+  installCodexHookGroup(dryRun, getHome, {
+    event: "SessionStart",
+    subcommand: "hook-session-start",
+    label: "session start",
+  });
+}
+
 export function cmdInstallCodex(dryRun: boolean, deps: InstallDeps = {}): void {
   const exitFn = deps.exit ?? defaultExit;
   const getHome = deps.homedir ?? homedir;
@@ -144,8 +182,9 @@ export function cmdInstallCodex(dryRun: boolean, deps: InstallDeps = {}): void {
     console.error(`  restart Codex to load the MCP server`);
   }
 
-  // --- Stop hook (~/.codex/hooks.json) ---
+  // --- Stop + SessionStart hooks (~/.codex/hooks.json) ---
   installStopHook(dryRun, getHome);
+  installSessionStartHook(dryRun, getHome);
 
   // --- Skills (~/.agents/skills/) ---
   const skillsDir = agentsSkillsDir(getHome);