fapony 0.2.0 → 0.3.0

package/src/hook.ts

@@ -26,11 +26,12 @@ import {
   statSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, join, relative, resolve } from "node:path";
-import { collectSourceFiles, SCAN_EXTS } from "./analyze.js";
+import { basename, join, relative, resolve, sep } from "node:path";
+import { buildGraphCached, collectSourceFiles, SCAN_EXTS } from "./analyze.js";
 import { openDb } from "./db/index.js";
-import { debtForFile, loadConventions } from "./debt.js";
-import { readMemLog } from "./memory.js";
+import { debtForFile, loadConventions } from "./debt/index.js";
+import { detectTestRunner } from "./detect.js";
+import { readMemLog, whereMemDir } from "./memory.js";
 
 // --- Hint-fire log (PLAN-feedback-surface chunk 1) ---
 //
@@ -63,7 +64,7 @@ export function hintLogPath(worktree: string): string {
 export interface HintFireRow {
   ts: string;
   worktree: string;
-  surface: "read" | "debt" | "mem" | "commit";
+  surface: "read" | "debt" | "mem" | "commit" | "edit";
   file: string | null;
   count: number;
   ids?: string[];
@@ -96,7 +97,13 @@ export function recordHintFire(row: HintFireRow): void {
 
 export interface HintImpact {
   fired: number;
-  by_surface: { read: number; debt: number; mem: number; commit: number };
+  by_surface: {
+    read: number;
+    debt: number;
+    mem: number;
+    commit: number;
+    edit: number;
+  };
   debt: { shown: number; resolved: number; unknown: number };
   window: string | null;
 }
@@ -115,7 +122,7 @@ export function computeHintImpact(
   const dir = hintLogDir();
   const impact: HintImpact = {
     fired: 0,
-    by_surface: { read: 0, debt: 0, mem: 0, commit: 0 },
+    by_surface: { read: 0, debt: 0, mem: 0, commit: 0, edit: 0 },
     debt: { shown: 0, resolved: 0, unknown: 0 },
     window: since ?? null,
   };
@@ -212,9 +219,13 @@ export interface RawStopPayload {
   conversation_id?: string;
   loop_count?: number;
   status?: string;
+  // Codex — hooks contract (https://learn.chatgpt.com/docs/hooks)
+  session_id?: string;
+  model?: string;
+  permission_mode?: string;
 }
 
-export type StopClient = "claude" | "cursor";
+export type StopClient = "claude" | "cursor" | "codex";
 
 export interface NormalizedStopInput {
   client: StopClient;
@@ -245,6 +256,8 @@ export function decideStop(opts: {
   verdicts: number;
   commitList?: string[];
   memLastTs?: string | null;
+  /** Logs that exist in the repo but are out of scope from this worktree. */
+  memCandidates?: string[];
 }): string | null {
   if (opts.stopHookActive) return null; // already blocked once — let it end
   if (!opts.worktree) return null;
@@ -262,16 +275,30 @@ export function decideStop(opts: {
     lines.push(
       `mem: last row ${opts.memLastTs.slice(0, 10)} — nothing newer this session`,
     );
+  } else if (opts.memCandidates?.length) {
+    // "nothing recorded" would be a lie: the log exists, it is just not in
+    // scope from here (monorepo — the log lives in the app dir). Say where.
+    lines.push(
+      `mem: no log in scope from ${opts.worktree} — found ` +
+        `${opts.memCandidates.join(", ")} (run mem commands from there, or --mem-dir)`,
+    );
   } else {
     lines.push("mem: no rows at all — nothing recorded in this project yet");
   }
+  const runner = detectTestRunner(opts.worktree);
+  const verifyLine = runner
+    ? `If you did not run \`${runner.typecheckCmd ? `${runner.typecheckCmd} and ` : ""}${runner.testCmd}\` to a real exit code, ` +
+      `the honest verdict is uncertain, not pass. `
+    : `If you did not run this repo's typecheck and test suite to a real exit code, ` +
+      `the honest verdict is uncertain, not pass. `;
+
   lines.push(
     `Call verdict_submit before ending: worktree must be the absolute path above, ` +
       `regime is one of code|fix|review|plan|inquiry|test, and the note must stand alone ` +
       `(it is read months from now with no access to this conversation). ` +
       `Grade what actually happened — pass-family when it held up, fail if the first ` +
-      `attempt was wrong, uncertain when you could not verify it. What deserves a mem ` +
-      `row (decision/bug/note) is your call — not every unit needs one.`,
+      `attempt was wrong, uncertain when you could not verify it. ${verifyLine}` +
+      `What deserves a mem row (decision/bug/note) is your call — not every unit needs one.`,
   );
   return lines.join("\n");
 }
@@ -319,11 +346,32 @@ export function isCursorPayload(raw: RawStopPayload): boolean {
   );
 }
 
-/** Field-mapping only — both clients feed the same decideStop below. */
+/** Codex sends permission_mode and/or model — fields neither Claude nor Cursor include in Stop. */
+export function isCodexPayload(raw: RawStopPayload): boolean {
+  return (
+    typeof raw.permission_mode === "string" ||
+    (typeof raw.model === "string" && !isCursorPayload(raw))
+  );
+}
+
+/** Field-mapping only — all three clients feed the same decideStop below. */
 export function normalizeStopInput(
   raw: RawStopPayload,
   home: string,
 ): NormalizedStopInput {
+  if (isCodexPayload(raw)) {
+    // Codex: cwd is the session working directory; stop_hook_active means
+    // the hook already fired once (same semantics as Claude).
+    return {
+      client: "codex",
+      cwd: raw.cwd ?? process.cwd(),
+      transcriptPath:
+        typeof raw.transcript_path === "string" && raw.transcript_path
+          ? raw.transcript_path
+          : null,
+      stopHookActive: raw.stop_hook_active === true,
+    };
+  }
   if (isCursorPayload(raw)) {
     const cwd = raw.workspace_roots?.[0] ?? raw.cwd ?? process.cwd();
     let transcriptPath =
@@ -350,12 +398,74 @@ export function normalizeStopInput(
   };
 }
 
-/** Claude blocks with decision:block; Cursor's stop hook "blocks" by
- *  auto-submitting the reason as the next user message. */
+/** Claude blocks with decision:block; Cursor auto-submits as followup_message;
+ *  Codex continues with decision:block + reason (continue:false would take
+ *  precedence and end the turn instead — Codex Hooks, Stop section). */
 export function stopOutput(client: StopClient, reason: string): string {
-  return client === "cursor"
-    ? JSON.stringify({ followup_message: reason })
-    : JSON.stringify({ decision: "block", reason });
+  if (client === "cursor") return JSON.stringify({ followup_message: reason });
+  if (client === "codex") return JSON.stringify({ decision: "block", reason });
+  return JSON.stringify({ decision: "block", reason });
+}
+
+// --- Block dedupe (one block per session + worktree) ---
+//
+// stop_hook_active only suppresses the block that fires *immediately* after
+// one. Every later turn that still carries ungraded commits blocks again, so
+// a session that keeps committing gets the same paragraph 4-5 times. The
+// first block already delivered it; the repeats add noise, not force (rule 9
+// — the forcing happens once, and the agent that ignored it once is not
+// persuaded by the fifth copy).
+//
+// Keyed by the transcript path, which is already the session identity the
+// commit window is measured from — no session field to thread through.
+
+const STOP_BLOCK_DIR = "stop-block";
+
+interface StopBlockRow {
+  ts: string;
+  worktree: string;
+}
+
+/** Absolute path of a session's block log — may not exist. */
+export function stopBlockPath(session: string): string {
+  const base =
+    process.env.FAPONY_STATE_DIR || join(homedir(), ".config", "fapony");
+  return join(base, STOP_BLOCK_DIR, `${sessionKey(session)}.jsonl`);
+}
+
+/**
+ * True when this session already blocked for this worktree — the caller then
+ * lets the turn end. Records the block when it has not. Every unknown (no
+ * session identity, unwritable state dir) resolves to false: a dedupe that
+ * guesses must fail towards blocking, never towards silence.
+ */
+export function stopBlockedBefore(
+  session: string | null,
+  worktree: string,
+): boolean {
+  if (!session) return false;
+  const path = stopBlockPath(session);
+  try {
+    if (existsSync(path)) {
+      for (const line of readFileSync(path, "utf-8").split("\n")) {
+        if (!line) continue;
+        try {
+          if ((JSON.parse(line) as StopBlockRow).worktree === worktree) {
+            return true;
+          }
+        } catch {
+          // a torn line must not lose the rest of the log
+        }
+      }
+    }
+    const dir = join(path, "..");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const row: StopBlockRow = { ts: new Date().toISOString(), worktree };
+    appendFileSync(path, `${JSON.stringify(row)}\n`, "utf-8");
+  } catch {
+    return false;
+  }
+  return false;
 }
 
 /** Reads the Stop-hook JSON on stdin, prints a block decision or nothing. */
@@ -370,6 +480,7 @@ export async function cmdHookStop(): Promise<void> {
     // died — commits from those turns are still caught at the next completed
     // stop (the window is the conversation transcript's birthtime).
     if (client === "cursor" && raw.status !== "completed") return;
+    // Codex: no status guard needed — Stop fires at turn end unconditionally.
 
     const worktree = git(["rev-parse", "--show-toplevel"], norm.cwd);
 
@@ -388,6 +499,7 @@ export async function cmdHookStop(): Promise<void> {
     let commitList: string[] = [];
     let verdicts = 0;
     let memLastTs: string | null = null;
+    let memCandidates: string[] = [];
     if (worktree && since) {
       const log = git(
         ["log", "--since", `${since} +0000`, "--format=%h %s"],
@@ -409,6 +521,8 @@ export async function cmdHookStop(): Promise<void> {
         try {
           const mem = readMemLog(worktree);
           memLastTs = mem.rows[0]?.ts ?? null;
+          if (!memLastTs)
+            memCandidates = whereMemDir(worktree).candidates ?? [];
         } catch {
           memLastTs = null;
         }
@@ -422,7 +536,16 @@ export async function cmdHookStop(): Promise<void> {
       verdicts,
       commitList,
       memLastTs,
+      memCandidates,
     });
+    // Already blocked for this worktree in this session — say it once.
+    if (
+      reason &&
+      worktree &&
+      stopBlockedBefore(norm.transcriptPath, worktree)
+    ) {
+      reason = null;
+    }
   } catch {
     reason = null; // any failure = allow the turn to end
   }
@@ -430,6 +553,78 @@ export async function cmdHookStop(): Promise<void> {
   if (reason) console.log(stopOutput(client, reason));
 }
 
+// --- Session start (kickoff as context, not as a thing to remember) ---
+//
+// `fapony mem kickoff` is the one command that pays for itself at session
+// open — what is open, what is stale, what the last rows touched. Asking the
+// agent to run it measured as not enough (rule 9), and an MCP tool would pay
+// schema rent in every session of every client to save one bash round
+// (rule 13). A SessionStart hook is neither: zero rent, and it fires whether
+// or not anyone remembers.
+//
+// Runs the CLI in a subprocess rather than calling cmdKickoff: kickoff prints
+// to stdout and exits on bad input, both of which would be this hook's stdout.
+
+/** Cap on injected context — kickoff is short, a broken repo's output is not. */
+export const SESSION_START_MAX_CHARS = 4_000;
+
+const TRUNCATED = "… truncated — run `fapony mem kickoff` for the rest";
+
+/** Trim to whole lines, keeping the marker's line boundary intact. */
+function headLines(text: string, max: number): string {
+  const cut = text.slice(0, max);
+  const lastNl = cut.lastIndexOf("\n");
+  return (lastNl > 0 ? cut.slice(0, lastNl) : cut).trimEnd();
+}
+
+/**
+ * Trim to whole lines within the cap, with an honest truncation marker.
+ *
+ * "## next up" is kickoff's last section and its most actionable one, so a
+ * plain head-cut drops exactly the part worth injecting in a repo with a long
+ * open list (measured here: 92 rows, the cut landed mid-history). Keep it and
+ * spend the rest of the budget on the head.
+ */
+export function capContext(
+  text: string,
+  max = SESSION_START_MAX_CHARS,
+): string {
+  if (text.length <= max) return text;
+  const at = text.lastIndexOf("\n## next up");
+  const tail = at > 0 ? text.slice(at).trimEnd() : "";
+  if (tail && tail.length < max / 2) {
+    return `${headLines(text, max - tail.length)}\n${TRUNCATED}\n${tail}`;
+  }
+  return `${headLines(text, max)}\n${TRUNCATED}`;
+}
+
+/** SessionStart hook: inject `fapony mem kickoff` output as context. */
+export async function cmdHookSessionStart(): Promise<void> {
+  try {
+    const raw = JSON.parse(await Bun.stdin.text()) as { cwd?: string };
+    const cwd = raw.cwd ?? process.cwd();
+    // No mem log in scope = nothing to say. Silence beats "no rows yet".
+    if (!whereMemDir(cwd).dir) return;
+    const p = Bun.spawnSync([process.execPath, Bun.main, "mem", "kickoff"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = p.stdout.toString().trim();
+    if (p.exitCode !== 0 || !out) return;
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: capContext(out),
+        },
+      }),
+    );
+  } catch {
+    // any failure = no context, never a broken session start
+  }
+}
+
 // --- Read hint (PreToolUse annotate — never block, never dedupe) ---
 //
 // Reading a large file in full is where an agent spends tokens without
@@ -490,7 +685,7 @@ export function readHintFor(opts: ReadHintInput): string | null {
     return (
       `fapony: ${shown} is ${lines} lines — review-seed --files ${shown} ` +
       `returns exports with line numbers, importers, and signatures first ` +
-      `(${READ_HINT_MEASURED})`
+      `(${READ_HINT_MEASURED}; skill /lookup-before-edit has the routine)`
     );
   } catch {
     return null;
@@ -633,6 +828,132 @@ export function rereadHintFor(opts: RereadHintInput): string | null {
   }
 }
 
+// --- Edit hint (PreToolUse annotate — importer count + once-per-session dedupe) ---
+//
+// Editing a file that has importers can silently break its consumers (measured:
+// 17.9% of changed nodes over 30 commits had a 1-hop blast radius; ~12-16% of
+// all-time fail rows were producer/consumer mismatches). The hint is a fact —
+// the importer count plus the review-seed command that lists them — never a
+// judgment about whether the edit is safe, and never a block.
+//
+// Dedupe is per (session, file): the first edit to a file fires, repeats stay
+// silent. The track log reuses the read-track session mechanism (sessionKey,
+// one jsonl per session) but lives in its own dir — sharing read-track's file
+// would make an Edit look like a Read and falsely trip the re-read hint. Like
+// rereadHintFor the track write happens inside this function (the caller-side
+// rule covers recordHintFire, not dedupe state); unlike it there is no mtime
+// comparison — an edit that moves mtime is still the same file in the same
+// session, and repeating the count buys nothing.
+
+const EDIT_TRACK_DIR = "edit-track";
+
+export interface EditTrackRow {
+  ts: string;
+  path: string;
+}
+
+/** Directory holding one edit log per session. */
+function editTrackDir(): string {
+  const base =
+    process.env.FAPONY_STATE_DIR || join(homedir(), ".config", "fapony");
+  return join(base, EDIT_TRACK_DIR);
+}
+
+/** Absolute path of a session's edit log — may not exist. */
+export function editTrackPath(session: string): string {
+  return join(editTrackDir(), `${sessionKey(session)}.jsonl`);
+}
+
+function editTrackPaths(session: string): Set<string> {
+  const p = editTrackPath(session);
+  if (!existsSync(p)) return new Set();
+  const out = new Set<string>();
+  for (const line of readFileSync(p, "utf-8").split("\n")) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line) as EditTrackRow;
+      if (typeof r.path === "string") out.add(r.path);
+    } catch {
+      // a torn line must not lose the rest of the log
+    }
+  }
+  return out;
+}
+
+function appendEditTrackRow(session: string, row: EditTrackRow): void {
+  const dir = editTrackDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  appendFileSync(editTrackPath(session), `${JSON.stringify(row)}\n`, "utf-8");
+}
+
+export interface EditHintInput {
+  filePath: unknown;
+  cwd: string;
+  /**
+   * Session identity — transcript path (Claude) or session id. Without it the
+   * hint still fires (the importer fact holds) but cannot dedupe.
+   */
+  session?: unknown;
+}
+
+/**
+ * Factual one-liner for editing a source file that has importers, or null.
+ * Every unknown (no path, non-source ext, new/unsaved file, outside the
+ * worktree, no git repo, graph failure) resolves to null — a hint must never
+ * fire on a guess. Files with importers are checked before the dedupe log is
+ * touched, so a file nobody imports never writes a track row.
+ */
+export function editHintFor(opts: EditHintInput): string | null {
+  try {
+    if (typeof opts.filePath !== "string" || opts.filePath === "") return null;
+    const dot = opts.filePath.lastIndexOf(".");
+    // SCAN_EXTS keys carry the dot (".ts") — slice from the dot itself.
+    if (dot < 0 || !SCAN_EXTS.has(opts.filePath.slice(dot))) return null;
+    // review-seed is a git command — outside a repo the hint would lie.
+    const git = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      cwd: opts.cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (git.exitCode !== 0) return null;
+    // macOS /var → /private/var: normalize both sides before comparing.
+    const worktree = realpathSync(git.stdout.toString().trim());
+    const abs = (() => {
+      const p = opts.filePath.startsWith("/")
+        ? opts.filePath
+        : join(opts.cwd, opts.filePath);
+      try {
+        return realpathSync(p);
+      } catch {
+        return null; // new file — nothing imports it yet
+      }
+    })();
+    if (!abs) return null;
+    const rel = relative(worktree, abs).split(sep).join("/");
+    if (rel.startsWith("..") || rel === "") return null;
+
+    const importers = buildGraphCached(worktree).dependents.get(rel);
+    if (!importers || importers.size === 0) return null;
+
+    if (typeof opts.session === "string" && opts.session !== "") {
+      if (editTrackPaths(opts.session).has(abs)) return null;
+      appendEditTrackRow(opts.session, {
+        ts: new Date().toISOString(),
+        path: abs,
+      });
+    }
+
+    const n = importers.size;
+    return (
+      `fapony: ${rel} has ${n} importer${n === 1 ? "" : "s"} — ` +
+      `review-seed --files ${rel} lists them (add --callers <export> for one ` +
+      `export's callers); check before changing its shape (skill /lookup-before-edit)`
+    );
+  } catch {
+    return null;
+  }
+}
+
 // --- Commit hint (tool.execute.after — annotate only, never block) ---
 //
 // OpenCode has no Stop hook (Cursor does — see cursor.ts hook-stop wiring)
@@ -835,6 +1156,80 @@ export async function cmdHookReadHint(): Promise<void> {
   }
 }
 
+/** Claude Code PreToolUse (matcher Edit): stdin JSON in, additionalContext out.
+ *  No permissionDecision ever — the edit always proceeds. Fires once per
+ *  (session, file); the dedupe lives inside editHintFor. */
+export async function cmdHookEditHint(): Promise<void> {
+  try {
+    const raw = JSON.parse(await Bun.stdin.text()) as {
+      cwd?: string;
+      transcript_path?: string;
+      session_id?: string;
+      tool_input?: {
+        file_path?: unknown;
+      };
+    };
+    const cwd = raw.cwd ?? process.cwd();
+    const filePath = raw.tool_input?.file_path;
+    // One edit log per session — same identity as the read hint.
+    const session = raw.transcript_path ?? raw.session_id;
+    const hint = editHintFor({ filePath, cwd, session });
+    if (hint) {
+      console.log(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: hint,
+          },
+        }),
+      );
+    }
+
+    // --- hint-fire log (PLAN-edit-importer-hint chunk 3) ---
+    // After output — best-effort, never block the hint.
+    if (hint) {
+      try {
+        const g = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+          cwd,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        if (g.exitCode === 0) {
+          const worktree = realpathSync(g.stdout.toString().trim());
+          const abs =
+            typeof filePath === "string"
+              ? (() => {
+                  try {
+                    return realpathSync(
+                      filePath.startsWith("/")
+                        ? filePath
+                        : join(worktree, filePath),
+                    );
+                  } catch {
+                    return null;
+                  }
+                })()
+              : null;
+          const rel = abs
+            ? relative(worktree, abs).split("\\").join("/")
+            : null;
+          recordHintFire({
+            ts: new Date().toISOString(),
+            worktree,
+            surface: "edit",
+            file: rel && !rel.startsWith("..") ? rel : null,
+            count: 1,
+          });
+        }
+      } catch {
+        // best-effort — swallow
+      }
+    }
+  } catch {
+    // any failure = no hint; a hook must never block an edit over a hint
+  }
+}
+
 // --- Debt + mem context (PLAN-convention-debt chunk 4) ---
 //
 // The one moment paying down debt is worth tokens is when the file is already

package/src/init-mem.ts

@@ -13,7 +13,7 @@ import {
   rmSync,
 } from "node:fs";
 import { join } from "node:path";
-import { loadConfig } from "./db/index.js";
+import { DEFAULT_MEM_DIR, FAPONY_DIR, loadConfig } from "./db/index.js";
 
 export function copyDir(src: string, dest: string): string[] {
   mkdirSync(dest, { recursive: true });
@@ -62,8 +62,8 @@ export function cmdInitMem(args: string[]): void {
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
         if (
           entry.isDirectory() &&
-          !entry.name.startsWith(".") &&
-          entry.name !== "node_modules"
+          entry.name !== "node_modules" &&
+          (!entry.name.startsWith(".") || entry.name === FAPONY_DIR)
         ) {
           walk(join(dir, entry.name), depth + 1);
         }
@@ -95,7 +95,7 @@ export function cmdInitMem(args: string[]): void {
           `keeping ${d} — has ${logs.length} log file(s): ${logs.join(", ")}`,
         );
         console.log(
-          `  move them under ${join(d, "..", ".fapony", ".memory")}/, or re-run with --force to delete`,
+          `  move them under ${DEFAULT_MEM_DIR}/, or re-run with --force to delete`,
         );
         kept++;
         continue;
@@ -109,7 +109,7 @@ export function cmdInitMem(args: string[]): void {
     console.log(
       `\nremoved ${removed} legacy .memory/ director${removed === 1 ? "y" : "ies"}${
         kept > 0
-          ? ` · kept ${kept} with logs — move them under .fapony/.memory/, then re-run`
+          ? ` · kept ${kept} with logs — move them under ${DEFAULT_MEM_DIR}/, then re-run`
           : ""
       }`,
     );

package/src/init.ts

@@ -17,6 +17,7 @@ import {
   type Config,
   doneDir,
   evidenceFile,
+  FAPONY_DIR,
   memoryDir,
   planDir,
   specDir,
@@ -108,7 +109,7 @@ export function initProject(targetPath: string, config?: Config): void {
   mkdirSync(targetPath, { recursive: true });
 
   // --- .fapony/ marker ---
-  const faponyDir = join(targetPath, ".fapony");
+  const faponyDir = join(targetPath, FAPONY_DIR);
   if (existsSync(faponyDir)) {
     throw new Error(
       `${faponyDir} already exists — delete it first if you want a fresh scaffold.`,
@@ -142,7 +143,7 @@ export function initProject(targetPath: string, config?: Config): void {
   writeFileSync(evidencePath, EVIDENCE_JSON);
 
   // --- plan/ spec/ .memory/ — all under .fapony/ ---
-  const planDirAbs = join(targetPath, planDir(config));
+  const planDirAbs = join(targetPath, planDir());
   if (existsSync(planDirAbs)) {
     throw new Error(`${planDirAbs} already exists — not overwriting.`);
   }
@@ -156,7 +157,7 @@ export function initProject(targetPath: string, config?: Config): void {
   mkdirSync(doneDirAbs, { recursive: true });
 
   // --- spec/ ---
-  const specDirAbs = join(targetPath, specDir(config));
+  const specDirAbs = join(targetPath, specDir());
   if (existsSync(specDirAbs)) {
     throw new Error(`${specDirAbs} already exists — not overwriting.`);
   }
@@ -177,9 +178,9 @@ export function initProject(targetPath: string, config?: Config): void {
   console.log(
     `  .fapony/         — project dir (plans, specs, memory, evidence)`,
   );
-  console.log(`  ${planDir(config)}/    — live plan files`);
+  console.log(`  ${planDir()}/    — live plan files`);
   console.log(`  ${doneDir(config)}/    — shipped plans (archive)`);
-  console.log(`  ${specDir(config)}/    — spec files`);
+  console.log(`  ${specDir()}/    — spec files`);
   console.log(
     `  ${evidenceFile(config)}    — allowlist for 'fapony report' (edit the cmds!)`,
   );