fapony 0.6.2 → 0.7.1

package/src/mem/commands/rotate.ts

@@ -1,59 +0,0 @@
-// commands/rotate.ts — compact log.jsonl once it grows past a row-count threshold
-// keep open work rows + active claims; the rest (close/release/synced of already-closed refs)
-// is git mv'd to a separate archive file (not deleted) — old history remains, searchable via git log/git show
-
-import { existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { rotateKeep } from "../selectors.js";
-import { appendRaw, dir, LOG, rows } from "../store.js";
-
-// ponytail: threshold = total row count, not just open — the fear is a bloated file / slow grep when many people use it at once
-// (the view being unreadable is a separate problem the CAP in write.ts already handles)
-// 3000 estimated from one solo week = ~2k rows — tune with MEM_ROTATE_THRESHOLD if the pace differs a lot from this
-export const THRESHOLD = Number(process.env.MEM_ROTATE_THRESHOLD) || 3000;
-
-export const cmdRotate = (a: string[]) => {
-  const apply = a.includes("--apply");
-  const all = rows();
-  const over = all.length >= THRESHOLD;
-
-  if (!apply) {
-    console.log(
-      `${all.length} rows (threshold ${THRESHOLD})${over ? " — over the threshold, run --apply" : " — under the threshold"}`,
-    );
-    return;
-  }
-  if (!over && !process.env.MEM_FORCE) {
-    console.log(
-      `${all.length}/${THRESHOLD} rows — under the threshold, no rotate needed (MEM_FORCE=1 to do it anyway)`,
-    );
-    return;
-  }
-
-  const keep = rotateKeep(all);
-  const stamp = new Date().toISOString().slice(0, 10);
-  const archived = join(dir, `log.${stamp}.jsonl`);
-  if (existsSync(archived)) {
-    console.error(
-      `${archived} already exists (rotated today?) — remove or move it first to run again`,
-    );
-    process.exit(1);
-  }
-
-  // like plan-sweep: stage first to stop git mv failing silently if the file is untracked (exit 128)
-  Bun.spawnSync(["git", "add", LOG]);
-  const mv = Bun.spawnSync(["git", "mv", LOG, archived]);
-  if (mv.exitCode !== 0) {
-    console.error(
-      `git mv failed (${mv.stderr.toString().trim()}) — rotate aborted`,
-    );
-    process.exit(1);
-  }
-
-  writeFileSync(LOG, "");
-  for (const r of keep) appendRaw(LOG, r);
-
-  console.log(
-    `rotated: ${all.length} rows → archive ${archived.replace(`${dir}/`, "")} (git history intact), ${keep.length} row(s) left in log.jsonl (open + active claims)`,
-  );
-};

package/src/mem/commands/where.ts

@@ -1,56 +0,0 @@
-// src/mem/commands/where.ts — `fapony mem where`: show which mem dir is resolved and how
-
-import { whereMemDir } from "../../memory.js";
-
-const USAGE = "usage: fapony mem [--mem-dir <path>] where [--from <dir>]";
-
-export function cmdWhere(args: string[], memDir?: string): void {
-  let fromDir: string | undefined;
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--from") {
-      const v = args[i + 1];
-      if (!v || v.startsWith("--")) {
-        console.error(`fapony mem where: --from needs a value\n${USAGE}`);
-        process.exit(1);
-      }
-      fromDir = v;
-      i++;
-    } else if (args[i] === "-h" || args[i] === "--help") {
-      console.log(USAGE);
-      return;
-    }
-  }
-
-  const result = whereMemDir(fromDir, memDir);
-
-  if (result.step === "ambiguous") {
-    console.error(
-      "fapony mem: two mem dirs at the same level, refusing to guess",
-    );
-    for (const c of result.candidates ?? []) console.error(`  ${c}`);
-    console.error("cd into one of them, set paths.memDir, or pass --mem-dir");
-    process.exit(1);
-  }
-
-  if (!result.dir) {
-    console.log(
-      `fapony mem where — no .fapony/.memory/ found (step: ${result.step})`,
-    );
-    console.log("  Create one with: fapony init <path>");
-    return;
-  }
-
-  const labels: Record<string, string> = {
-    flag: "--mem-dir flag",
-    config: "paths.memDir in fapony.config.json",
-    "walk-up": "walked up from cwd",
-    "repo-root": "git repo root fallback",
-    ambiguous: "ambiguous",
-    none: "not found",
-  };
-
-  console.log(`fapony mem where`);
-  console.log(`  dir:   ${result.dir}`);
-  console.log(`  step:  ${labels[result.step] ?? result.step}`);
-}

package/src/mem/commands/write.ts

@@ -1,273 +0,0 @@
-// commands/write.ts — mutating commands: add, close, claim, release, synced, hook
-
-import { CapError, engineAdd, engineClose } from "../engine.js";
-import { claimsOf, openRows } from "../selectors.js";
-import type { WorkKind } from "../store.js";
-import { KINDS, memCmd, put, root, rows } from "../store.js";
-
-export const cmdAdd = async (a: string[]) => {
-  // mem add <next|bug|decision|note|hold> "<text>" --files f1,f2 [path/to/SPEC.md]
-  // mem add <kind> --stdin --files f1,f2 [spec.md]  ← read text from stdin (avoids shell metachar issues)
-  // ponytail: a wrong kind = that row silently vanishes from the view — better to die right here
-  if (!KINDS.includes(a[0] as WorkKind)) {
-    console.error(
-      `kind must be one of ${KINDS.join("|")} — got "${a[0] ?? ""}"`,
-    );
-    process.exit(1);
-  }
-  // hold requires a spec — checked after parse (the spec may come before --files)
-  // PLAN-convention-debt chunk 3: files[] is required — a measured optional field
-  // had fill rate 0 (required+enum = 50/50) and recall on old logs without files[] caught only
-  // 48.1% — fix the write side, not the read side: a row that does not name the file = unfindable when you touch that file
-
-  // Positional reparse (PLAN-comma-x chunk 2): walk argv once, consume every
-  // known flag occurrence, keep the rest as positional = text + optional
-  // trailing spec.md. The old filter removed only the first --files value by
-  // identity, so `--files a --files b` left the stray `b` in the row text
-  // (live corruption, row muds6zg5) — and a text word equal to the files
-  // value was eaten instead. Flag strip stays positional, never by value:
-  // a key like "fix" may legitimately sit inside the text.
-  const positional: string[] = [];
-  const rawFiles: string[] = [];
-  let filesValueMissing = false;
-  let useStdin = false;
-  let sawKey = false;
-  let keyVal: string | undefined;
-  const rest = a.slice(1);
-  for (let i = 0; i < rest.length; i++) {
-    const t = rest[i];
-    if (t === "--stdin") {
-      useStdin = true;
-      continue;
-    }
-    if (t === "--files") {
-      const v = rest[i + 1];
-      if (v !== undefined && !v.startsWith("--")) {
-        rawFiles.push(v);
-        i++;
-      } else {
-        filesValueMissing = true; // dies in validation below
-      }
-      continue;
-    }
-    if (t === "--key" || t.startsWith("--key=")) {
-      const eq = t.startsWith("--key=");
-      const v = eq ? t.slice("--key=".length) : rest[i + 1];
-      if (!sawKey) {
-        sawKey = true;
-        keyVal = v; // first occurrence wins — validated below
-      }
-      // Consume the value token on every occurrence so a stray repeat never
-      // leaks into the text (same leak class as a repeated --files).
-      if (!eq && v !== undefined && !v.startsWith("--")) i++;
-      continue;
-    }
-    positional.push(t);
-  }
-
-  // Validation order unchanged from the old parser: files → key → hold → text.
-  if (filesValueMissing || rawFiles.length === 0) {
-    console.error(
-      `--files is required — usage: ${memCmd} add ${a[0]} "<text>" --files path/to/file.ts[,more] [spec.md]`,
-    );
-    process.exit(1);
-  }
-  const files: string[] = [];
-  for (const v of rawFiles) {
-    const parts = v
-      .split(",")
-      .map((s) => s.trim().replace(/^\.\//, ""))
-      .filter(Boolean);
-    if (parts.length === 0) {
-      console.error(
-        `--files needs at least one path — usage: ${memCmd} add ${a[0]} "<text>" --files path/to/file.ts[,more]`,
-      );
-      process.exit(1);
-    }
-    files.push(...parts);
-  }
-  // --key is optional; pattern validation lives in engineAdd (one checker,
-  // both surfaces — PLAN-mem-keys chunk 1). argv layer only extracts it.
-  // Accepts `--key value` and `--key=value` alike (same as cmdFind) — an
-  // exact-match lookup for "--key" would leave a `--key=x` token inside the
-  // text and write a keyless row with exit 0 (silent drop, never allowed).
-  if (sawKey && (!keyVal || keyVal.startsWith("--"))) {
-    console.error(
-      `--key needs a value — usage: ${memCmd} add ${a[0]} "<text>" --files f1,f2 --key fix-stop-dedupe`,
-    );
-    process.exit(1);
-  }
-  const spec = positional.at(-1)?.endsWith(".md")
-    ? positional.pop()
-    : undefined;
-  if (a[0] === "hold" && !spec) {
-    console.error(
-      `hold requires a spec — usage: ${memCmd} add hold "..." --files f1,f2 <spec.md>`,
-    );
-    process.exit(1);
-  }
-  let text: string;
-  if (useStdin) {
-    text = (await Bun.stdin.text()).trim();
-    if (!text) {
-      console.error("stdin was empty — text is required");
-      process.exit(1);
-    }
-  } else {
-    // text is required
-    if (positional.length === 0) {
-      console.error(
-        `text is required — usage: ${memCmd} add <kind> "<text>" --files f1,f2 [spec.md]`,
-      );
-      process.exit(1);
-    }
-    text = positional.join(" ");
-  }
-  // Domain rules (caps, id) live in the shared engine — this wrapper owns
-  // only argv surface and the MEM_FORCE hint wording (PLAN-unify-mem-engine).
-  try {
-    const { id } = engineAdd({ kind: a[0], text, spec, files, key: keyVal });
-    console.log(id);
-  } catch (e) {
-    if (e instanceof CapError) {
-      const hint =
-        e.cap === "next"
-          ? " (or MEM_FORCE=1 if you really must)"
-          : " (or MEM_FORCE=1)";
-      console.error(`${e.message}${hint}`);
-    } else {
-      console.error(e instanceof Error ? e.message : String(e));
-    }
-    process.exit(1);
-  }
-};
-
-export const cmdClose = async (a: string[]) => {
-  // mem close <id> "<what was done / commit>" — the tombstone voids the claim by itself
-  // mem close <id> --stdin ← read text from stdin
-  if (!a[0]) {
-    console.error(`id is required — usage: ${memCmd} close <id> "<text>"`);
-    process.exit(1);
-  }
-  const rest = a.slice(1);
-  const useStdin = rest.includes("--stdin");
-  let text: string;
-  if (useStdin) {
-    text = (await Bun.stdin.text()).trim();
-  } else {
-    text = rest.join(" ");
-  }
-  // Tombstone rules (id must exist, text required) live in the shared engine —
-  // note this tightens CLI: an empty-text close now errors instead of writing
-  // a textless tombstone (intentional, PLAN-unify-mem-engine §4).
-  try {
-    engineClose({ id: a[0], text });
-  } catch (e) {
-    console.error(e instanceof Error ? e.message : String(e));
-    process.exit(1);
-  }
-};
-
-export const cmdClaim = (a: string[]) => {
-  // mem claim <id> — id must be real, open, kind=next|bug, with no active claim pending
-  if (!a[0]) {
-    console.error(`id is required — usage: ${memCmd} claim <id>`);
-    process.exit(1);
-  }
-  const all = rows();
-  const open = openRows(all);
-  const target = open.find((r) => r.id === a[0]);
-  if (!target) {
-    const exists = all.find((r) => "id" in r && r.id === a[0]);
-    console.error(
-      exists
-        ? `id "${a[0]}" exists but is already closed (close tombstone)`
-        : `no id "${a[0]}" in the log`,
-    );
-    process.exit(1);
-  }
-  if (target.kind !== "next" && target.kind !== "bug") {
-    console.error(
-      `only next/bug can be claimed — id "${a[0]}" is ${target.kind}`,
-    );
-    process.exit(1);
-  }
-  const claims = claimsOf(all);
-  if (claims.has(a[0])) {
-    const c = claims.get(a[0])!;
-    console.error(
-      `id "${a[0]}" is already claimed by ${c.agent} — release it first`,
-    );
-    process.exit(1);
-  }
-  put({ kind: "claim", ref: a[0] });
-  console.log(`claimed ${a[0]}`);
-};
-
-export const cmdRelease = async (a: string[]) => {
-  // mem release <id> "<reason>?"
-  // mem release <id> --stdin ← read text from stdin
-  if (!a[0]) {
-    console.error(`id is required — usage: ${memCmd} release <id> [reason]`);
-    process.exit(1);
-  }
-  const all = rows();
-  const claims = claimsOf(all);
-  if (!claims.has(a[0])) {
-    console.error(`id "${a[0]}" has no active claim`);
-    process.exit(1);
-  }
-  const rest = a.slice(1);
-  const useStdin = rest.includes("--stdin");
-  let text: string | undefined;
-  if (useStdin) {
-    const t = (await Bun.stdin.text()).trim();
-    text = t || undefined;
-  } else {
-    text = rest.join(" ") || undefined;
-  }
-  put({ kind: "release", ref: a[0], text });
-  console.log(`released ${a[0]}`);
-};
-
-export const cmdSynced = (a: string[]) => {
-  // mem synced [path.md ...] — declare the spec now matches the log (none given = every spec the log mentions)
-  const specs = a.length
-    ? a
-    : [
-        ...new Set(
-          rows()
-            .filter((r) => r.kind === "synced" || ("spec" in r && r.spec))
-            .map((r) => ("spec" in r ? r.spec : undefined))
-            .filter(Boolean) as string[],
-        ),
-      ];
-  for (const spec of specs) put({ kind: "synced", spec });
-  console.log(`synced ${specs.length} spec`);
-};
-
-export const cmdHook = async () => {
-  // PostToolUse: stdin = {tool_input:{file_path}} → editing this app's spec is done = mark synced automatically
-  const j = (await Bun.stdin.json().catch(() => null)) as Record<
-    string,
-    unknown
-  > | null;
-  const f =
-    j && typeof j === "object" && "tool_input" in j
-      ? ((j as { tool_input?: { file_path?: string } }).tool_input?.file_path ??
-        "")
-      : "";
-  const { planDir, doneDir } = await import("../store.js");
-  const relF = f.startsWith(root) ? f.slice(root.length + 1) : f;
-  // match PLAN*.md under this project's plan/ or done/
-  const planRe = new RegExp(
-    `^${planDir.replace(`${root}/`, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/.*PLAN.*\\.md$`,
-  );
-  const doneRe = new RegExp(
-    `^${doneDir.replace(`${root}/`, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/.*PLAN.*\\.md$`,
-  );
-  if (planRe.test(relF) || doneRe.test(relF)) {
-    put({ kind: "synced", spec: relF });
-    console.log(`synced ${relF}`);
-  }
-};

package/src/mem/engine.ts

@@ -1,315 +0,0 @@
-// src/mem/engine.ts — the single validation+write engine for mem add/close.
-//
-// Both entry points call it: CLI (commands/write.ts cmdAdd/cmdClose) and MCP
-// (adapters/mcp/tools/mem.ts memAdd/memClose). Every domain rule lives here
-// exactly once — kind check, files[] required, hold-requires-spec, open
-// next/hold caps. Wrappers own only their surface: argv parsing +
-// console.error/exit (CLI), worktree-shape checks + JSON results (MCP).
-//
-// Precondition: the store is initialized (initStore) before calling — cli.ts
-// does it at dispatch, the MCP wrapper does it per call with its worktree.
-// (PLAN-unify-mem-engine chunk 1)
-
-import { KEY_RE } from "../core/mem-log.js";
-import { openRows } from "./selectors.js";
-import { KINDS, nextId, put, rows, type WorkKind } from "./store.js";
-
-export const CAP_NEXT = 15;
-export const CAP_HOLD = 10;
-
-/**
- * Thrown when an open next/hold cap is full. Carries which cap so the CLI
- * wrapper can append its MEM_FORCE hint while MCP passes the bare message
- * (the two surfaces keep their exact legacy strings — PLAN §4).
- */
-export class CapError extends Error {
-  readonly cap: "next" | "hold";
-  constructor(cap: "next" | "hold", message: string) {
-    super(message);
-    this.name = "CapError";
-    this.cap = cap;
-  }
-}
-
-export interface EngineAddArgs {
-  kind: string;
-  text: string;
-  files: string[];
-  spec?: string;
-  /** Problem identity — optional, but validated against KEY_RE whenever present. */
-  key?: string;
-}
-
-export interface EngineAddResult {
-  id: string;
-  kind: string;
-  text: string;
-  files: string[];
-  spec?: string;
-  key?: string;
-  ts: string;
-}
-
-export function engineAdd(a: EngineAddArgs): EngineAddResult {
-  if (!KINDS.includes(a.kind as WorkKind)) {
-    throw new Error(`kind must be one of ${KINDS.join("|")} — got "${a.kind}"`);
-  }
-  if (a.files.length === 0) {
-    throw new Error("files must contain at least one path");
-  }
-  if (!a.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-  // Without a spec a hold can never be resolved by rotate — reject at write.
-  if (a.kind === "hold" && !a.spec) {
-    throw new Error("hold requires a spec — pass spec: <path/to/SPEC.md>");
-  }
-  // One validator for both surfaces (CLI argv reaches here too) — reject loudly
-  // with a usable example, never silently drop the key (SPEC-mem-keys §Validation).
-  if (a.key !== undefined && !KEY_RE.test(a.key)) {
-    throw new Error(
-      `key must match [a-z0-9-]{3,40} — e.g. "fix-stop-dedupe", got "${a.key}"`,
-    );
-  }
-
-  const all = rows();
-  if (a.kind === "next" && !process.env.MEM_FORCE) {
-    const openNext = openRows(all).filter((r) => r.kind === "next").length;
-    if (openNext >= CAP_NEXT) {
-      throw new CapError(
-        "next",
-        `open next ${openNext}/${CAP_NEXT} is full — close an old one first`,
-      );
-    }
-  }
-  if (a.kind === "hold" && !process.env.MEM_FORCE) {
-    const openHold = openRows(all).filter((r) => r.kind === "hold").length;
-    if (openHold >= CAP_HOLD) {
-      throw new CapError(
-        "hold",
-        `open hold ${openHold}/${CAP_HOLD} is full — close/release an old one first`,
-      );
-    }
-  }
-
-  const id = nextId(all);
-  const ts = new Date().toISOString();
-  // Every row written from here on is v:2 — key optional, but the version
-  // stamps the schema so a reader can tell new rows from v:1 legacy ones.
-  // JSON.stringify drops the undefined key, so keyless rows carry only v.
-  put({
-    id,
-    kind: a.kind as WorkKind,
-    text: a.text,
-    spec: a.spec,
-    files: a.files,
-    key: a.key,
-    v: 2,
-  });
-  return {
-    id,
-    kind: a.kind,
-    text: a.text,
-    files: a.files,
-    spec: a.spec,
-    key: a.key,
-    ts,
-  };
-}
-
-export interface EngineCloseArgs {
-  id: string;
-  text: string;
-}
-
-export interface EngineCloseResult {
-  ref: string;
-  text: string;
-  ts: string;
-}
-
-export function engineClose(a: EngineCloseArgs): EngineCloseResult {
-  if (!a.id.trim()) {
-    throw new Error("id is required");
-  }
-  if (!a.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-
-  const all = rows();
-  if (!all.some((r) => "id" in r && r.id === a.id)) {
-    throw new Error(`no id "${a.id}" in the log`);
-  }
-
-  const ts = new Date().toISOString();
-  put({ kind: "close", ref: a.id, text: a.text });
-
-  return { ref: a.id, text: a.text, ts };
-}
-
-// --- find ---
-//
-// The single query engine for mem find. Both entry points call it with rows
-// they already read — CLI (commands/read.ts cmdFind, via allRows() which
-// includes rotated archives) and MCP (adapters/mcp/tools/mem.ts memFind, via
-// readMemLog whose loose log*.jsonl regex includes log.YYYY-MM-DD.jsonl too).
-// Archive scope is therefore identical on both sides with no parameter for it
-// (PLAN-unify-mem-engine chunk 2 §4.1: the "MCP reads live only" premise was
-// wrong — both see archives, base rate 0 archive files vs 211 live rows).
-//
-// The engine is pure: it takes rows + typed params, never touches argv
-// strings or the store. Wrappers own their surface — CLI parses
-// --kind/--files/--since/--limit/--open at the argv layer, MCP validates its JSON
-// shape — and each passes its own kind default (PLAN §5 escape):
-// MCP passes no exclude (contract: "every kind, no default filter", locked by
-// test), CLI passes the bookkeeping exclude to keep its legacy output.
-
-export const FIND_DEFAULT_LIMIT = 20;
-
-/** Bookkeeping rows the CLI hides unless explicitly asked via --kind. */
-export const CLI_FIND_EXCLUDE = ["close", "synced", "claim", "release"];
-
-export interface EngineFindArgs {
-  /** Substring over text/spec/ref, case-insensitive. Omit = no text filter. */
-  text?: string;
-  /** Repo-relative paths — stored files[] first, text/spec/ref fallback. */
-  files?: string[];
-  /** Include filter — when non-empty, wins over excludeKind. */
-  kind?: string[];
-  /** Exclude filter — applied only when kind is empty. */
-  excludeKind?: string[];
-  /** ISO timestamp — only rows at or after this time (inclusive). */
-  sinceIso?: string;
-  /** Max rows returned (total still counts all matches). Default 20. */
-  limit?: number;
-  /**
-   * true = unresolved work only: drops bookkeeping kinds
-   * (close/claim/release/synced) plus work rows a close row points at.
-   * Mirrors selectors.openRows but stays generic (no store types) so MCP rows
-   * qualify. Default false — recall shows closed rows too.
-   */
-  open?: boolean;
-  /**
-   * Exact problem-identity match — rows whose effective key differs fall out
-   * (v:1 rows included; they stay reachable via files/text). A close row
-   * matches through the key of the work row its ref points at (derived at
-   * read time, never stored). A pure miss also returns knownKeys.
-   */
-  key?: string;
-}
-
-export interface EngineFindResult<T> {
-  rows: T[];
-  total: number;
-  /** Present only on a pure key miss — every distinct key in `all`, sorted. */
-  knownKeys?: string[];
-}
-
-export type FindableRow = {
-  kind: string;
-  text?: string;
-  spec?: string;
-  ref?: string;
-  files?: string[];
-  key?: string;
-  ts: string;
-};
-
-export function engineFind<T extends FindableRow>(
-  all: T[],
-  a: EngineFindArgs,
-): EngineFindResult<T> {
-  let out = [...all];
-
-  if (a.open === true) {
-    const dead = new Set(
-      all
-        .filter((r) => r.kind === "close" && typeof r.ref === "string")
-        .map((r) => r.ref as string),
-    );
-    const BOOKKEEPING = new Set(["close", "claim", "release", "synced"]);
-    out = out.filter(
-      (r) =>
-        !BOOKKEEPING.has(r.kind) &&
-        !("id" in r && typeof r.id === "string" && dead.has(r.id)),
-    );
-  }
-
-  if (a.sinceIso) {
-    const since = a.sinceIso;
-    out = out.filter((r) => !(r.ts < since));
-  }
-
-  if (a.kind && a.kind.length > 0) {
-    const keep = new Set(a.kind);
-    out = out.filter((r) => keep.has(r.kind));
-  } else if (a.excludeKind && a.excludeKind.length > 0) {
-    const drop = new Set(a.excludeKind);
-    out = out.filter((r) => !drop.has(r.kind));
-  }
-
-  // Exact key match, before text/files — a wrong key must never fall through
-  // to substring luck. Close rows derive their key from the ref'd work row
-  // (read-time derive: match only; the row itself stays keyless). knownKeys
-  // fires only on a pure key miss — answer a wrong guess with the real list.
-  let knownKeys: string[] | undefined;
-  if (a.key) {
-    const want = a.key;
-    const idKey = new Map<string, string>();
-    for (const r of all) {
-      if ("id" in r && typeof r.id === "string" && r.key) {
-        idKey.set(r.id, r.key);
-      }
-    }
-    const eff = (r: T): string | undefined =>
-      r.key ??
-      (r.kind === "close" && typeof r.ref === "string"
-        ? idKey.get(r.ref)
-        : undefined);
-    out = out.filter((r) => eff(r) === want);
-    if (!all.some((r) => eff(r) === want)) {
-      const distinct = new Set<string>();
-      for (const r of all) {
-        if (r.key) distinct.add(r.key);
-      }
-      knownKeys = [...distinct].sort();
-    }
-  }
-
-  if (a.text?.trim()) {
-    const needle = a.text.toLowerCase();
-    out = out.filter((r) =>
-      `${r.text ?? ""}\n${r.spec ?? ""}\n${r.ref ?? ""}`
-        .toLowerCase()
-        .includes(needle),
-    );
-  }
-
-  if (a.files && a.files.length > 0) {
-    // Rows written by `mem add --files` carry files[] — match that first.
-    // Older rows (and any row whose author skipped --files) have none, so the
-    // text/spec/ref substring stays as the fallback: low recall by nature,
-    // a limit of the data rather than of the query.
-    const paths = a.files.map((f) => f.toLowerCase());
-    out = out.filter((r) => {
-      const stored = (r.files ?? []).map((f) => f.toLowerCase());
-      if (stored.some((f) => paths.some((p) => f === p || f.endsWith(`/${p}`))))
-        return true;
-      const hay =
-        `${r.text ?? ""}\n${r.spec ?? ""}\n${r.ref ?? ""}`.toLowerCase();
-      return paths.some((p) => hay.includes(p));
-    });
-  }
-
-  // Newest first — the canonical order. The CLI wrapper reprints oldest-first
-  // to keep its legacy output byte-identical (same set, legacy order).
-  out.sort((x, y) => y.ts.localeCompare(x.ts));
-
-  const total = out.length;
-  const limit = Math.max(0, a.limit ?? FIND_DEFAULT_LIMIT);
-  return {
-    rows: out.slice(0, limit),
-    total,
-    ...(knownKeys ? { knownKeys } : {}),
-  };
-}