fapony 0.2.1 → 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.1";
+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/memory.ts

@@ -218,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[];
 }
 
@@ -320,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, DEFAULT_MEM_DIR);
-    if (existsSync(rootDir)) return { dir: rootDir, step: "repo-root" };
+    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/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

@@ -229,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>              │