fapony 0.3.5 → 0.3.6

package/README.md

@@ -434,9 +434,10 @@ years:
 - **There is no `MASTER.md`.** Every line above is derived from the plan files themselves, so it
   cannot drift; a hand-kept master file always does.
 
-`status` / `blocked_by` / `blocks` / `superseded_by` are read by people, not by a tool — the one
-that read them, `plan_list`, was removed in 2026-09 once `mem kickoff` answered the same
-question from the CLI, where a schema costs nothing until it runs.
+`status` / `blocked_by` / `blocks` / `superseded_by` are read by `fapony mem plan-check`
+(dangling refs, blocker shipped but dependent still blocked, waiter cycles, blocked with all
+chunks ticked) and by `fapony mem plan-sweep` (blocked view + a `🔓` unblock hint on `--apply`).
+Sentence values ("waiting on support email") carry no `PLAN-*.md` token and are never flagged.
 
 The layout, and why archiving is a plain `git mv`:
 
@@ -464,13 +465,13 @@ fapony price-scan                        # fetch model price table → prices.js
 fapony usage-web [port]                   # live usage comparison dashboard from cache
 fapony stats [--mode verdict [--regime code|fix|review|plan|inquiry|test]]  # KPIs: pass/stall rate, by-model, by-grade — --mode verdict ranks by quality/tokens instead
 fapony digest [--since 7d|YYYY-MM-DD] [--format text|html] [--json] [--out FILE]  # single-page summary: decisions, open bugs, in-flight plans, cost, pass/fail — from what's already on disk
-fapony plan-seed <name> [--spec] [--scope <path>]...  # write PLAN (+SPEC): frontmatter, 8 empty sections, prior-art list, ledger context; SPEC chunks carry signatures, every section capped — the agent fills the judgment
+fapony plan-seed <name> [--spec] [--scope <path>]...  # write PLAN (+SPEC): frontmatter, 8 empty sections, prior-art list, mem-decision context + existing-in-scope; existing plans listed on stdout; SPEC chunks carry signatures, every section capped — the agent fills the judgment
 fapony review-seed [--staged|--commit <sha>|--range <a...b>|--files f1,f2,dir|--plan <PLAN.md>]  # read-only scope facts for a review (changed files, importers, untested, signatures, plan cross-check)
 
 # Memory & convention debt
 fapony mem add <kind> "<text>" --files f1,f2 [spec.md]   # append a mem row (decision/bug/note/next/hold)
 fapony mem close <id> "<msg>"              # close a bug
-fapony mem find "<text>"                   # substring-search every row
+fapony mem find ["<text>"] [--kind a,b] [--files f1,f2] [--since <N>d|YYYY-MM-DD] [--limit n] [--open]  # search mem log
 fapony mem kickoff [<plan.md>]             # open a session + a next-up list
 fapony mem where                           # show the resolved mem dir and which step won
 fapony mem done | stale              # views

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fapony",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Token usage across Claude Code, OpenCode, Codex & ZCode on one yardstick — plus a project mem log and convention-debt tracker agents query via 3 MCP tools. No server, your data stays local",
   "license": "MIT",
   "author": "delamind (https://github.com/kire21b)",

package/skill/move-to-done/SKILL.md

@@ -21,7 +21,7 @@ You are about to move a PLAN that has been shipped to the archive.
    Say in the summary that you stamped it, so a wrong HEAD is visible and correctable.
    STOP only if there's no git repo / no commits to hash from.
 
-1b. **A plan can also leave `plan/` without shipping** — it got absorbed into another plan, or the
+ 1b. **A plan can also leave `plan/` without shipping** — it got absorbed into another plan, or the
    redesign deleted the thing it planned. That is normal during a UI/UX sweep and is the main
    reason `plan/` grows forever: there is no state for "dead" so it just sits there. Archive it
    the same way, with two differences — header `> ⛔ **superseded by [PLAN-bar.md](PLAN-bar.md)**
@@ -37,12 +37,22 @@ You are about to move a PLAN that has been shipped to the archive.
    A plan that is merely *waiting* (on a person, a customer, a decision) is **not** dead and does
    not move — mark it `status: blocked` + `blocked_by: <what you are waiting for>` and leave it in
    `plan/` — the frontmatter is for the next person reading the folder, and the plan stays out
-   of `done/`, which is what `plan-sweep` and `kickoff` go by.
+   of `done/`, which is what `plan-sweep` and `kickoff` go by. Never `--apply` a blocked file;
+   a blocked file with all chunks ticked is deferred doc debt — ask the user: ship it or keep
+   waiting.
+
+ 1c. **Check the dep graph before moving** — `fapony mem plan-check` reads `blocked_by`/`blocks`
+    and says what a human would miss: a `blocked_by` pointing at a file that is not in `plan/`
+    or `done/`, a blocker already in `done/` while the dependent is still `status: blocked`,
+    a waiter cycle, and a blocked plan with all chunks ticked. Fix its issues first — a move
+    on top of a broken graph just relocates the confusion.
 
 2. **Run `plan-sweep --apply`** — this does the `git mv`, rewrites markdown links inside the
    file and inbound links from every `.md` under `.fapony/` (`plan/`, `done/`, `spec/`),
    warns about plain-text mentions and about tracked files outside `.fapony/` that still
-   name the file (both detect-only), and logs a decision row — all in one call:
+   name the file, prints a `🔓 <shipped> — <waiter> lists it as blocker` line when the ship
+   unblocks a waiting plan (copy that line into your summary — the waiter keeps
+   `status: blocked` until its owner clears it), and logs a decision row — all in one call:
    ```bash
    fapony mem plan-sweep <PLAN-foo.md> --apply
    ```

package/skill/plan-with-pony/SKILL.md

@@ -88,9 +88,13 @@ fapony plan-seed <feature> --spec --scope <path>
 One command, no MCP round trip. It writes `<planDir>/PLAN-<feature>.md` +
 `<specDir>/SPEC-<feature>.md` — the frontmatter, the 8 empty sections, a `## 8. References` list
 of shipped plans that already touched this scope, and a `## Context (fapony)` block under the
-TL;DR (recent mem decisions plus which model holds up per task shape here). SPEC chunks carry
+TL;DR (recent mem decisions plus what is already in scope — one line per scope file with its
+exports; needs `--scope` to list anything). No ledger-ranking line: the ledger is frozen and
+cross-model ranking claims are off the table, so the seed does not point at them. SPEC chunks carry
 verbatim signatures, hard-capped (PLAN ≤ ~60 / SPEC ≤ 200 lines), and capped lines say what was
-cut. The CLI resolves plan-dir/spec-dir and refuses to overwrite (pick `-v2` — see Phase 2).
+cut. Stdout ends with the existing plan list (active first, then shipped) — the seed that lands
+next to a shipped decision without knowing it is the expensive mistake, and the file guard in §8
+is not where the glance lands. The CLI resolves plan-dir/spec-dir and refuses to overwrite (pick `-v2` — see Phase 2).
 
 **§2/§5 arrive empty on purpose (2026-09-18).** They used to hold a repetition scan and analyze
 findings; measured over every plan that ever used them, §5 printed "no findings" 3 times out of 3

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

@@ -0,0 +1,50 @@
+// 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. */
+export const BUG_MARKERS: RegExp[] = [
+  /เจอบั๊ก/,
+  /พบบั๊ก/,
+  /\bfound (?:a |the )?bug\b/i,
+  /\b(?:this|that|it)(?:'s| is) a bug\b/i,
+  /\bbug\b\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).
+ */
+export function hasBugMarker(text: string): string | null {
+  for (const re of BUG_MARKERS) {
+    const m = text.match(re);
+    if (m) 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/compute-hint-impact.ts

@@ -3,15 +3,21 @@
 // Split from src/hook.ts (PLAN-lib-layer chunk 3). Reads hint log + re-runs
 // debt detection to count resolved vs unresolved hints.
 
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
 import {
   type HintFireRow,
   type HintImpact,
   hintLogDir,
   worktreeKey,
 } from "../../core/hint-log.js";
-import { debtForFile, loadConventions } from "../../debt/index.js";
+import { debtForFile, resolveDebtScope } from "../../debt/index.js";
 
 /**
  * Compute hint-fire impact from the log. `since` is an ISO date string;
@@ -80,14 +86,25 @@ export function computeHintImpact(
 
   for (const [key, ids] of debtByFile) {
     const [worktree, file] = key.split("\t");
-    const absFile = join(worktree, file);
+    let absFile = join(worktree, file);
     let currentIds: Set<string>;
     try {
       if (!statSync(absFile).isFile()) {
         impact.debt.unknown += ids.length;
         continue;
       }
-      const convs = debtForFile(worktree, absFile, loadConventions(worktree));
+      // The log stores the worktree lexically; scanRoot is physical —
+      // resolve so debtForFile compares like with like.
+      try {
+        absFile = realpathSync(absFile);
+      } catch {
+        // keep the lexical form
+      }
+      // Same scope as the hint itself — resolving at the git root would
+      // load zero conventions in a monorepo and count every shown id as
+      // resolved (precision stuck at 100%).
+      const scope = resolveDebtScope(dirname(absFile));
+      const convs = debtForFile(scope.scanRoot, absFile, scope.loaded);
       currentIds = new Set(convs.map((c) => c.id));
     } catch {
       impact.debt.unknown += ids.length;

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

@@ -4,9 +4,9 @@
 // edit-hint adapters to attach debt/mem lines when a file is open.
 
 import { realpathSync } from "node:fs";
-import { basename, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { collectSourceFiles, SCAN_EXTS } from "../../analyze.js";
-import { debtForFile, loadConventions } from "../../debt/index.js";
+import { debtForFile, resolveDebtScope } from "../../debt/index.js";
 import { readMemLog } from "../../memory.js";
 
 const DEBT_HINT_MAX = 3;
@@ -44,21 +44,27 @@ export function readContextData(
     const debtLines: string[] = [];
     const memLines: string[] = [];
 
-    // convention debt — source files only, fresh from the repo
+    // 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))) {
-      for (const c of debtForFile(
-        worktree,
-        abs,
-        loadConventions(worktree),
-      ).slice(0, DEBT_HINT_MAX)) {
+      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
-    const mem = readMemLog(worktree);
+    // 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) {
       const base = basename(rel);
       const direct: typeof mem.rows = [];

package/src/adapters/hooks/index.ts

@@ -15,6 +15,11 @@ export {
   sessionKey,
   utcStamp,
 } from "../../core/hook-helpers.js";
+export {
+  BUG_MARKERS,
+  hasBugMarker,
+  isBugfixCommit,
+} from "./bug-markers.js";
 export { computeHintImpact } from "./compute-hint-impact.js";
 export {
   type ContextLineData,

package/src/adapters/hooks/read-hint.ts

@@ -18,6 +18,7 @@ import { recordHintFire } from "../../core/hint-log.js";
 import { sessionKey } from "../../core/hook-helpers.js";
 import { readMemLog } from "../../memory.js";
 import { renderSeed } from "../../seed/review-seed.js";
+import { hasBugMarker, isBugfixCommit } from "./bug-markers.js";
 import { readContextData } from "./context-data.js";
 
 // --- Read hint (size) ---
@@ -244,7 +245,9 @@ export function commitHintFor(opts: CommitHintInput): string | null {
 
     let memLastTs: string | null = null;
     try {
-      memLastTs = readMemLog(worktree).rows[0]?.ts ?? null;
+      // Anchor at the dir the commit ran in, not the repo root: the log is
+      // app-scoped in a monorepo, and root resolution misses it (bug muc9q47r).
+      memLastTs = readMemLog(opts.cwd).rows[0]?.ts ?? null;
     } catch {
       memLastTs = null;
     }
@@ -258,6 +261,13 @@ export function commitHintFor(opts: CommitHintInput): string | null {
     const commitList = log ? log.split("\n").filter(Boolean) : [];
     if (commitList.length < COMMIT_HINT_MIN_COMMITS) return null;
 
+    // %h %s — strip the short hash to test the subject alone.
+    const subjectOf = (c: string) => c.replace(/^\S+\s+/, "");
+    const bugCommits = commitList.filter(
+      (c) =>
+        isBugfixCommit(subjectOf(c)) || hasBugMarker(subjectOf(c)) !== null,
+    );
+
     const lines: string[] = [
       `${commitList.length} commit(s) since last mem row (${memLastTs.slice(0, 10)}) — record a mem row for this work.`,
     ];
@@ -266,6 +276,12 @@ export function commitHintFor(opts: CommitHintInput): string | null {
     lines.push(
       `fapony mem add <decision|bug|note> "what happened" --files <files> ${worktree}/.fapony/plan/PLAN.md`,
     );
+    if (bugCommits.length > 0) {
+      lines.push(
+        `${bugCommits.length} of these read as a bug (fix-type commit or found-a-bug wording) — use kind:bug so it surfaces later, not note:`,
+      );
+      lines.push(`  fapony mem add bug "what broke" --files <files>`);
+    }
 
     const prefixed = lines.map((l) => `fapony: ${l}`).join("\n");
     return prefixed;

package/src/adapters/hooks/session-start.ts

@@ -69,12 +69,23 @@ export function sessionStartContext(
   cwd: string,
   faponyTs: string = Bun.main,
 ): string | null {
-  if (!whereMemDir(cwd).dir) return null;
-  const p = Bun.spawnSync([process.execPath, faponyTs, "mem", "kickoff"], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
+  // Resolution shares one function with every reader. A bare monorepo root has
+  // no log at/above cwd, so the resolver reports the app-scoped log only as an
+  // out-of-scope candidate (SPEC §1). For a *read* at session start that is
+  // still recoverable: if the whole repo holds exactly one log, it is the
+  // project's memory — point kickoff at it with --mem-dir. Two or more is
+  // genuinely ambiguous (which app?), so refuse exactly as the resolver does.
+  const resolved = whereMemDir(cwd);
+  const memArgs: string[] = [];
+  if (!resolved.dir) {
+    const candidates = resolved.candidates ?? [];
+    if (candidates.length !== 1) return null;
+    memArgs.push("--mem-dir", candidates[0]);
+  }
+  const p = Bun.spawnSync(
+    [process.execPath, faponyTs, "mem", ...memArgs, "kickoff"],
+    { cwd, stdout: "pipe", stderr: "pipe" },
+  );
   const out = p.stdout.toString().trim();
   if (p.exitCode !== 0 || !out) return null;
   return capContext(out);

package/src/adapters/hooks/stop.ts

@@ -15,6 +15,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { hookTsMs, sessionKey, utcStamp } from "../../core/hook-helpers.js";
 import { readMemLog, whereMemDir } from "../../memory.js";
+import { hasBugMarker } from "./bug-markers.js";
 
 // --- Types ---
 
@@ -252,9 +253,6 @@ export function stopBlockedBefore(
 
 // --- Bug-signal detection ---
 
-/** Announcement words that indicate the agent found a bug — not symptom words. */
-const BUG_MARKERS: RegExp[] = [/เจอบั๊ก/];
-
 /**
  * Scan assistant text from a Claude transcript for bug markers. Reads only
  * the tail of the file (last 200KB) to avoid parsing the full transcript.
@@ -314,12 +312,8 @@ export function bugSignalFromTranscript(
       }
       for (const b of m.content) {
         if (b.type !== "text" || typeof b.text !== "string") continue;
-        for (const re of BUG_MARKERS) {
-          if (re.test(b.text)) {
-            const match = b.text.match(re);
-            return match?.[0] ?? null;
-          }
-        }
+        const hit = hasBugMarker(b.text);
+        if (hit) return hit;
       }
     }
   } catch {

package/src/adapters/mcp/tools/index.ts

@@ -3,7 +3,7 @@
 // Every schema here is paid as input tokens in *every* session of *every*
 // client that connects, whether or not the tool is called. Adding one is
 // buying attention with a standing charge; earning it back means the tool
-// saves more than it costs (see CLAUDE.md "จ่าย token อย่างฉลาด"). Keep
+// saves more than it costs (see CLAUDE.md "Spend tokens smart"). Keep
 // descriptions imperative — say what to send, not why it matters.
 
 export { toolMemAdd, toolMemClose, toolMemFind } from "./mem.js";
@@ -59,6 +59,11 @@ export const TOOLS = [
           description:
             "Max rows returned (default 20) — total still counts all matches",
         },
+        open: {
+          type: "boolean",
+          description:
+            "true = unresolved work only: drops close/claim/release/synced rows and work rows already closed. Omit = every row. With kind:[bug] answers 'what bugs remain?'",
+        },
       },
       required: ["worktree"],
     },

package/src/adapters/mcp/tools/mem.ts

@@ -6,15 +6,14 @@
 // file is unfindable when you touch that file (fill rate 26% CLI-flag vs 88%
 // MCP-required — schema wins over prose every time, see CLAUDE.md rule 9).
 
-import { openRows } from "../../../mem/selectors.js";
 import {
-  initStore,
-  KINDS,
-  nextId,
-  put,
-  rows,
-  type WorkKind,
-} from "../../../mem/store.js";
+  type EngineAddResult,
+  type EngineCloseResult,
+  engineAdd,
+  engineClose,
+  engineFind,
+} from "../../../mem/engine.js";
+import { initStore, KINDS, type WorkKind } from "../../../mem/store.js";
 import { type MemRow, readMemLog, resolveMemDir } from "../../../memory.js";
 import { errorResult, jsonResult, type ToolResult } from "../types.js";
 
@@ -33,37 +32,24 @@ export function memFind(args: {
   kind?: string[];
   since?: string;
   limit?: number;
+  open?: boolean;
 }): MemFindResult {
-  const read = readMemLog(args.worktree, args.since);
-
-  let rows = read.rows;
-  if (args.kind && args.kind.length > 0) {
-    const kinds = new Set(args.kind);
-    rows = rows.filter((r) => kinds.has(r.kind));
-  }
-  if (args.text) {
-    const needle = args.text.toLowerCase();
-    rows = rows.filter((r) => r.text.toLowerCase().includes(needle));
-  }
-  if (args.files && args.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 (spec §5.4).
-    const paths = args.files.map((f) => f.toLowerCase());
-    rows = rows.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));
-    });
-  }
-
-  const total = rows.length;
-  const limit = Math.max(0, args.limit ?? 20);
+  // Query logic lives in the shared engine (src/mem/engine.ts) — this wrapper
+  // owns only the read (readMemLog sees live + rotated archives via its loose
+  // log*.jsonl regex) and the result shape. No kind default here by contract:
+  // omitting kind returns every kind (locked by test). CLI cmdFind calls the
+  // same engine with its own bookkeeping exclude.
+  const read = readMemLog(args.worktree);
+  const { rows: matched, total } = engineFind(read.rows, {
+    text: args.text,
+    files: args.files,
+    kind: args.kind,
+    sinceIso: args.since,
+    limit: args.limit,
+    open: args.open,
+  });
   return {
-    rows: rows.slice(0, limit),
+    rows: matched,
     total,
     filesFound: read.filesFound,
     skipped: read.skipped,
@@ -100,24 +86,25 @@ export function toolMemFind(args: Record<string, unknown>): ToolResult {
     : undefined;
   const text = typeof args.text === "string" ? args.text : undefined;
   const since = typeof args.since === "string" ? args.since : undefined;
+  if (since !== undefined && Number.isNaN(Date.parse(since))) {
+    return errorResult(
+      `since must be an ISO date (e.g. 2026-09-19T00:00:00.000Z), got: "${since}" — CLI accepts <N>d/YYYY-MM-DD, MCP takes ISO only`,
+    );
+  }
   const limit = typeof args.limit === "number" ? args.limit : undefined;
+  const open = typeof args.open === "boolean" ? args.open : undefined;
 
-  return jsonResult(memFind({ worktree, files, text, kind, since, limit }));
+  return jsonResult(
+    memFind({ worktree, files, text, kind, since, limit, open }),
+  );
 }
 
 // --- mem_add ---
+//
+// Domain rules live in the shared engine (src/mem/engine.ts) — this wrapper
+// owns only store init for its worktree. CLI cmdAdd calls the same engine.
 
-export interface MemAddResult {
-  id: string;
-  kind: string;
-  text: string;
-  files: string[];
-  spec?: string;
-  ts: string;
-}
-
-const CAP_NEXT = 15;
-const CAP_HOLD = 10;
+export type MemAddResult = EngineAddResult;
 
 export function memAdd(args: {
   worktree: string;
@@ -126,62 +113,13 @@ export function memAdd(args: {
   files: string[];
   spec?: string;
 }): MemAddResult {
-  if (!KINDS.includes(args.kind as WorkKind)) {
-    throw new Error(
-      `kind must be one of ${KINDS.join("|")} — got "${args.kind}"`,
-    );
-  }
-  if (args.files.length === 0) {
-    throw new Error("files must contain at least one path");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-  // CLI cmdAdd rejects hold without a spec (write.ts) — keep the two writers
-  // in lockstep: without a spec a hold can never be resolved by rotate.
-  if (args.kind === "hold" && !args.spec) {
-    throw new Error("hold requires a spec — pass spec: <path/to/SPEC.md>");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-
-  // Cap check — matches CLI cmdAdd behaviour
-  if (args.kind === "next" && !process.env.MEM_FORCE) {
-    const openNext = openRows(all).filter((r) => r.kind === "next").length;
-    if (openNext >= CAP_NEXT) {
-      throw new Error(
-        `open next ${openNext}/${CAP_NEXT} is full — close an old one first`,
-      );
-    }
-  }
-  if (args.kind === "hold" && !process.env.MEM_FORCE) {
-    const openHold = openRows(all).filter((r) => r.kind === "hold").length;
-    if (openHold >= CAP_HOLD) {
-      throw new Error(
-        `open hold ${openHold}/${CAP_HOLD} is full — close/release an old one first`,
-      );
-    }
-  }
-
-  const id = nextId(all);
-  const ts = new Date().toISOString();
-  put({
-    id,
-    kind: args.kind as WorkKind,
-    text: args.text,
-    spec: args.spec,
-    files: args.files,
-  });
-
-  return {
-    id,
+  return engineAdd({
     kind: args.kind,
     text: args.text,
     files: args.files,
     spec: args.spec,
-    ts,
-  };
+  });
 }
 
 export function toolMemAdd(args: Record<string, unknown>): ToolResult {
@@ -246,34 +184,15 @@ export function toolMemAdd(args: Record<string, unknown>): ToolResult {
 // (commands/write.ts cmdClose): the id must exist; the tombstone voids the
 // claim by itself.
 
-export interface MemCloseResult {
-  ref: string;
-  text: string;
-  ts: string;
-}
+export type MemCloseResult = EngineCloseResult;
 
 export function memClose(args: {
   worktree: string;
   id: string;
   text: string;
 }): MemCloseResult {
-  if (!args.id.trim()) {
-    throw new Error("id is required");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-  if (!all.some((r) => "id" in r && r.id === args.id)) {
-    throw new Error(`no id "${args.id}" in the log`);
-  }
-
-  const ts = new Date().toISOString();
-  put({ kind: "close", ref: args.id, text: args.text });
-
-  return { ref: args.id, text: args.text, ts };
+  return engineClose({ id: args.id, text: args.text });
 }
 
 export function toolMemClose(args: Record<string, unknown>): ToolResult {

package/src/core/debt-format.ts

@@ -77,7 +77,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
     for (let i = 0; i < cap; i++) {
       const [zone, zoneFiles] = zoneEntries[i];
       const pad = " ".repeat(Math.max(0, 42 - zone.length));
-      lines.push(`\n  ${zone}${pad}${zoneFiles.length} ไฟล์`);
+      lines.push(`\n  ${zone}${pad}${zoneFiles.length} files`);
       lines.push(`    ${zoneFiles.map((f) => f.split("/").pop()).join(" · ")}`);
       totalCapped += zoneFiles.length;
     }
@@ -85,7 +85,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
       const remaining = e.files.length - totalCapped;
       const remainingZones = zoneEntries.length - cap;
       lines.push(
-        `\n  … อีก ${remainingZones} โซน (${remaining} ไฟล์) — fapony debt --id ${e.conv.id} --all`,
+        `\n  … ${remainingZones} more zones (${remaining} files) — fapony debt --id ${e.conv.id} --all`,
       );
     }
   }

package/src/core/since.ts

@@ -0,0 +1,26 @@
+// src/core/since.ts — parse `--since` (Nd | YYYY-MM-DD) into an ISO timestamp.
+//
+// Pure date math, no imports. Two callers share it: digest/collect.ts and
+// mem find (CLI --since + MCP sinceIso passthrough). It lives in core because
+// both are features and core never imports back up (PLAN-unify-mem-engine
+// chunk 2 — digest/collect.ts used to own this, but importing it from mem
+// would drag db/store + hook.js into the mem load path).
+
+export function parseSince(
+  raw: string | undefined,
+  now?: number,
+): { iso: string; label: string } {
+  const def = "7d";
+  const s = raw ?? def;
+  const dMatch = /^(\d+)d$/.exec(s);
+  if (dMatch) {
+    const days = Number(dMatch[1]);
+    const dt = new Date((now ?? Date.now()) - days * 86400000);
+    return { iso: dt.toISOString(), label: `${days}d` };
+  }
+  const dateMatch = /^\d{4}-\d{2}-\d{2}$/.exec(s);
+  if (dateMatch) {
+    return { iso: `${s}T00:00:00.000Z`, label: s };
+  }
+  throw new Error(`invalid --since format: "${s}" — use <N>d or YYYY-MM-DD`);
+}