fapony 0.2.0 → 0.3.0

package/src/mcp/tools/mem.ts

@@ -235,3 +235,74 @@ export function toolMemAdd(args: Record<string, unknown>): ToolResult {
     return errorResult(e instanceof Error ? e.message : String(e));
   }
 }
+
+// --- mem_close ---
+//
+// A separate tool on purpose, not kind:"close" inside mem_add: a close row
+// carries {ref, text} with no files[] and no spec, while mem_add requires a
+// non-empty files[] (and a spec for hold) — folding them into one schema
+// would make required fields depend on the value of another field, the shape
+// models call wrong most often. Mirrors CLI `mem close <id> "<msg>"`
+// (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 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 };
+}
+
+export function toolMemClose(args: Record<string, unknown>): ToolResult {
+  const worktree =
+    typeof args.worktree === "string" ? args.worktree.trim() : "";
+  if (!worktree) {
+    return errorResult(
+      "worktree is required and must be an absolute path " +
+        "(git rev-parse --show-toplevel)",
+    );
+  }
+  if (!worktree.startsWith("/")) {
+    return errorResult(`worktree must be an absolute path, got: ${worktree}`);
+  }
+
+  const id = typeof args.id === "string" ? args.id.trim() : "";
+  if (!id) {
+    return errorResult("id is required — the row id to close");
+  }
+
+  const text = typeof args.text === "string" ? args.text.trim() : "";
+  if (!text) {
+    return errorResult("text is required and must not be empty");
+  }
+
+  try {
+    const result = memClose({ worktree, id, text });
+    return jsonResult(result);
+  } catch (e) {
+    return errorResult(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/mcp/transport.ts

@@ -4,13 +4,12 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
-import { mergeBytesByTool, type UsageDetail } from "../session/index.js";
 import { getServerSha } from "./primitives.js";
 import {
   TOOLS,
   toolMemAdd,
+  toolMemClose,
   toolMemFind,
-  toolPassiveUsage,
   toolVerdictSubmit,
 } from "./tools/index.js";
 import { errorResult, type ToolResult } from "./types.js";
@@ -39,68 +38,18 @@ Skip it and every tool still answers correctly, on a thinner history.`;
 //
 // Written after every MCP tool call. The Claude Code statusline script reads
 // this file (< 1ms, no spawn, no db). Format: single line of text.
-// Only fapony_usage with detail:true produces meaningful data (bytes_by_tool,
-// aggregated across all clients — the bytes live on the claude_code
-// sub-object, never top-level); other tools write a minimal "fapony" marker.
+// No remaining tool produces bytes_by_tool detail, so every call writes the
+// minimal "fapony" marker — cross-client spend lives on the CLI now
+// (`fapony usage-scan` + `fapony usage-web`), which the statusline cannot
+// spawn (it must stay < 1ms).
 
 const STATUSLINE_PATH = join(homedir(), ".config", "fapony", "statusline");
 
-function writeStatuslineCache(toolResult: ToolResult): void {
+function writeStatuslineCache(): void {
   try {
-    // Extract bytes_by_tool from fapony_usage detail JSON response.
-    let line = "fapony";
-    if (
-      toolResult &&
-      typeof toolResult === "object" &&
-      "content" in toolResult &&
-      Array.isArray(toolResult.content)
-    ) {
-      for (const c of toolResult.content) {
-        if (
-          c &&
-          typeof c === "object" &&
-          c.type === "text" &&
-          typeof c.text === "string"
-        ) {
-          // Try to extract bytes_by_tool from JSON text response.
-          // Aggregated across all clients: the bytes live on the Claude Code
-          // sub-object (claude_code.detail), never on the top-level detail,
-          // so reading top-level alone would always miss.
-          try {
-            const parsed = JSON.parse(c.text) as {
-              detail?: UsageDetail | null;
-              zcode?: { detail?: UsageDetail | null } | null;
-              claude_code?: { detail?: UsageDetail | null } | null;
-              codex?: { detail?: UsageDetail | null } | null;
-            };
-            const bbt = mergeBytesByTool(
-              parsed?.detail,
-              parsed?.zcode?.detail,
-              parsed?.claude_code?.detail,
-              parsed?.codex?.detail,
-            );
-            const entries = Object.entries(bbt).sort((a, b) => b[1] - a[1]);
-            const total = entries.reduce((s, e) => s + e[1], 0);
-            if (total > 0) {
-              // Format: "84.2k" for total, or "Read 42k · Grep 31k" for top tools.
-              const fmt = (n: number) =>
-                n >= 1024 ? `${(n / 1024).toFixed(1)}k` : `${Math.round(n)}`;
-              if (entries.length <= 3) {
-                line = `fapony ${entries.map((e) => `${e[0]} ${fmt(e[1])}`).join(" · ")}`;
-              } else {
-                line = `fapony ${fmt(total)}`;
-              }
-            }
-          } catch {
-            // Not JSON — that's fine, use default "fapony" marker.
-          }
-          break;
-        }
-      }
-    }
     const dir = join(homedir(), ".config", "fapony");
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(STATUSLINE_PATH, line, "utf-8");
+    writeFileSync(STATUSLINE_PATH, "fapony", "utf-8");
   } catch {
     // Cache write is best-effort — never block MCP on it.
   }
@@ -110,7 +59,7 @@ function writeStatuslineCache(toolResult: ToolResult): void {
 
 const MCP_PROTOCOL_VERSION = "2025-03-26";
 const SERVER_NAME = "fapony-handcheck";
-const SERVER_VERSION = "0.2.0";
+const SERVER_VERSION = "0.3.0";
 
 // --- JSON-RPC dispatch ---
 
@@ -152,20 +101,20 @@ function dispatchToolCall(params: {
     case "verdict_submit":
       result = toolVerdictSubmit(args);
       break;
-    case "fapony_usage":
-      result = toolPassiveUsage(args);
-      break;
     case "mem_find":
       result = toolMemFind(args);
       break;
     case "mem_add":
       result = toolMemAdd(args);
       break;
+    case "mem_close":
+      result = toolMemClose(args);
+      break;
     default:
       return errorResult(`unknown tool: ${params.name}`);
   }
   // Write statusline cache after every tool call — best-effort, never blocks.
-  writeStatuslineCache(result);
+  writeStatuslineCache();
   return result;
 }
 

package/src/mem/commands/read.ts

@@ -2,10 +2,11 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
+import { baselinePath, readEvidenceLintCmd } from "../../lint-baseline.js";
 import { doneLines, fmtClose, fmtRow, printOpenRows } from "../render.js";
 import { claimsOf, openRows, staleReport } from "../selectors.js";
 import type { CloseRow, WorkRow } from "../store.js";
-import { allRows, app, memCmd, planDir, rows } from "../store.js";
+import { allRows, app, memCmd, planDir, root, rows } from "../store.js";
 import { planSweepCmd, shippedNotMoved } from "./plan.js";
 import { THRESHOLD } from "./rotate.js";
 
@@ -406,6 +407,22 @@ export const cmdKickoff = (a: string[]) => {
     });
   }
 
+  // group 4 — the lint baseline. "Is this red mine or was it already red" is
+  // already answered by `lint-baseline`, but only if it was captured before
+  // the work started — and nobody remembers at session open, which is what
+  // kickoff is. Only offered when the repo declared a lint command; without
+  // one the capture would just fail.
+  try {
+    if (readEvidenceLintCmd(root) && !existsSync(baselinePath(root))) {
+      suggestions.push({
+        text: "lint baseline ยังไม่ capture — แดงที่มีอยู่ก่อนจะถูกนับเป็นของคุณ",
+        run: "fapony lint-baseline --capture",
+      });
+    }
+  } catch {
+    // state dir unreadable — the baseline line is a convenience, never a gate
+  }
+
   // Print and optionally execute. Only a suggestion with a complete command is
   // runnable — a plan item is context, a bug's close is a template needing a message.
   if (suggestions.length) {

package/src/mem/store.ts

@@ -15,6 +15,7 @@ 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 { whereMemDir } from "../memory.js";
 
 // --- types ---
@@ -174,7 +175,7 @@ export function initStore(worktree: string, overrideMemDir?: string): void {
       `two or more .fapony/.memory dirs under ${root} — refusing to guess:\n` +
       `${list}\ncd into one, set paths.memDir, or pass --mem-dir`;
   }
-  dir = resolved.dir ?? join(root, ".fapony", ".memory");
+  dir = resolved.dir ?? join(root, DEFAULT_MEM_DIR);
 
   // planBase: the .fapony dir — plan/done/conventions live here.
   // Derive from dir by going up from .fapony/.memory → .fapony
@@ -184,10 +185,11 @@ export function initStore(worktree: string, overrideMemDir?: string): void {
   app = dirname(planBase);
 
   // Read fapony.config.json
-  const configDir = planBase === `${root}/.fapony` ? root : dirname(planBase);
+  const configDir =
+    planBase === `${root}/${FAPONY_DIR}` ? root : dirname(planBase);
   const configPaths = ((): Record<string, string> => {
     try {
-      const raw = readFileSync(`${configDir}/fapony.config.json`, "utf8");
+      const raw = readFileSync(`${configDir}/${CONFIG_FILENAME}`, "utf8");
       return (JSON.parse(raw)?.paths ?? {}) as Record<string, string>;
     } catch {
       return {};
@@ -198,7 +200,7 @@ export function initStore(worktree: string, overrideMemDir?: string): void {
       ? join(configDir, configPaths[key])
       : null;
 
-  planDir = fromConfig("planDir") ?? `${planBase}/plan`;
+  planDir = `${planBase}/plan`;
 
   // done/ sits beside plan/ (same depth, relative links survive)
   doneDir =

package/src/memory.ts

@@ -5,6 +5,7 @@
 import { execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { CONFIG_FILENAME, DEFAULT_MEM_DIR, FAPONY_DIR } from "./db/defaults.js";
 import { type Config, loadConfig, safetyDeny } from "./db/index.js";
 import { assertSafe } from "./safety.js";
 import { templateArgs } from "./util.js";
@@ -202,7 +203,7 @@ function walkUpForMemDir(fromDir: string, acceptEmpty: boolean): string | null {
   const boundary = repoRootOf(start) ?? "/";
   let dir = start;
   while (true) {
-    const candidate = join(dir, ".fapony", ".memory");
+    const candidate = join(dir, DEFAULT_MEM_DIR);
     if (existsSync(candidate) && (acceptEmpty || hasMemLogs(candidate))) {
       return candidate;
     }
@@ -217,7 +218,13 @@ function walkUpForMemDir(fromDir: string, acceptEmpty: boolean): string | null {
 export interface MemDirResult {
   dir: string | null;
   step: "flag" | "config" | "walk-up" | "repo-root" | "ambiguous" | "none";
-  /** For step "ambiguous" — the sibling `.fapony/.memory/` dirs that hold logs. */
+  /**
+   * `.fapony/.memory/` dirs under the repo root that hold logs but are not in
+   * scope from `fromDir`. Set for "ambiguous" (two or more, the refusal) and
+   * also for "repo-root"/"none" (one) — a caller that reports "nothing
+   * recorded here" is lying when a single app-scoped log exists one level
+   * down, and the honest line needs the path to say where.
+   */
   candidates?: string[];
 }
 
@@ -254,8 +261,8 @@ function findMemDirsUnder(root: string): string[] {
     }
     for (const e of entries) {
       if (!e.isDirectory()) continue;
-      if (e.name === ".fapony") {
-        const candidate = join(dir, ".fapony", ".memory");
+      if (e.name === FAPONY_DIR) {
+        const candidate = join(dir, DEFAULT_MEM_DIR);
         if (hasMemLogs(candidate)) found.push(candidate);
         continue;
       }
@@ -298,7 +305,7 @@ function resolveMemDirFrom(
   // path source here — spec §1 pins this to fapony.config.json)
   const configDir = root ?? cwd;
   try {
-    const configPath = join(configDir, "fapony.config.json");
+    const configPath = join(configDir, CONFIG_FILENAME);
     if (existsSync(configPath)) {
       const config = loadConfig(configPath);
       if (config?.paths?.memDir) {
@@ -319,20 +326,23 @@ function resolveMemDirFrom(
   // Guard (SPEC §1 fail example): nothing at/above cwd holds a log, but the repo
   // has two or more app-scoped ones — refuse instead of silently creating a
   // third log at the root that no app-scoped reader will ever see.
-  if (root) {
-    const candidates = findMemDirsUnder(root);
-    if (candidates.length >= 2) {
-      return { dir: null, step: "ambiguous", candidates };
-    }
+  // One candidate is not ambiguous, so resolution is unchanged — but it still
+  // travels back with the result: out-of-scope is not the same as absent.
+  const candidates = root ? findMemDirsUnder(root) : [];
+  if (candidates.length >= 2) {
+    return { dir: null, step: "ambiguous", candidates };
   }
+  const outOfScope = candidates.length ? { candidates } : {};
 
   // Step 4: <repo root>/.fapony/.memory/ — where a new log is created
   if (root) {
-    const rootDir = join(root, ".fapony", ".memory");
-    if (existsSync(rootDir)) return { dir: rootDir, step: "repo-root" };
+    const rootDir = join(root, DEFAULT_MEM_DIR);
+    if (existsSync(rootDir)) {
+      return { dir: rootDir, step: "repo-root", ...outOfScope };
+    }
   }
 
-  return { dir: null, step: "none" };
+  return { dir: null, step: "none", ...outOfScope };
 }
 
 export function resolveMemDir(

package/src/plan-seed.ts

@@ -38,6 +38,7 @@ import { basename, join, relative, resolve, sep } from "node:path";
 import { collectSourceFiles, isSkippedDir, SCAN_EXTS } from "./analyze.js";
 import { computeModelFit } from "./context/projectHealth.js";
 import { doneDir, planDir, specDir } from "./db/getters.js";
+import { CONFIG_FILENAME } from "./db/index.js";
 import { loadConfig } from "./db/load.js";
 import type { Config } from "./db/types.js";
 import { extractExports } from "./map.js";
@@ -97,7 +98,7 @@ function renderPriorArt(cwd: string, config: Config, roots: string[]): string {
   if (keys.length === 0) return placeholder;
 
   const hits: { shipped: string; line: string }[] = [];
-  for (const dir of [doneDir(config), specDir(config)]) {
+  for (const dir of [doneDir(config), specDir()]) {
     const abs = join(cwd, dir);
     let names: string[];
     try {
@@ -524,7 +525,7 @@ export function cmdPlanSeed(args: string[]): void {
     process.exit(1);
   }
   const cwd = process.cwd();
-  const config = loadConfig(join(cwd, "fapony.config.json"));
+  const config = loadConfig(join(cwd, CONFIG_FILENAME));
   // Resolve the git worktree root so mem/ledger queries hit the same key
   // state.db uses (git rev-parse --show-toplevel). Running from a subdir
   // would otherwise mismatch: stats return empty, Context (fapony) always
@@ -568,7 +569,7 @@ export function cmdPlanSeed(args: string[]): void {
     );
   }
 
-  const planDirAbs = join(cwd, planDir(config));
+  const planDirAbs = join(cwd, planDir());
   const planPath = join(planDirAbs, `PLAN-${name}.md`);
   if (existsSync(planPath)) {
     console.error(
@@ -582,7 +583,7 @@ export function cmdPlanSeed(args: string[]): void {
 
   let specLink: string | null = null;
   if (withSpec) {
-    const specDirAbs = join(cwd, specDir(config));
+    const specDirAbs = join(cwd, specDir());
     const specPath = join(specDirAbs, `SPEC-${name}.md`);
     if (existsSync(specPath)) {
       console.error(
@@ -602,7 +603,7 @@ export function cmdPlanSeed(args: string[]): void {
           : null,
       ),
     );
-    specLink = `../${specDir(config).split("/").pop()}/SPEC-${name}.md`;
+    specLink = `../${specDir().split("/").pop()}/SPEC-${name}.md`;
   }
 
   mkdirSync(planDirAbs, { recursive: true });
@@ -613,7 +614,7 @@ export function cmdPlanSeed(args: string[]): void {
       priorArt,
       contextFapony,
       specLink,
-      `${planDir(config)}/PLAN-${name}.md`,
+      `${planDir()}/PLAN-${name}.md`,
     ),
   );
   console.log(`wrote ${planPath}${specLink ? ` + SPEC-${name}.md` : ""}`);

package/src/session/helpers.ts

@@ -270,7 +270,7 @@ export function readDetailFromDb(
     .all(...filter.params) as DetailPerSessionToolRow[];
 
   // Context bytes per tool — summed `state.output` length. Same signal the
-  // Claude Code/Codex readers derive from tool_result blocks, so `fapony_usage`
+  // Claude Code/Codex readers derive from tool_result blocks, so usage-scan
   // stops reporting zero bytes for the SQLite clients.
   const bytesRows = db
     .prepare(

package/src/session/registry.ts

@@ -2,8 +2,8 @@
 //
 // Adding a client: write its reader (src/session/<name>.ts, same
 // PassiveUsageResult shape as an existing one — SQLite or JSONL, whatever the
-// client actually stores), then add one entry below. usage-scan and
-// fapony_usage both iterate this list; neither needs any other change.
+// client actually stores), then add one entry below. usage-scan iterates
+// this list; nothing else needs any other change.
 //
 // This does not remove the real work of a new client (reverse-engineering
 // its storage format) — it only removes the "wire it into 2 call sites"
@@ -16,12 +16,10 @@ import type { PassiveUsageReader } from "./types.js";
 import { readZcodeUsage } from "./zcode.js";
 
 export interface ClientAdapter {
-  /** cache `client` field and fapony_usage JSON key. */
+  /** usage-cache.jsonl `client` field and usage-scan label default. */
   key: string;
   /** usage-scan progress label — defaults to `key`. */
   scanLabel?: string;
-  /** fapony_usage text-report section label — defaults to `key`. */
-  reportLabel?: string;
   /** The one client whose totals lead the report as the unlabeled top-level summary. */
   primary?: boolean;
   read: PassiveUsageReader;
@@ -38,7 +36,6 @@ export const CLIENTS: ClientAdapter[] = [
   {
     key: "claude_code",
     scanLabel: "claude-code",
-    reportLabel: "claude code",
     read: readClaudeCodeUsage,
   },
   { key: "codex", read: readCodexUsage },

package/src/setup.ts

@@ -6,6 +6,7 @@ import { existsSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { seedConventionsFile } from "./conventions-seed.js";
+import { CONFIG_FILENAME, FAPONY_DIR } from "./db/index.js";
 import { initProject } from "./init.js";
 import { isAffirmative } from "./util.js";
 
@@ -181,7 +182,7 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
       enableMemory,
     });
 
-    const configPath = join(process.cwd(), "fapony.config.json");
+    const configPath = join(process.cwd(), CONFIG_FILENAME);
     if (existsSync(configPath)) {
       const overwrite = await askFn(
         "⚠  fapony.config.json already exists. Overwrite? (y/n)",
@@ -197,7 +198,7 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
     console.log(`\n  ✓  Wrote ${configPath}`);
 
     // --- scaffold worktree ---
-    const faponyDir = join(worktreePath, ".fapony");
+    const faponyDir = join(worktreePath, FAPONY_DIR);
     if (!existsSync(faponyDir)) {
       try {
         initProject(worktreePath);
@@ -228,7 +229,7 @@ export async function cmdSetup(deps: SetupDeps = {}): Promise<void> {
   │     fapony install --platform claude    │
   │                                         │
   │  2. Ask your agent:                     │
-  │     "Run fapony_stats and fapony_usage" │
+  │     "Find past decisions with mem_find" │
   │                                         │
   │  3. Read a run's report:                │
   │     fapony report <run-id>              │

package/src/stats/data.ts

@@ -1,9 +1,8 @@
 // src/stats/data.ts — StatsData shape + getStatsData()
 
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync } from "node:fs";
 import { join } from "node:path";
-
-import { type Event, openDb, type Run } from "../db/index.js";
+import { type Event, openDb, PLAN_DIR, type Run } from "../db/index.js";
 import { loadConfig } from "../db/load.js";
 import { enrichGateWindows } from "../gates.js";
 import { avg, minutesBetween } from "../math.js";
@@ -89,9 +88,7 @@ function enrichGates(
 /**
  * Count un-shipped plan files in a worktree's planDir.
  *
- * Reads the *target repo's own* fapony.config.json for `paths.planDir` — the
- * central config's worktrees map is optional and usually absent, and each repo
- * picks its own plan dir (vela uses apps/vela/plan, not .fapony/plan).
+ * planDir is hardcoded to .fapony/plan — not configurable (gitignored = private).
  *
  * Returns null — never 0 — when the path isn't a readable directory, so a
  * sentinel row like "mcp-external" renders as "—" instead of claiming
@@ -99,19 +96,10 @@ function enrichGates(
  */
 export function countPendingPlans(worktree: string): number | null {
   if (!worktree.startsWith("/")) return null;
-  let planDir = ".fapony/plan";
-  try {
-    const cfg = JSON.parse(
-      readFileSync(join(worktree, "fapony.config.json"), "utf8"),
-    ) as { paths?: { planDir?: unknown } };
-    if (typeof cfg.paths?.planDir === "string" && cfg.paths.planDir)
-      planDir = cfg.paths.planDir;
-  } catch {
-    // no config (or unreadable/malformed) — fall back to the scaffold default
-  }
   try {
-    return readdirSync(join(worktree, planDir)).filter((f) => f.endsWith(".md"))
-      .length;
+    return readdirSync(join(worktree, PLAN_DIR)).filter((f) =>
+      f.endsWith(".md"),
+    ).length;
   } catch {
     return null;
   }