fapony 0.7.0 → 0.7.1

package/src/{mem/commands/plan.ts → plan/sweep.ts}

@@ -1,4 +1,5 @@
-// commands/plan.ts — plan-sweep: find PLAN-*.md whose header says shipped but not yet moved into done/
+// src/plan/sweep.ts — `fapony plan sweep` + `fapony plan check`.
+// sweep: find PLAN-*.md whose header says shipped but not yet moved into done/
 // rationale: moving by hand = chasing relative links yourself (in the file + files that link to it) → the step gets skipped often
 // no arg = report only (safe, shows every kickoff/stale run)
 // <file.md> = check a single file, is it ready to move
@@ -11,22 +12,26 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  realpathSync,
+  renameSync,
   writeFileSync,
 } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 
-import { openRows } from "../selectors.js";
-import {
-  doneDir,
-  memCmd,
-  nextId,
-  planBase,
-  planDir,
-  put,
-  rel,
-  root,
-  rows,
-} from "../store.js";
+import { type MemRow, readFaelLog } from "../fael.js";
+import { doneDir, planBase, planDir, rel, root } from "./store.js";
+
+// Open fael rows about a plan — matched by basename on files[] or spec, so a
+// row still counts after the plan moves plan/ → done/. One fael call per run.
+let openCache: { root: string; rows: MemRow[] } | null = null;
+export const openRowsFor = (planPath: string): MemRow[] => {
+  if (openCache?.root !== root)
+    openCache = { root, rows: readFaelLog(root, undefined, true).rows };
+  const name = basename(planPath);
+  return openCache.rows.filter((r) =>
+    [...(r.files ?? []), r.spec ?? ""].some((f) => basename(f) === name),
+  );
+};
 
 const SHIPPED = /^>\s*✅/m;
 const FRONT = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -284,7 +289,7 @@ export const hasShippedHeader = (file: string): boolean => {
   return !HELD.test(FRONT.exec(head)?.[1] ?? "");
 };
 
-export const planSweepCmd = `${memCmd} plan-sweep`;
+export const planSweepCmd = "fapony plan sweep";
 
 const mdFiles = (dir: string): string[] =>
   existsSync(dir)
@@ -411,16 +416,15 @@ export const cmdPlanSweep = (a: string[]) => {
   const apply = a.includes("--apply");
 
   if (!target) {
-    const all = rows();
     if (candidates.length) {
       console.log(
         `# plan-sweep — ${candidates.length} file(s) marked shipped but not archived\n`,
       );
       for (const name of candidates) {
         const spec = `${rel(dir)}/${name}`;
-        const openN = openRows(all).filter((r) => r.spec === spec).length;
+        const openN = openRowsFor(spec).filter((r) => r.kind === "bug").length;
         const warn = openN
-          ? `  ⚠ ${openN} open row(s) (next/bug/hold/decision/note) — check before moving`
+          ? `  ⚠ ${openN} open issue(s) (fael) — close before moving`
           : "";
         console.log(`- ${rel(dir)}/${name}${warn}`);
       }
@@ -443,7 +447,7 @@ export const cmdPlanSweep = (a: string[]) => {
       for (const f of blocked) {
         const { checked, unchecked } = countFirstSection(f);
         const spec = rel(f);
-        const openN = openRows(all).filter((r) => r.spec === spec).length;
+        const openN = openRowsFor(spec).length;
         const by = parsePlanFrontmatter(f).blockedByRaw ?? "?";
         console.log(
           `- ${spec} — ${checked}/${checked + unchecked} chunks · blocked_by: ${by}${openN ? ` · ⚠ ${openN} open row(s)` : ""}`,
@@ -467,9 +471,11 @@ export const cmdPlanSweep = (a: string[]) => {
   }
   const name = basename(src);
   const srcDir = dirname(src);
-  const shipped = hasShippedHeader(src);
+  const fm = parsePlanFrontmatter(src);
+  // superseded = closed without shipping; done/ is where closed plans live
+  const superseded = fm.status === "superseded";
+  const shipped = hasShippedHeader(src) || superseded;
   if (!apply) {
-    const fm = parsePlanFrontmatter(src);
     if (fm.status === "blocked") {
       console.log(
         `${target}: status:blocked (blocked_by: ${fm.blockedByRaw ?? "?"}) — not a move candidate, stays in plan/`,
@@ -477,9 +483,11 @@ export const cmdPlanSweep = (a: string[]) => {
       return;
     }
     console.log(
-      shipped
-        ? `${target}: has a ✅ shipped header — ready to move (add --apply)`
-        : `${target}: no ✅ shipped header at the top — check the whole file is actually done`,
+      superseded
+        ? `${target}: status:superseded — ready to move (add --apply)`
+        : shipped
+          ? `${target}: has a ✅ shipped header — ready to move (add --apply)`
+          : `${target}: no ✅ shipped header at the top — check the whole file is actually done`,
     );
     return;
   }
@@ -488,15 +496,17 @@ export const cmdPlanSweep = (a: string[]) => {
   // but then run --apply directly and skip everything → risky when an agent ships automatically with no human check, so hard block
   if (!shipped && !process.env.MEM_FORCE) {
     console.error(
-      `${name}: no ✅ shipped header at the top — refusing to move (MEM_FORCE=1 to override)`,
+      `${name}: no ✅ shipped header and not status:superseded — refusing to move (MEM_FORCE=1 to override)`,
     );
     process.exit(1);
   }
-  const openSpec = rel(src);
-  const openN = openRows(rows()).filter((r) => r.spec === openSpec);
+  // Notes and decisions are the plan's history and travel with it (basename
+  // match survives the move); only an open issue (MemRow kind "bug") is
+  // unfinished work.
+  const openN = openRowsFor(rel(src)).filter((r) => r.kind === "bug");
   if (openN.length && !process.env.MEM_FORCE) {
     console.error(
-      `${name}: still has ${openN.length} open row(s) (next/bug/hold/decision/note) — close them or move the spec first (MEM_FORCE=1 to override):\n` +
+      `${name}: still has ${openN.length} open issue(s) (fael) — close them first (MEM_FORCE=1 to override):\n` +
         openN.map((r) => `  [${r.id}] ${r.kind} ${r.text}`).join("\n"),
     );
     process.exit(1);
@@ -511,11 +521,22 @@ export const cmdPlanSweep = (a: string[]) => {
   // ponytail: a file just written this round may not be git add'ed yet — `git mv` fails silently (exit 128, no throw)
   // then the next code hits ENOENT reading a dst that does not exist — always stage first (no-op if already tracked)
   mkdirSync(doneDir, { recursive: true });
-  Bun.spawnSync(["git", "add", src]);
-  const mv = Bun.spawnSync(["git", "mv", src, dst]);
-  if (mv.exitCode !== 0) {
-    console.error(`git mv failed (${mv.stderr.toString().trim()}) — not moved`);
-    process.exit(1);
+  // a repo that gitignores .fapony/ (public repo, private plans) has nothing
+  // for git to move — `git add` refuses an ignored path, so rename instead
+  if (gitOk(["check-ignore", "-q", src], root)) {
+    renameSync(src, dst);
+    console.log(
+      `${rel(src)} is not tracked by git — moved with a plain rename`,
+    );
+  } else {
+    Bun.spawnSync(["git", "add", src]);
+    const mv = Bun.spawnSync(["git", "mv", src, dst]);
+    if (mv.exitCode !== 0) {
+      console.error(
+        `git mv failed (${mv.stderr.toString().trim()}) — not moved`,
+      );
+      process.exit(1);
+    }
   }
 
   // own links always need re-relativizing — the file changed directory even in
@@ -543,18 +564,6 @@ export const cmdPlanSweep = (a: string[]) => {
     `inbound links rewritten: ${inbound} in ${inboundFiles} file(s) (scanned ${rel(planBase)}/**)`,
   );
 
-  // log decision — record ship event (reuse existing kind, no new schema)
-  const doneSpec = `${rel(dst)}`;
-  put({
-    id: nextId(rows()),
-    kind: "decision",
-    text: `${name} shipped → ${rel(dst)}`,
-    spec: doneSpec,
-  });
-  // ponytail: this decision *is* the move itself, nothing to write back into the spec — do not mark synced
-  // immediately or staleReport shows "decision never made it into the spec" on every ship (seen in kickoff 2026-09-02)
-  put({ kind: "synced", spec: doneSpec });
-
   // the ship may unblock waiting plans — the dep graph lives in frontmatter,
   // so say which active plans name this file as their blocker (or were named
   // in this file's own blocks:). Detect-only: the dependent keeps
@@ -736,6 +745,18 @@ export const cmdPlanCheck = (a: string[]) => {
     let m: RegExpExecArray | null;
     while ((m = linkRe.exec(src)) !== null) {
       const target = m[1];
+      if (target?.startsWith("file://")) {
+        // works on the machine that wrote it, nowhere else — name the
+        // relative path instead of calling an existing file "broken"
+        const [abs] = decodeURI(target.slice("file://".length)).split("#");
+        const at = `${f.replace(`${dir}/`, "")}:${src.slice(0, m.index).split("\n").length}`;
+        issues.push(
+          abs && existsSync(abs)
+            ? `${at} — absolute file:// link → ${target} (works on this machine only)\n   fix: use ${relative(realpathSync(dirname(f)), realpathSync(abs))}`
+            : `${at} — broken link → ${target}\n   fix: correct the path or create the file it points at`,
+        );
+        continue;
+      }
       if (!target || /^(https?:|mailto:|\/)/.test(target)) continue;
       const [pathPart] = target.split("#");
       if (!pathPart) continue;
@@ -811,14 +832,13 @@ export const cmdPlanCheck = (a: string[]) => {
       (f) => parsePlanFrontmatter(f).status === "blocked",
     );
     if (blocked.length) {
-      const all = rows();
       console.log(
         `\nblocked plans (${blocked.length}) — waiting, not candidates:`,
       );
       for (const f of blocked) {
         const { checked, unchecked } = countFirstSection(f);
         const spec = rel(f);
-        const openN = openRows(all).filter((r) => r.spec === spec).length;
+        const openN = openRowsFor(spec).length;
         const by = parsePlanFrontmatter(f).blockedByRaw ?? "?";
         console.log(
           `- ${spec} — ${checked}/${checked + unchecked} chunks · blocked_by: ${by}${openN ? ` · ⚠ ${openN} open row(s)` : ""}`,

package/src/seed/plan-seed.ts

@@ -47,9 +47,8 @@ import {
   planDir,
   specDir,
 } from "../core/config.js";
-import { MEM_TEXT_MAX } from "../core/mem-log.js";
+import { readFaelLog, recentDecisions } from "../fael.js";
 import { extractExports } from "../map.js";
-import { readMemLog, readRecentMemDecisions } from "../memory.js";
 import { capLines, execGit, SIG_MAX } from "./primitives.js";
 
 // One chunk = one module's signatures — past ~40 lines a module is its own
@@ -63,6 +62,8 @@ const SCOPE_WARN_FILES = 300;
 // Shipped plans/specs that already touched this scope. Capped low on purpose:
 // this is a "go read that first" pointer, not a bibliography.
 const MAX_PRIOR_ART = 5;
+// Mem-row text budget in the Known traps block.
+const MEM_TEXT_MAX = 120;
 // Chunk 4 (PLAN-seed-and-surface): the PLAN names what is already in scope —
 // one line per scope file with its export names. SPEC-only seeds never gave
 // PLAN-only readers this pointer, so agents re-derived what export-lines.ts
@@ -241,7 +242,7 @@ function renderExistingInScope(
 
 function renderContextFapony(worktree: string): string {
   const lines: string[] = [];
-  const decisions = readRecentMemDecisions(worktree, 3).slice(0, 3);
+  const decisions = recentDecisions(readFaelLog(worktree).rows, 3);
   lines.push(
     decisions.length > 0
       ? `- Decisions on record (mem): ${decisions
@@ -250,7 +251,7 @@ function renderContextFapony(worktree: string): string {
               `"${d.text.length > 140 ? `${d.text.slice(0, 139)}…` : d.text}"`,
           )
           .join(" · ")}`
-      : "- Decisions on record (mem): _(none — no mem log or empty)_",
+      : "- Decisions on record (mem): _(none — no fael log or empty)_",
   );
   return lines.join("\n");
 }
@@ -305,7 +306,7 @@ One step = one chunk = one session: finish it, close it, **stop** — starting t
 
 1. _(agent fills in — each step must be verifiable)_
 
-**Closing a step:** tick TL;DR with sha · \`git commit\` files only · \`fapony mem add note "<what chunk N+1 must know>" --files <f1,f2> ${planRel}\` · next opens with \`kickoff ${planRel}\` (or \`kickoff PLAN-${name}.md\` — kickoff resolves by filename too).
+**Closing a step:** tick TL;DR with sha · \`git commit\` files only · \`fael add note "<what chunk N+1 must know>" --files <f1,f2>,${planRel}\` · next opens with \`fapony plan PLAN-${name}.md\` (unchecked chunks + those notes).
 - [ ] handoff: the mem note is the handoff — this box only opts the plan into the Stop-hook check
 
 ## 7. Examples
@@ -569,7 +570,7 @@ function specTemplate(
 //
 // The one place a seed is allowed to be opinionated: past pain about exactly
 // these files. bug rows first, then decision (note carries no "this hurt"
-// signal), newest first within a kind. Match mirrors mem_find: files[] first;
+// signal), newest first within a kind. Match mirrors fael find: files[] first;
 // the text/spec fallback runs ONLY for rows with no files[] at all — a row
 // that named files already spoke, its text may quote any path.
 //
@@ -601,8 +602,8 @@ export function renderKnownTraps(
 ): { lines: string[]; matched: number; lacked: number } {
   const empty = { lines: [], matched: 0, lacked: 0 };
   try {
-    const { rows, filesFound } = readMemLog(worktree);
-    if (filesFound === 0 || rows.length === 0) return empty;
+    const { rows } = readFaelLog(worktree);
+    if (rows.length === 0) return empty;
 
     const scopeFiles = new Set<string>();
     for (const r of roots)
@@ -637,7 +638,7 @@ export function renderKnownTraps(
     );
     const lacked = hits.filter((h) => h.viaText).length;
     const lines = [
-      "## Known traps (fapony mem)",
+      "## Known traps (fael)",
       "",
       `- ${hits.length} relevant row(s) on this scope (${lacked} lacked files[]${lacked > 0 ? " — matched via text" : ""})`,
     ];

package/src/setup.ts

@@ -62,7 +62,6 @@ export interface SetupDeps {
 export interface SetupAnswers {
   worktreeName: string;
   worktreePath: string;
-  enableMemory: boolean;
 }
 
 /** Pure config builder — the config-write path of cmdSetup, minus prompting.
@@ -77,15 +76,6 @@ export function buildSetupConfig(a: SetupAnswers): Record<string, unknown> {
     memory: null,
   };
 
-  if (a.enableMemory) {
-    config.memory = {
-      claim: ["fapony", "mem", "claim", "{id}"],
-      close: ["fapony", "mem", "close", "{id}", "{msg}"],
-      add: ["fapony", "mem", "add", "{kind}", "{text}"],
-      kickoff: ["fapony", "mem", "kickoff"],
-    };
-  }
-
   return config;
 }
 
@@ -159,12 +149,6 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
       defaultName,
     );
 
-    // --- memory ---
-    console.log();
-    const enableMemory = isAffirmative(
-      await askFn("Enable project memory? (y/n)", "n"),
-    );
-
     // --- write config ---
     // loadConfig() resolves to FAPONY_CONFIG or cwd/fapony.config.json, so a
     // cwd write is consistent — but warn when cwd isn't a fapony checkout,
@@ -179,7 +163,6 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
     const config = buildSetupConfig({
       worktreeName,
       worktreePath,
-      enableMemory,
     });
 
     const configPath = join(process.cwd(), CONFIG_FILENAME);
@@ -224,12 +207,11 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
   ┌─────────────────────────────────────────┐
   │  Setup complete! Next steps:            │
   │                                         │
-  │  1. Wire fapony into your MCP client:   │
-  │     fapony install --platform opencode  │
-  │     fapony install --platform claude    │
+  │  1. Wire fapony into your clients:      │
+  │     fapony install                      │
   │                                         │
-  │  2. Ask your agent:                     │
-  │     "Find past decisions with mem_find" │
+  │  2. See where your plans stand:         │
+  │     fapony plan                         │
   │                                         │
   │  3. Read a run's report:                │
   │     fapony report <run-id>              │

package/src/update.ts

@@ -155,7 +155,7 @@ export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
   if (isRepo !== "true") {
     console.error(`❌ ${ROOT} is not a git repo — cannot self-update.`);
     console.error(
-      "   Reinstall via: git clone https://github.com/kire21b/fapony.git",
+      "   Reinstall via: git clone https://github.com/inonix-dev/fapony.git",
     );
     exitFn(1);
   }

package/templates/PLAN.md

@@ -11,7 +11,7 @@ blocked_by: <plan or sentence>    # required when status: blocked
 blocks: PLAN-<other>.md           # plans that cannot start until this one lands (comma-separated)
 superseded_by: PLAN-<other>.md    # required when status: superseded
 spec: SPEC-<feature>.md           # if any
-priority: high                    # optional: high = appears first in kickoff · omit = normal
+priority: high                    # optional: high = listed first by `fapony plan` · omit = normal
 ---
 
 # PLAN-<feature>.md — <short name>

package/src/adapters/hooks/bug-markers.ts

@@ -1,60 +0,0 @@
-// src/adapters/hooks/bug-markers.ts — how fapony recognises "a bug was found".
-//
-// Split from stop.ts so the Stop hook (blocking, claude/cursor/codex) and the
-// OpenCode commit hint (advisory) share one definition. A bug that lives only
-// in a `note` row is not surfaced by anything, so the two signals are:
-//
-//   1. a structured commit-message token — `fix:` / `bugfix:` / `hotfix:`.
-//      Universal by construction: only the type token is English, so a Thai
-//      description on a conventional commit still reads as a bug
-//      (`fix(debt): ...`). This is the language-independent signal, and it is
-//      already how this repo commits (120/581 commits are fix-family).
-//   2. free-text announcement phrases — inherently per-language. A substring
-//      list cannot be universal; keep it small and open instead. Add your
-//      language here — do NOT invent a new row kind for it (open/closed is
-//      derived from close rows already; a kind would just drift).
-//
-// Deliberately NOT matched: symptom words ("broken", "dies silently"). They
-// appear in every bug report and would fire on any turn that reads one — the
-// Stop hook blocks once per session on a match, so a false positive is costly.
-
-/** Free-text announcement phrases ("I found a bug"), never symptom words.
- *  `g` flag is required — hasBugMarker walks every match (matchAll). */
-export const BUG_MARKERS: RegExp[] = [
-  /(?:เจอ|พบ)(?:ว่า)?(?:เป็น)?บั๊ก/g, // พบบั๊ก · พบว่าเป็นบั๊กจริง
-  /บั๊กที่(?:เจอ|พบ)/g,
-  /\bfound (?:a |the )?(?:real |actual )?bug\b/gi,
-  /\b(?:this|that|it)(?:'s| is) a (?:real )?bug\b/gi,
-  /\b(?:bug confirmed|confirmed (?:a |real )?bug)\b/gi,
-  /\bbug\b\s*(?:\([^)\n]{0,80}\))?\s*:/gi, // **Bug (cause…):**
-];
-
-// Negation / hypothetical right before a match ("ไม่พบบั๊ก", "จะเจอบั๊ก",
-// "not a bug"). Bare "เป็นบั๊ก" is deliberately not a marker: "อาจเป็นบั๊ก" is
-// everywhere and a false fire costs a Stop-hook block.
-const NEGATED = /(?:ไม่|จะ|ถ้า|อาจ|\bnot\s|\bno\s|\bif\s)\s*$/i;
-
-/**
- * The matched marker phrase, or null. Returns the matched text so the caller
- * can quote it back to the agent (stop.ts does, in its block reason). Every
- * match is checked, so "ไม่พบบั๊กใหม่ แต่เจอบั๊กที่ X" still fires on the second.
- */
-export function hasBugMarker(text: string): string | null {
-  for (const re of BUG_MARKERS) {
-    for (const m of text.matchAll(re)) {
-      const before = text.slice(Math.max(0, m.index - 15), m.index);
-      if (!NEGATED.test(before)) return m[0];
-    }
-  }
-  return null;
-}
-
-// Conventional-commit bug types, anchored to the subject prefix — arbitrary
-// prose containing "fix" ("pre-fix the cache") must not match. Language-free:
-// the type token stays English even when the description is not.
-const BUGFIX_COMMIT = /^(?:fix|bugfix|hotfix)(?:\([^)]*\))?!?:/;
-
-/** True when a commit subject declares a fix (the universal bug token). */
-export function isBugfixCommit(subject: string): boolean {
-  return BUGFIX_COMMIT.test(subject.trim());
-}

package/src/adapters/hooks/context-data.ts

@@ -1,211 +0,0 @@
-// src/adapters/hooks/context-data.ts — shared debt + mem context reader
-//
-// Split from src/hook.ts (PLAN-lib-layer chunk 3). Used by both read-hint and
-// edit-hint adapters to attach debt/mem lines when a file is open.
-
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  realpathSync,
-} from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import { collectSourceFiles, SCAN_EXTS } from "../../analyze/index.js";
-import { readTrackDir, sessionKey } from "../../core/hook-helpers.js";
-import { clipMemText, readMemLog } from "../../core/mem-log.js";
-import { debtForFile, resolveDebtScope } from "../../debt/index.js";
-import { movedTargets } from "../../mem/selectors.js";
-
-const DEBT_HINT_MAX = 3;
-const MEM_HINT_MAX = 2;
-
-export interface ContextLineData {
-  worktree: string;
-  debtIds: string[];
-  debtLines: string[];
-  memLines: string[];
-  /** Ids of open bugs actually emitted as OPEN BUG lines above (for the fire log). */
-  openBugIds: string[];
-  /** Ids of every mem row emitted in memLines (open bugs first) — joined to authors offline. */
-  memIds: string[];
-}
-
-/** Mem row ids already shown this session — a row repeats on every read/edit otherwise. */
-function shownPath(session: string): string {
-  return join(readTrackDir(), `${sessionKey(session)}.mem-shown`);
-}
-
-function readShown(session: string): Set<string> {
-  try {
-    const p = shownPath(session);
-    if (!existsSync(p)) return new Set();
-    return new Set(readFileSync(p, "utf-8").split("\n").filter(Boolean));
-  } catch {
-    return new Set();
-  }
-}
-
-function markShown(session: string, ids: string[]): void {
-  if (ids.length === 0) return;
-  try {
-    mkdirSync(readTrackDir(), { recursive: true });
-    appendFileSync(shownPath(session), `${ids.join("\n")}\n`, "utf-8");
-  } catch {
-    // a hint must never fail the tool call
-  }
-}
-
-/**
- * Structured data behind readContextLines — used by cmdHookReadHint for logging.
- * With a session, a non-bug mem row shows once per session (open bugs always
- * show: they are exact files[] matches and the point is to nag until closed).
- */
-export function readContextData(
-  filePath: unknown,
-  cwd: string,
-  session?: unknown,
-): ContextLineData | null {
-  try {
-    if (typeof filePath !== "string" || filePath === "") return null;
-    const git = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (git.exitCode !== 0) return null;
-    const worktree = realpathSync(git.stdout.toString().trim());
-    const abs = realpathSync(
-      filePath.startsWith("/") ? filePath : join(worktree, filePath),
-    );
-    const rel = relative(worktree, abs).split("\\").join("/");
-    if (rel.startsWith("..") || rel === "") return null;
-
-    const debtIds: string[] = [];
-    const debtLines: string[] = [];
-    const memLines: string[] = [];
-    const openBugIds: string[] = [];
-    const memIds: string[] = [];
-
-    // convention debt — source files only, fresh from the repo. The scope
-    // pairs the git root (repo-relative `where`) with the nearest
-    // conventions file — anchoring the load at the root goes silent in a
-    // monorepo with app-scoped conventions (bug mucvfaxk).
-    const dot = rel.lastIndexOf(".");
-    if (dot >= 0 && SCAN_EXTS.has(rel.slice(dot))) {
-      const scope = resolveDebtScope(dirname(abs));
-      for (const c of debtForFile(scope.scanRoot, abs, scope.loaded).slice(
-        0,
-        DEBT_HINT_MAX,
-      )) {
-        debtIds.push(c.id);
-        debtLines.push(`fapony debt: [${c.id}] ${c.rule}`);
-      }
-    }
-
-    // mem rows that are about this file — resolve the log from the file's own
-    // directory, not the repo root. In a monorepo the log is app-scoped, so
-    // anchoring at the root sees only an out-of-scope candidate and goes silent
-    // even though the file being touched sits right under its log (bug muc9q47r).
-    const mem = readMemLog(dirname(abs));
-    if (mem.rows.length > 0) {
-      // PLAN-mem-core chunk 5 — follow moves: a row naming old/a.ts still
-      // shows when the file now lives at new/a.ts, as long as no other a.ts
-      // exists on disk. Missing = stat-miss on the worktree-joined path; the
-      // tree walk runs only when some row actually names a missing file.
-      const missingOld = new Set<string>();
-      for (const r of mem.rows)
-        for (const f of r.files ?? [])
-          if (f !== rel && !existsSync(join(worktree, f))) missingOld.add(f);
-      const moved =
-        missingOld.size > 0
-          ? movedTargets([...missingOld], collectSourceFiles(worktree))
-          : null;
-      const filesOf = (r: (typeof mem.rows)[number]): string[] =>
-        (r.files ?? []).map((f) => moved?.get(f) ?? f);
-      const movedFrom = (r: (typeof mem.rows)[number]): string => {
-        const from = (r.files ?? []).find(
-          (f) => f !== rel && moved?.get(f) === rel,
-        );
-        return from ? ` (moved from ${from})` : "";
-      };
-      // Open bugs first (PLAN-active-pain chunk 3): a kind:"bug" row whose id
-      // is in no close row's ref — the same tombstone shape as openRows in
-      // src/mem/selectors.ts, never a regex on text. Exact files[] match only:
-      // a bug row with no files[] stays silent rather than guessed at.
-      const closed = new Set(
-        mem.rows.filter((r) => r.kind === "close").map((r) => r.ref),
-      );
-      const openLines: string[] = [];
-      for (const r of mem.rows) {
-        if (openLines.length >= MEM_HINT_MAX) break;
-        if (r.kind !== "bug" || !r.id || closed.has(r.id)) continue;
-        if (!filesOf(r).includes(rel)) continue;
-        openLines.push(
-          `fapony mem: OPEN BUG ${r.id} — "${clipMemText(r.text)}" — ปิดด้วย fapony mem close ${r.id} "<msg>" เมื่อแก้แล้ว${movedFrom(r)}`,
-        );
-        openBugIds.push(r.id);
-      }
-      const base = basename(rel);
-      // Tiers: files[] names this file > text/spec mentions the path >
-      // basename-only. readMemLog is newest first, so each tier is too.
-      const exact: typeof mem.rows = [];
-      const mention: typeof mem.rows = [];
-      const baseOnly: typeof mem.rows = [];
-      for (const r of mem.rows) {
-        if (r.kind === "claim" || r.kind === "release" || r.kind === "close") {
-          continue;
-        }
-        if (filesOf(r).includes(rel)) {
-          exact.push(r);
-          continue;
-        }
-        const hay = `${r.text}\n${r.spec ?? ""}\n${(r.files ?? []).join(",")}`;
-        if (hay.includes(rel)) mention.push(r);
-        else if (base && hay.includes(base)) baseOnly.push(r);
-      }
-      let usableBase = baseOnly;
-      if (baseOnly.length > 0) {
-        const sameName = collectSourceFiles(worktree).filter(
-          (f) => basename(f) === base,
-        ).length;
-        if (sameName !== 1) usableBase = [];
-      }
-      const shown =
-        typeof session === "string" && session !== ""
-          ? readShown(session)
-          : null;
-      // Open lines take the closed rows' slots first; the rest fills the
-      // remaining budget without adding lines past the cap — and without
-      // repeating a row already emitted as OPEN BUG or shown this session.
-      const emitted = new Set(openBugIds);
-      const rest = [exact, mention, usableBase]
-        .flat()
-        .filter((r) => !(r.id && (emitted.has(r.id) || shown?.has(r.id))))
-        .slice(0, MEM_HINT_MAX - openLines.length);
-      for (const line of openLines) memLines.push(line);
-      memIds.push(...openBugIds);
-      const restIds: string[] = [];
-      for (const r of rest) {
-        if (r.id) restIds.push(r.id);
-        memLines.push(
-          `fapony mem: ${r.ts.slice(0, 10)} ${r.kind} — ${clipMemText(r.text)}${movedFrom(r)}`,
-        );
-      }
-      memIds.push(...restIds);
-      if (shown && typeof session === "string") markShown(session, restIds);
-    }
-    return { worktree, debtIds, debtLines, memLines, openBugIds, memIds };
-  } catch {
-    return null;
-  }
-}
-
-export function readContextLines(filePath: unknown, cwd: string): string[] {
-  const data = readContextData(filePath, cwd);
-  if (!data) return [];
-  return [...data.debtLines, ...data.memLines].slice(
-    0,
-    DEBT_HINT_MAX + MEM_HINT_MAX,
-  );
-}