fapony 0.3.3 → 0.3.5

package/src/mem/commands/plan.ts

@@ -2,8 +2,9 @@
 // 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
-// <file.md> --apply = git mv + fix markdown links inside the file + fix inbound links from other files in plan/
-//                      + warn about plain-text mentions (detect-only, no auto-fix)
+// <file.md> --apply = git mv + fix markdown links inside the file + fix inbound links from every .md under .fapony/
+//                      (plan/ + done/ + spec/) + warn about plain-text mentions (detect-only, no auto-fix)
+//                      + warn about tracked files outside .fapony/ that mention the filename (detect-only)
 
 import {
   existsSync,
@@ -12,10 +13,20 @@ import {
   readFileSync,
   writeFileSync,
 } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 
 import { openRows } from "../selectors.js";
-import { doneDir, memCmd, nextId, planDir, put, rel, rows } from "../store.js";
+import {
+  doneDir,
+  memCmd,
+  nextId,
+  planBase,
+  planDir,
+  put,
+  rel,
+  root,
+  rows,
+} from "../store.js";
 
 const SHIPPED = /^>\s*✅/m;
 const FRONT = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -52,6 +63,11 @@ const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 // the file moved dir (same content) — an old markdown link meant the old path relative to oldDir, must re-relativize via newDir
 // resolve from newDir (where the file is now) — if the target also moved to the same dir → plain filename,
 // if the target stayed in oldDir → ../target (both correct)
+//
+// Runs on EVERY move, including the standard sibling layout (plan/ → done/ beside
+// it): same depth is not the same directory, so a sibling link like
+// [other](PLAN-other.md) breaks unless rewritten to ../plan/PLAN-other.md.
+// Skipping this pass left exactly that dangling (mtjn3ldk).
 // pass 1 only — fix only [text](target) markdown links, do not touch plain text
 export const rewriteMovedFileLinks = (
   file: string,
@@ -65,11 +81,17 @@ export const rewriteMovedFileLinks = (
     const [target, anchor] = t.split("#");
     if (!target || /^(https?:|mailto:|\/)/.test(target)) return m;
     // resolve from where the file IS now (newDir); if target doesn't exist
-    // there, fall back to oldDir (target stayed in original location)
+    // there, fall back to oldDir (target stayed in original location).
+    // If it exists in neither, the link is already broken — leave it for
+    // plan-check instead of fabricating a new broken path.
     const inNew = resolve(newDir, target);
-    const abs = existsSync(inNew) ? inNew : resolve(oldDir, target);
+    const inOld = resolve(oldDir, target);
+    const abs = existsSync(inNew) ? inNew : existsSync(inOld) ? inOld : null;
+    if (!abs) return m;
+    const next = `](${relative(newDir, abs) || "."}${anchor ? `#${anchor}` : ""})`;
+    if (next === m) return m;
     n++;
-    return `](${relative(newDir, abs) || "."}${anchor ? `#${anchor}` : ""})`;
+    return next;
   });
 
   if (n) writeFileSync(file, out);
@@ -172,11 +194,20 @@ export const cmdPlanSweep = (a: string[]) => {
     return;
   }
 
-  const src = join(dir, target);
-  if (!existsSync(src)) {
-    console.error(`${rel(src)} not found`);
+  // target arrives as a bare name (PLAN-x.md, the SKILL form) or a repo-relative
+  // path (.fapony/plan/PLAN-x.md, the example form) — both must resolve, so try
+  // planDir first, then the repo root, then the bare basename as a last resort.
+  const src = [
+    join(dir, target),
+    join(root, target),
+    join(dir, basename(target)),
+  ].find((p) => existsSync(p));
+  if (!src) {
+    console.error(`${target} not found (looked in ${rel(dir)}/ and repo root)`);
     process.exit(1);
   }
+  const name = basename(src);
+  const srcDir = dirname(src);
   const shipped = hasShippedHeader(src);
   if (!apply) {
     console.log(
@@ -191,21 +222,21 @@ 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(
-      `${target}: no ✅ shipped header at the top — refusing to move (MEM_FORCE=1 to override)`,
+      `${name}: no ✅ shipped header at the top — refusing to move (MEM_FORCE=1 to override)`,
     );
     process.exit(1);
   }
-  const openSpec = `${rel(dir)}/${target}`;
+  const openSpec = rel(src);
   const openN = openRows(rows()).filter((r) => r.spec === openSpec);
   if (openN.length && !process.env.MEM_FORCE) {
     console.error(
-      `${target}: 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 row(s) (next/bug/hold/decision/note) — close them or move the spec first (MEM_FORCE=1 to override):\n` +
         openN.map((r) => `  [${r.id}] ${r.kind} ${r.text}`).join("\n"),
     );
     process.exit(1);
   }
 
-  const dst = join(doneDir, target);
+  const dst = join(doneDir, name);
   if (existsSync(dst)) {
     console.error(`${rel(dst)} already exists`);
     process.exit(1);
@@ -221,14 +252,17 @@ export const cmdPlanSweep = (a: string[]) => {
     process.exit(1);
   }
 
-  // done/ is a sibling of plan/ = same depth, links in the file still resolve, no need to touch
-  // the old layout (plan/done/) is one level deeper, so it does need re-relativizing
-  const nested = dirname(doneDir) !== dirname(dir);
-  const ownLinks = nested ? rewriteMovedFileLinks(dst, dir, doneDir) : 0;
+  // own links always need re-relativizing — the file changed directory even in
+  // the sibling layout (plan/ → done/ beside it), so sibling links dangle
+  // unless rewritten (see rewriteMovedFileLinks).
+  const ownLinks = rewriteMovedFileLinks(dst, srcDir, doneDir);
 
+  // inbound: every .md under .fapony/ can link here — other active plans,
+  // shipped plans in done/ (they reference each other), and specs. Scanning
+  // plan/ only left done/+spec/ links dangling (mtl15q4y).
   let inbound = 0;
   let inboundFiles = 0;
-  for (const f of mdFiles(dir)) {
+  for (const f of mdFiles(planBase)) {
     if (f === dst) continue;
     const n = rewriteMarkdownLinks(f, src, dst);
     if (n) {
@@ -238,13 +272,9 @@ export const cmdPlanSweep = (a: string[]) => {
   }
 
   console.log(`moved ${rel(src)} → ${rel(dst)}`);
+  console.log(`links rewritten inside the file: ${ownLinks}`);
   console.log(
-    nested
-      ? `links rewritten inside the file: ${ownLinks}`
-      : `links rewritten inside the file: 0 (same depth, existing links still resolve)`,
-  );
-  console.log(
-    `inbound links rewritten: ${inbound} in ${inboundFiles} file(s) (scanned ${rel(dir)}/** only)`,
+    `inbound links rewritten: ${inbound} in ${inboundFiles} file(s) (scanned ${rel(planBase)}/**)`,
   );
 
   // log decision — record ship event (reuse existing kind, no new schema)
@@ -252,7 +282,7 @@ export const cmdPlanSweep = (a: string[]) => {
   put({
     id: nextId(rows()),
     kind: "decision",
-    text: `${target} shipped → ${rel(dst)}`,
+    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
@@ -262,40 +292,124 @@ export const cmdPlanSweep = (a: string[]) => {
   // plain-text mention detection (detect-only, no auto-fix)
   let plainTextTotal = 0;
   const plainTextFiles: string[] = [];
-  for (const f of mdFiles(dir)) {
-    const n = countPlainTextMentions(f, target);
+  for (const f of mdFiles(planBase)) {
+    if (f === dst) continue;
+    const n = countPlainTextMentions(f, name);
     if (n) {
       plainTextTotal += n;
-      plainTextFiles.push(f.replace(`${dir}/`, ""));
+      plainTextFiles.push(f.replace(`${planBase}/`, ""));
     }
   }
   if (plainTextTotal > 0) {
     console.log(
-      `⚠ ${plainTextTotal} plain-text mention(s) in ${plainTextFiles.length} file(s) under ${rel(dir)}/ — grep and update the paths yourself:\n${plainTextFiles.join("\n")}`,
+      `⚠ ${plainTextTotal} plain-text mention(s) in ${plainTextFiles.length} file(s) under ${rel(planBase)}/ — grep and update the paths yourself:\n${plainTextFiles.join("\n")}`,
     );
   }
 
-  // files outside plan/ that mention the target — detect-only
-  const grep = Bun.spawnSync([
-    "git",
-    "grep",
-    "-l",
-    target,
-    "--",
-    // the "files outside plan/" scope = the folder plan/ lives under (apps/vela, .fapony, …)
-    rel(dirname(planDir)),
-    `:!${rel(dir)}`,
-  ])
+  // files outside .fapony/ that mention the filename — detect-only.
+  // Everything under planBase/ was auto-fixed above, so what remains is repo
+  // docs and prose (README, docs/, CLAUDE.md) with hand-written paths.
+  // cwd: root — the pathspecs are root-relative no matter where fapony runs from.
+  const grep = Bun.spawnSync(
+    ["git", "grep", "-l", name, "--", ".", `:!${rel(planBase)}`],
+    { cwd: root },
+  )
     .stdout.toString()
     .trim();
   if (grep)
     console.log(
-      `⚠ files outside ${rel(dir)}/ still mention "${target}" — check them yourself (not auto-fixed):\n${grep}`,
+      `⚠ files outside ${rel(planBase)}/ still mention "${name}" — check them yourself (not auto-fixed):\n${grep}`,
     );
 };
 
 // plan-check — list active PLANs + detect shipped-not-moved + broken links
+// + verify the commits ticked chunks cite (chunk 8, PLAN-seed-and-surface)
 // exit 0 = clean, 1 = issues found
+
+// A ticked chunk cites the commit that closed it — a sha git cannot find on
+// this HEAD means the "done" mark proves nothing. git is the judge, not the
+// regex: a 7-hex word that is no object at all (deadbee) is a plain word,
+// never an issue. A sha that IS an object but not a commit (blob/tree)
+// counts as missing — "no such commit" is literally true for it.
+// Standalone short shas only — lookarounds (not \b) so a 40-char sha never
+// matches on its tail: git resolves leading prefixes, a trailing slice would
+// false-positive as missing.
+export const SHA_RE = /(?<![0-9a-f])[0-9a-f]{7,12}(?![0-9a-f])/g;
+
+export const extractShas = (line: string): string[] => line.match(SHA_RE) ?? [];
+
+const gitOk = (args: string[], cwd: string): boolean => {
+  try {
+    return (
+      Bun.spawnSync(["git", ...args], {
+        cwd,
+        stdout: "ignore",
+        stderr: "ignore",
+      }).exitCode === 0
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const isCommitObject = (sha: string, cwd: string): boolean =>
+  gitOk(["cat-file", "-e", `${sha}^{commit}`], cwd);
+
+const isAnyObject = (sha: string, cwd: string): boolean =>
+  gitOk(["cat-file", "-e", sha], cwd);
+
+export const isAncestorOfHead = (sha: string, cwd: string): boolean =>
+  gitOk(["merge-base", "--is-ancestor", sha, "HEAD"], cwd);
+
+// Per ticked line: which cited shas fail, plus how many shas the line cites
+// at all (cited). A hex word git never heard of is a plain word (deadbee,
+// the "feedbac" inside "feedback") — UNLESS it sits in a paren group with a
+// sha git knows, in which case the author cited it as a commit: the fixture
+// is (e898877 + e307fe6), where e898877 resolves to no object at all yet is
+// unmistakably a citation, not prose.
+export const checkTickedLine = (
+  line: string,
+  cwd: string,
+): { missing: string[]; diverged: string[]; cited: number } => {
+  const missing: string[] = [];
+  const diverged: string[] = [];
+  const status = new Map<string, "commit" | "object" | "word">();
+  for (const sha of extractShas(line)) {
+    if (!status.has(sha)) {
+      status.set(
+        sha,
+        isCommitObject(sha, cwd)
+          ? "commit"
+          : isAnyObject(sha, cwd)
+            ? "object"
+            : "word",
+      );
+    }
+  }
+  const known = new Set(
+    [...status].filter(([, s]) => s !== "word").map(([k]) => k),
+  );
+  const citedInGroup = new Set<string>();
+  for (const g of line.match(/\([^)]*\)/g) ?? []) {
+    const gs = extractShas(g);
+    if (gs.some((s) => known.has(s))) for (const s of gs) citedInGroup.add(s);
+  }
+  let cited = 0;
+  for (const [sha, st] of status) {
+    if (st === "commit") {
+      cited++;
+      if (!isAncestorOfHead(sha, cwd)) diverged.push(sha);
+    } else if (st === "object") {
+      cited++;
+      missing.push(sha);
+    } else if (citedInGroup.has(sha)) {
+      cited++;
+      missing.push(sha);
+    }
+    // else: a plain word that happens to be hex — skip
+  }
+  return { missing, diverged, cited };
+};
 export const cmdPlanCheck = (a: string[]) => {
   const quiet = a.includes("--quiet");
   const dir = planDir;
@@ -347,6 +461,47 @@ export const cmdPlanCheck = (a: string[]) => {
     }
   }
 
+  // 4) Ticked-chunk sha check — a ticked chunk that cites a commit must cite
+  //    one git finds on this HEAD. Scans plan/ AND done/: done/ files are the
+  //    shipped record, and the known-stale shas all live there — active-only
+  //    would see zero. No sha = no check (chunks that close with "defer" have
+  //    no commit); the summary line reports the ratio instead of flagging.
+  let closed = 0;
+  let citing = 0;
+  let verified = 0;
+  const shaFiles = [
+    ...new Set([...active, ...(existsSync(doneDir) ? mdFiles(doneDir) : [])]),
+  ];
+  for (const f of shaFiles) {
+    const relPath = relative(planBase, f);
+    const lines = readFileSync(f, "utf8").split("\n");
+    lines.forEach((line, i) => {
+      if (!/^\s*-\s\[x\]/.test(line)) return;
+      closed++;
+      const { missing, diverged, cited } = checkTickedLine(line, root);
+      if (cited > 0) {
+        citing++;
+        if (!missing.length && !diverged.length) verified++;
+      }
+      for (const sha of missing) {
+        issues.push(
+          `${relPath}:${i + 1} — ticked chunk cites ${sha} but git has no such commit\n   fix: correct the sha or leave the chunk unticked`,
+        );
+      }
+      for (const sha of diverged) {
+        issues.push(
+          `${relPath}:${i + 1} — ticked chunk cites ${sha} which is not an ancestor of HEAD (rebased away?)\n   fix: point at the surviving commit or leave the chunk unticked`,
+        );
+      }
+    });
+  }
+
+  if (!quiet) {
+    console.log(
+      `closed chunks: ${closed} · citing a commit: ${citing} · verified: ${verified}`,
+    );
+  }
+
   if (issues.length === 0) {
     if (!quiet) console.log("✅ clean");
     process.exit(0);

package/src/mem/commands/read.ts

@@ -7,7 +7,7 @@ import { doneLines, fmtClose, fmtRow } from "../render.js";
 import { claimsOf, openRows, staleReport } from "../selectors.js";
 import type { CloseRow, WorkRow } from "../store.js";
 import { allRows, app, memCmd, planDir, root, rows } from "../store.js";
-import { planSweepCmd, shippedNotMoved } from "./plan.js";
+import { checkTickedLine, planSweepCmd, shippedNotMoved } from "./plan.js";
 import { THRESHOLD } from "./rotate.js";
 
 /** Files changed on this branch vs dev — empty set when dev is missing or diff fails. */
@@ -93,30 +93,56 @@ export const cmdFind = (a: string[]) => {
   if (!hits.length) console.log("(no matches)");
 };
 
-/** Read a plan file and extract unchecked checkboxes from the TL;DR section. */
-const readPlanCheckboxes = (planPath: string): string[] => {
+/** Read a plan file and extract checked + unchecked items from the first ## section. */
+const readPlanSectionItems = (
+  planPath: string,
+): { checked: string[]; unchecked: string[] } => {
   try {
     const text = readFileSync(planPath, "utf8");
     // Skip frontmatter
     const body = text.replace(/^---\r?\n[\s\S]*?\r?\n---/, "");
     // Find the first ## section (TL;DR)
     const start = body.search(/^##\s+/m);
-    if (start < 0) return [];
+    if (start < 0) return { checked: [], unchecked: [] };
     const rest = body.slice(start);
     const next = rest.slice(3).search(/^##\s+/m);
     const block = next < 0 ? rest : rest.slice(0, next + 3);
-    // Extract unchecked checkboxes
-    const items: string[] = [];
+    // Extract checkboxes — ticked and unticked
+    const checked: string[] = [];
+    const unchecked: string[] = [];
     for (const line of block.split("\n")) {
-      const m = /^\s*[-*]\s+\[\s\]\s+(.+)$/.exec(line);
-      if (m) items.push(m[1].trim());
+      let m = /^\s*[-*]\s+\[\s\]\s+(.+)$/.exec(line);
+      if (m) {
+        unchecked.push(m[1].trim());
+        continue;
+      }
+      m = /^\s*[-*]\s+\[[xX]\]\s+(.+)$/.exec(line);
+      if (m) checked.push(m[1].trim());
     }
-    return items;
+    return { checked, unchecked };
   } catch {
-    return [];
+    return { checked: [], unchecked: [] };
   }
 };
 
+// Chunk 9 (PLAN-seed-and-surface): one line under the next-chunk display
+// saying whether the last ticked chunk actually closed. Verified shas stay
+// silent; only the newest ticked chunk is ever mentioned — one line per
+// kickoff, never a list (else vela's 64/72 sha-less chunks become noise).
+const closureHint = (checked: string[]): string | null => {
+  const last = checked[checked.length - 1];
+  if (!last) return null;
+  const { missing, diverged, cited } = checkTickedLine(last, root);
+  const label = /chunk\s+([^\s—–-]+)/i.exec(last)?.[1] ?? "latest";
+  if (missing.length)
+    return `⚠ chunk ${label} is ticked but ${missing[0]} is not in git — nothing proves it closed`;
+  if (diverged.length)
+    return `⚠ chunk ${label} is ticked but ${diverged[0]} is not on HEAD (rebased away?)`;
+  if (!cited)
+    return `⚠ chunk ${label} is ticked but cites no commit — nothing to verify it closed`;
+  return null;
+};
+
 /** Check if a plan has `priority: high` in its frontmatter. */
 const hasHighPriority = (planPath: string): boolean => {
   try {
@@ -200,6 +226,7 @@ export const cmdKickoff = (a: string[]) => {
   // If no arg or arg didn't match an id/spec, check if it's a plan file
   let planFile: string | null = null;
   let planCheckboxes: string[] = [];
+  let planChecked: string[] = [];
 
   if (arg && !resolvedSpec && !target) {
     if (matches.length === 1) {
@@ -233,14 +260,18 @@ export const cmdKickoff = (a: string[]) => {
 
   // Read plan file if we found one (or if a .md arg matched a spec)
   if (planFile) {
-    planCheckboxes = readPlanCheckboxes(planFile);
+    const items = readPlanSectionItems(planFile);
+    planCheckboxes = items.unchecked;
+    planChecked = items.checked;
   } else if (arg && resolvedSpec && arg.endsWith(".md")) {
     // The spec resolved from the log might be a plan file — try to read it
     const dir = planDir;
     const byName = join(dir, basename(arg));
     if (existsSync(byName)) {
       planFile = byName;
-      planCheckboxes = readPlanCheckboxes(planFile);
+      const items = readPlanSectionItems(planFile);
+      planCheckboxes = items.unchecked;
+      planChecked = items.checked;
     }
   }
 
@@ -466,6 +497,12 @@ export const cmdKickoff = (a: string[]) => {
     if (!specRows.length && !specDecisions.length && !specCloses.length) {
       console.log("(no entries for this spec)");
     }
+    // The spec is also a plan file on disk — say whether the last ticked
+    // chunk actually closed (chunk 9). Silent when it verifies.
+    if (planFile) {
+      const hint = closureHint(planChecked);
+      if (hint) console.log(`\n${hint}`);
+    }
   } else if (target) {
     // id = a brief for that task
     const claims = claimsOf(all);
@@ -525,6 +562,10 @@ export const cmdKickoff = (a: string[]) => {
     } else {
       console.log(`\n(all chunks checked — ready to ship or archive)`);
     }
+    // Whether the last ticked chunk actually closed (chunk 9) — one line,
+    // silent when its sha verifies.
+    const hint = closureHint(planChecked);
+    if (hint) console.log(hint);
   } else if (arg) {
     console.error(`no id "${arg}" in the log`);
     process.exit(1);

package/src/mem/index.ts

@@ -3,6 +3,9 @@
 // Moved from templates/mem/mem.ts (2026-09-19) as part of PLAN-agent-one-call chunk 1.
 // Now an export function called by fapony.ts, not a standalone script.
 
+import { existsSync } from "node:fs";
+import { basename, join } from "node:path";
+import { levenshtein } from "../commands.js";
 import { cmdPlanCheck, cmdPlanSweep } from "./commands/plan.js";
 import { cmdDone, cmdFind, cmdKickoff, cmdStale } from "./commands/read.js";
 import { cmdRotate } from "./commands/rotate.js";
@@ -15,6 +18,7 @@ import {
   cmdRelease,
   cmdSynced,
 } from "./commands/write.js";
+import { doneDir, planDir } from "./store.js";
 
 const MEM_HELP = `usage: fapony mem [--mem-dir <path>] <sub> [args]
 
@@ -86,6 +90,42 @@ reads the Stop-hook payload on stdin — installed by fapony, not run by hand
 example: (installed hook only)`,
 };
 
+// Subcommand names for top-level did-you-mean (src/commands.ts) — derived
+// from HELP keys so the list cannot drift from the dispatch below.
+export const MEM_SUBCOMMANDS: string[] = Object.keys(HELP);
+
+// Chunk 7 (PLAN-seed-and-surface, bug muc85pml): `fapony mem now` used to fall
+// through to kickoff and print an overview ("N entries") instead of an error —
+// a typo that looks like success. Three rules, in order:
+//   1. a known subcommand → dispatch (unchanged)
+//   2. looks like a plan path (.md suffix, a slash, or a file with that name
+//      in planDir/doneDir) → kickoff — this is `fapony mem PLAN-x.md`, which
+//      must keep working without the `kickoff` word
+//   3. anything else → error, exit 1 (a typo is never a kickoff)
+//
+// `exists` is injectable so tests hit this directly without a store on disk —
+// production passes nothing and reads planDir/doneDir live.
+export function classifyMemArg(
+  arg: string,
+  exists?: (name: string) => boolean,
+): "subcommand" | "plan" | "unknown" {
+  // hasOwn, not `in` or indexing — prototype props ("toString") are not
+  // subcommands.
+  if (Object.hasOwn(HELP, arg)) return "subcommand";
+  if (arg.endsWith(".md") || arg.includes("/")) return "plan";
+  const has =
+    exists ??
+    ((name: string): boolean => {
+      const base = basename(name);
+      const candidates = [name, base, `${name}.md`, `${base}.md`];
+      return candidates.some(
+        (c) => existsSync(join(planDir, c)) || existsSync(join(doneDir, c)),
+      );
+    });
+  if (has(arg)) return "plan";
+  return "unknown";
+}
+
 export async function cmdMem(a: string[], memDir?: string): Promise<void> {
   const [cmd, ...rest] = a;
 
@@ -128,8 +168,27 @@ export async function cmdMem(a: string[], memDir?: string): Promise<void> {
     cmdPlanCheck(rest);
   } else if (cmd === "rotate") {
     cmdRotate(rest);
-  } else {
+  } else if (cmd === undefined) {
     // bare `fapony mem` → kickoff (ranked session overview)
     cmdKickoff(rest);
+  } else if (classifyMemArg(cmd) === "plan") {
+    // `fapony mem PLAN-x.md` — the plan arg rides along (the old else-branch
+    // dropped it and printed the no-arg overview instead).
+    cmdKickoff([cmd, ...rest]);
+  } else {
+    console.error(`fapony mem: unknown subcommand "${cmd}"`);
+    const scored = MEM_SUBCOMMANDS.map((s) => ({
+      s,
+      d: levenshtein(cmd, s),
+    }))
+      .filter((x) => x.d <= 2)
+      .sort((x, y) => x.d - y.d || (x.s < y.s ? -1 : 1))
+      .slice(0, 3)
+      .map((x) => `"fapony mem ${x.s}"`);
+    if (scored.length > 0) {
+      console.error(`did you mean ${scored.join(" or ")}?`);
+    }
+    console.error(`subcommands: ${MEM_SUBCOMMANDS.join(" ")}`);
+    process.exit(1);
   }
 }

package/src/mem/store.ts

@@ -15,7 +15,11 @@ import {
 } from "node:fs";
 import { hostname, networkInterfaces } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
-import { CONFIG_FILENAME, DEFAULT_MEM_DIR, FAPONY_DIR } from "../db/index.js";
+import {
+  CONFIG_FILENAME,
+  DEFAULT_MEM_DIR,
+  FAPONY_DIR,
+} from "../core/config.js";
 import { whereMemDir } from "../memory.js";
 
 // --- types ---