fapony 0.3.0 → 0.3.3

package/src/install.ts

@@ -12,6 +12,7 @@
 // ZCode gets skill/<name>/ symlinked into ~/.agents/skills.
 
 import { createInterface } from "node:readline";
+import { cmdInstallAntigravity } from "./install/antigravity.js";
 import { cmdInstallClaude } from "./install/claude.js";
 import { cmdInstallCodex } from "./install/codex.js";
 import { cmdInstallCursor } from "./install/cursor.js";
@@ -22,6 +23,7 @@ import { cmdInstallZcode } from "./install/zcode.js";
 import { ask } from "./setup.js";
 import { isAffirmative } from "./util.js";
 
+export { cmdInstallAntigravity } from "./install/antigravity.js";
 export {
   claudeAddArgs,
   claudeGetArgs,
@@ -58,6 +60,10 @@ export async function cmdInstall(
   const installAll = args.includes("--all");
 
   // --- explicit platform: original behavior, unchanged ---
+  if (platform === "antigravity") {
+    cmdInstallAntigravity(dryRun, deps);
+    return;
+  }
   if (platform === "claude") {
     cmdInstallClaude(dryRun, deps);
     return;
@@ -80,10 +86,10 @@ export async function cmdInstall(
   }
   if (platform !== undefined) {
     console.error(
-      `usage: fapony install --platform opencode|claude|cursor|zcode|codex [--dry-run]`,
+      `usage: fapony install --platform antigravity|opencode|claude|cursor|zcode|codex [--dry-run]`,
     );
     console.error(
-      `  supported platforms: opencode, claude, cursor, zcode, codex`,
+      `  supported platforms: antigravity, opencode, claude, cursor, zcode, codex`,
     );
     (deps.exit ?? defaultExit)(1);
     return;
@@ -107,7 +113,7 @@ export async function cmdInstall(
   if (found.length === 0) {
     console.error();
     console.error(
-      `  no MCP client found (looked for claude on PATH; config files for cursor, opencode, zcode, codex).`,
+      `  no MCP client found (looked for claude on PATH; config files for antigravity, cursor, opencode, zcode, codex).`,
     );
     console.error(
       `  open the app once, then re-run — or force with: fapony install --platform <name>`,
@@ -162,6 +168,9 @@ function installPlatform(
   deps: InstallDeps,
 ): void {
   switch (platform) {
+    case "antigravity":
+      cmdInstallAntigravity(dryRun, deps);
+      break;
     case "claude":
       cmdInstallClaude(dryRun, deps);
       break;

package/src/mcp/primitives.ts

@@ -157,7 +157,7 @@ export interface VerificationReport {
   evidence: EvidenceItem[];
   /** Evidence summary (computed from evidence array). */
   evidence_summary: EvidenceSummary;
-  /** Verdict grade + note (from gate/verdict_submit, or null if not yet). */
+  /** Verdict grade + note (from the frozen gate/verdict ledger, or null if never graded). */
   verdict: {
     grade: string;
     note: string;

package/src/mcp/tools/index.ts

@@ -6,85 +6,11 @@
 // saves more than it costs (see CLAUDE.md "จ่าย token อย่างฉลาด"). Keep
 // descriptions imperative — say what to send, not why it matters.
 
-import { VERDICT_GRADES } from "../../parse.js";
-import { REASON_CODES, REGIME_CODES } from "../types.js";
-
 export { toolMemAdd, toolMemClose, toolMemFind } from "./mem.js";
-export { toolVerdictSubmit } from "./verdict.js";
 
 // --- Tool definitions ---
 
 export const TOOLS = [
-  {
-    name: "verdict_submit",
-    description:
-      "Grade a finished unit of work — every unit that ends, including work " +
-      "that went right the first time. Submit 'fail' the moment a first " +
-      "attempt turns out wrong, then a pass-family verdict once the fix is " +
-      "verified. Never leave a run open: one stuck at running/fixing absorbs " +
-      "later unrelated verdicts for that worktree. Without run_id, binds to " +
-      "the latest open run for the same worktree+plan, else creates one.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        run_id: {
-          type: "number",
-          description: "Existing run to attach to. Omitted = bind or create.",
-        },
-        verdict: {
-          type: "string",
-          enum: [...VERDICT_GRADES],
-          description: "Verdict grade",
-        },
-        reason_code: {
-          type: "string",
-          enum: [...REASON_CODES],
-          description:
-            "Failure reason. Clean passes take 'none', never 'other'.",
-        },
-        regime: {
-          type: "string",
-          enum: [...REGIME_CODES],
-          description:
-            "Task shape: code=feature/refactor, fix=debugging a defect, " +
-            "review=reviewing a diff, plan=producing a plan or spec, " +
-            "inquiry=questions without editing files, test=writing tests",
-        },
-        note: {
-          type: "string",
-          description:
-            "Standalone note — read months later with no access to this " +
-            "conversation. Required when reason_code = 'other'.",
-        },
-        worktree: {
-          type: "string",
-          description:
-            "Absolute repo path (git rev-parse --show-toplevel). Every query " +
-            "scopes by it, so a bare name or an omission files the verdict " +
-            "where nothing reads it. Neither case errors.",
-        },
-        plan: {
-          type: "string",
-          description: "Plan file path, for a new run",
-        },
-        session_id: {
-          type: "string",
-          description:
-            "Client session id (Claude Code/Codex: the transcript .jsonl " +
-            "path; OpenCode/ZCode: the session id) — this is what attributes " +
-            "the verdict to a model. Cannot find it → omit, never invent one.",
-        },
-        files: {
-          type: "array",
-          items: { type: "string" },
-          description:
-            "Repo-relative paths this unit touched. Optional, but always " +
-            "send them: nothing else records where the work landed.",
-        },
-      },
-      required: ["verdict", "reason_code", "regime"],
-    },
-  },
   {
     name: "mem_find",
     description:

package/src/mcp/transport.ts

@@ -1,17 +1,8 @@
 // src/mcp/transport.ts — JSON-RPC dispatch + stdio entry point
 
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { getServerSha } from "./primitives.js";
-import {
-  TOOLS,
-  toolMemAdd,
-  toolMemClose,
-  toolMemFind,
-  toolVerdictSubmit,
-} from "./tools/index.js";
+import { TOOLS, toolMemAdd, toolMemClose, toolMemFind } from "./tools/index.js";
 import { errorResult, type ToolResult } from "./types.js";
 
 // --- Server instructions ---
@@ -26,35 +17,14 @@ import { errorResult, type ToolResult } from "./types.js";
 // Both habits degrade silently — an agent that ignores them still gets
 // correct answers from every tool, just a thinner history.
 
-const SERVER_INSTRUCTIONS = `fapony is a ledger of how work in this project turned out: which model, on which shape of task, produced work that held up. One habit feeds it.
+const SERVER_INSTRUCTIONS = `fapony records decisions, bugs, and notes about this project so the next session (or the next agent) knows what happened and what to watch out for.
 
-When a unit of work is finished, call verdict_submit to grade it — pass-excellent..pass when it holds, fail when the first attempt was wrong, uncertain when you could not verify it (never guess pass). This is a grade on the work, not a confession: grade routinely, including work that went right the first time, because a model's record is only as good as the number of graded units behind it.
+When you finish a unit of work, record a mem row: fapony mem add <decision|bug|note> "what happened" --files <files> <path/to/PLAN.md>. files[] is required — a row without it is unfindable when you touch that file next session.
 
-worktree must be the absolute path (git rev-parse --show-toplevel): every query scopes by it, so a bare name or none files the verdict where nothing reads it, and nothing errors to say so. Write the note standalone — what the work was and how it held up — it is read months later with no access to this conversation. Never leave a run non-terminal; an open run absorbs later unrelated verdicts for that worktree.
+worktree must be the absolute path (git rev-parse --show-toplevel): every query scopes by it, so a bare name or none files the row where nothing reads it, and nothing errors to say so. Write the note standalone — it is read months later with no access to this conversation.
 
 Skip it and every tool still answers correctly, on a thinner history.`;
 
-// --- Statusline cache ---
-//
-// Written after every MCP tool call. The Claude Code statusline script reads
-// this file (< 1ms, no spawn, no db). Format: single line of text.
-// 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(): void {
-  try {
-    const dir = join(homedir(), ".config", "fapony");
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(STATUSLINE_PATH, "fapony", "utf-8");
-  } catch {
-    // Cache write is best-effort — never block MCP on it.
-  }
-}
-
 // --- MCP protocol constants ---
 
 const MCP_PROTOCOL_VERSION = "2025-03-26";
@@ -98,9 +68,6 @@ function dispatchToolCall(params: {
   const args = params.arguments ?? {};
   let result: ToolResult;
   switch (params.name) {
-    case "verdict_submit":
-      result = toolVerdictSubmit(args);
-      break;
     case "mem_find":
       result = toolMemFind(args);
       break;
@@ -113,8 +80,6 @@ function dispatchToolCall(params: {
     default:
       return errorResult(`unknown tool: ${params.name}`);
   }
-  // Write statusline cache after every tool call — best-effort, never blocks.
-  writeStatuslineCache();
   return result;
 }
 

package/src/mcp/worktree.ts

@@ -8,7 +8,7 @@ const SENTINEL_MCP_EXTERNAL = "mcp-external";
  * Resolve a worktree argument to an absolute path.
  * - Absolute paths (contain "/") pass through unchanged
  * - Keys are looked up in config.worktrees
- * - "mcp-external" sentinel passes through (set by verdict_submit itself)
+ * - "mcp-external" sentinel passes through (used when no worktree is available)
  * - Throws if key not found in config
  */
 export function resolveWorktreeArg(value: string): string {

package/src/mem/commands/read.ts

@@ -3,13 +3,28 @@
 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 { 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 { THRESHOLD } from "./rotate.js";
 
+/** Files changed on this branch vs dev — empty set when dev is missing or diff fails. */
+function getBranchDiffFiles(cwd: string): Set<string> {
+  try {
+    const p = Bun.spawnSync(["git", "diff", "--name-only", "dev...HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (p.exitCode !== 0) return new Set();
+    return new Set(p.stdout.toString().trim().split("\n").filter(Boolean));
+  } catch {
+    return new Set();
+  }
+}
+
 const rotateLine = (n: number) =>
   n >= THRESHOLD
     ? `\n## 🗜 log ${n} rows (≥ ${THRESHOLD}) — run: ${memCmd} rotate --apply`
@@ -24,26 +39,20 @@ const planSweepLine = () => {
     : "";
 };
 
-export const cmdNow = () => {
-  // mem now (default) — next+bug+hold. decision/note is not pending work → search with find instead
-  const all = rows();
-  console.log(`# ${app} — ${all.length} entries`);
-  printOpenRows(all, { showHold: true });
-  const decisionN = openRows(all).filter((r) => r.kind === "decision").length;
-  const noteN = openRows(all).filter((r) => r.kind === "note").length;
-  console.log(
-    `\n## decision ${decisionN} · note ${noteN} — search: ${memCmd} find <word>`,
-  );
-  const stale = staleReport(all);
-  if (stale.length)
-    console.log(
-      `\n## ⚠ stale (${stale.length})\n` +
-        stale.map((l) => `- ${l}`).join("\n"),
-    );
-  const sweep = planSweepLine();
-  if (sweep) console.log(sweep);
-  const rotate = rotateLine(all.length);
-  if (rotate) console.log(rotate);
+// Row-list caps: no row-list section exceeds 10 (same budget as ## recent,
+// which takes doneLines(all, 10)). Per-row text is cut at a word boundary —
+// a kickoff line points at the row (mem find has the full text), it must not
+// reprint it.
+const BUGS_LIMIT = 10;
+const BRANCH_LIMIT = 10;
+const RECENT_OPEN_LIMIT = 10;
+const RECENT_OPEN_TEXT = 160;
+
+const shortText = (text: string, max = RECENT_OPEN_TEXT): string => {
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max);
+  const lastSpace = cut.lastIndexOf(" ");
+  return `${lastSpace > max / 2 ? cut.slice(0, lastSpace) : cut}…`;
 };
 
 export const cmdDone = () => {
@@ -235,118 +244,12 @@ export const cmdKickoff = (a: string[]) => {
     }
   }
 
-  // --- main output (unchanged behavior) ---
-
-  if (!arg && !planFile) {
-    // no args = now + a "recent" section = the last 10 closes
-    console.log(`# ${app} — ${all.length} entries`);
-    printOpenRows(all, { showHold: true });
-    console.log(`\n## recent\n${doneLines(all, 10).join("\n")}`);
-    const stale = staleReport(all);
-    if (stale.length)
-      console.log(
-        `\n## ⚠ stale (${stale.length})\n` +
-          stale.map((l) => `- ${l}`).join("\n"),
-      );
-    const sweep = planSweepLine();
-    if (sweep) console.log(sweep);
-    const rotate = rotateLine(all.length);
-    if (rotate) console.log(rotate);
-  } else if (resolvedSpec) {
-    // spec.md = a brief for that spec
-    const open = openRows(all);
-    const specRows = open.filter((r) => r.spec === resolvedSpec);
-    const specDecisions = all
-      .filter(
-        (r): r is WorkRow => r.kind === "decision" && r.spec === resolvedSpec,
-      )
-      .slice(-5);
-    const specCloses = all
-      .filter((r): r is CloseRow => r.kind === "close")
-      .filter((r) => byId.get(r.ref)?.spec === resolvedSpec)
-      .slice(-3);
-
-    console.log(`# ${resolvedSpec} — ${specRows.length} open rows`);
-    if (specRows.length) {
-      console.log(`\n## open\n${specRows.map((r) => fmtRow(r)).join("\n")}`);
-    }
-    if (specDecisions.length) {
-      console.log(
-        `\n## decisions\n` +
-          specDecisions
-            .map((r) => `- ${r.ts.slice(0, 10)} ${r.text}`)
-            .join("\n"),
-      );
-    }
-    if (specCloses.length) {
-      console.log(
-        `\n## closes\n${specCloses.map((c) => fmtClose(c, byId)).join("\n")}`,
-      );
-    }
-    if (!specRows.length && !specDecisions.length && !specCloses.length) {
-      console.log("(no entries for this spec)");
-    }
-  } else if (target) {
-    // id = a brief for that task
-    const claims = claimsOf(all);
-    const claimInfo = claims.has(arg)
-      ? `\nClaimed by: ${claims.get(arg)?.agent} (${claims.get(arg)?.ts.slice(0, 10)})`
-      : "";
-
-    const spec = target.spec;
-    const open = spec
-      ? openRows(all).filter((r) => r.spec === spec && r.id !== arg)
-      : [];
-    const specDecisions = spec
-      ? all
-          .filter((r): r is WorkRow => r.kind === "decision" && r.spec === spec)
-          .slice(-5)
-      : [];
-    const specNotes = spec
-      ? all
-          .filter((r): r is WorkRow => r.kind === "note" && r.spec === spec)
-          .slice(-5)
-      : [];
-    const specCloses = spec
-      ? all
-          .filter((r): r is CloseRow => r.kind === "close")
-          .filter((r) => byId.get(r.ref)?.spec === spec)
-          .slice(-3)
-      : [];
-
-    console.log(
-      `# [${target.id}] ${target.kind} — ${target.text}${target.spec ? ` → ${target.spec}` : ""}${claimInfo}`,
-    );
-    if (open.length) {
-      console.log(
-        `\n## open (same spec)\n` +
-          open.map((r) => fmtRow(r, claims)).join("\n"),
-      );
-    }
-    if (specDecisions.length || specNotes.length) {
-      console.log(`\n## decisions & notes (spec)\n`);
-      for (const r of [...specDecisions, ...specNotes]) {
-        console.log(`- ${r.ts.slice(0, 10)} ${r.kind} ${r.text}`);
-      }
-    }
-    if (specCloses.length) {
-      console.log(
-        `\n## closes (spec)\n` +
-          specCloses.map((c) => fmtClose(c, byId)).join("\n"),
-      );
-    }
-  } else if (arg) {
-    console.error(`no id "${arg}" in the log`);
-    process.exit(1);
-  }
-
-  // --- next up section (chunk 3) ---
+  // --- suggestions (generated early so the no-args path can print next up
+  //     before the recency tier, keeping it inside the 4KB cap) ---
 
-  // A suggestion may carry a fully-runnable command. `manual` marks a command
-  // that is a template with a placeholder (bug close) — show it, never auto-run it.
   type Suggestion = { text: string; run?: string; manual?: boolean };
   const suggestions: Suggestion[] = [];
-  const GROUP_CAP = 3; // SPEC §3: at most 3 groups, at most 3 lines each
+  const GROUP_CAP = 3;
 
   const truncate = (s: string, n = 80) =>
     s.length > n ? `${s.slice(0, n - 1).trimEnd()}…` : s;
@@ -358,7 +261,6 @@ export const cmdKickoff = (a: string[]) => {
     for (const file of files) {
       if (planLines.length >= GROUP_CAP) break;
       const fullPath = join(planDir, file);
-      // Skip the plan we already showed
       if (planFile && fullPath === planFile) continue;
       if (hasHighPriority(fullPath)) {
         const title = readPlanTitle(fullPath);
@@ -369,19 +271,16 @@ export const cmdKickoff = (a: string[]) => {
       }
     }
   }
-  // Only the first unchecked chunk (SPEC §3) — the body of the plan is the plan's job.
-  // There is no per-chunk command, so this line is context, not a runnable item.
   if (planLines.length < GROUP_CAP && planCheckboxes.length) {
     const planName = planFile ? basename(planFile) : "plan";
     planLines.push({ text: `${planCheckboxes[0]} (${planName})` });
   }
   suggestions.push(...planLines);
 
-  // group 2 — open bugs, oldest first. openRows excludes tombstoned refs; the
-  // old bug filter forgot that and offered already-closed bugs as work.
-  const claims = claimsOf(all);
+  // group 2 — open bugs, oldest first
+  const suggClaims = claimsOf(all);
   const openBugs = openRows(all)
-    .filter((r) => r.kind === "bug" && !claims.has(r.id))
+    .filter((r) => r.kind === "bug" && !suggClaims.has(r.id))
     .slice(0, GROUP_CAP);
   for (const b of openBugs) {
     suggestions.push({
@@ -407,11 +306,7 @@ 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.
+  // group 4 — the lint baseline
   try {
     if (readEvidenceLintCmd(root) && !existsSync(baselinePath(root))) {
       suggestions.push({
@@ -423,15 +318,14 @@ export const cmdKickoff = (a: string[]) => {
     // 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) {
+  /** Print ## next up and handle --pick. */
+  const printNextUp = () => {
+    if (!suggestions.length) return;
     console.log(`\n## next up`);
     for (let i = 0; i < suggestions.length; i++) {
       console.log(`  [${i + 1}] ${suggestions[i].text}`);
       if (suggestions[i].run) console.log(`      → ${suggestions[i].run}`);
     }
-
     if (pickIdx !== null) {
       if (pickIdx > suggestions.length) {
         console.error(
@@ -461,5 +355,184 @@ export const cmdKickoff = (a: string[]) => {
         process.exit(1);
       }
     }
+  };
+
+  // --- main output ---
+
+  // Deferred output for the no-args path — recent closes, plan sweep, rotate
+  let kickoffExtras: (() => void) | null = null;
+
+  if (!arg && !planFile) {
+    // no args = ranked open rows + next up + recent closes
+    console.log(`# ${app} — ${all.length} entries`);
+
+    const open = openRows(all);
+    const claims = claimsOf(all);
+    const diffFiles = getBranchDiffFiles(root);
+
+    // Tier 1: unclaimed bugs (always first, no matter how old) — capped: a
+    // backlog of unclosable bugs must not push the rest of the ranking out.
+    const bugs = open.filter((r) => r.kind === "bug" && !claims.has(r.id));
+    if (bugs.length) {
+      console.log(`\n## bugs`);
+      for (const r of bugs.slice(0, BUGS_LIMIT)) console.log(fmtRow(r));
+      if (bugs.length > BUGS_LIMIT)
+        console.log(
+          `… +${bugs.length - BUGS_LIMIT} more unclosed bugs — \`fapony mem find <word>\` for the rest`,
+        );
+    }
+
+    // next up BEFORE the branch/recency tiers so no row-list section can
+    // push it out — order is by actionability, never by "this tier is short".
+    printNextUp();
+
+    // Tier 2: rows whose files[] overlap with git diff --name-only dev...HEAD
+    // — capped like every other row-list section (≤10 + overflow, pointer
+    // lines via shortText): the branch diff is unbounded and mem clusters on
+    // files every real branch touches, so uncapped this reprints the log.
+    const bugIds = new Set(bugs.map((r) => r.id));
+    const diffMatched = open.filter((r) => {
+      if (bugIds.has(r.id)) return false;
+      if (diffFiles.size === 0) return false;
+      return (r.files ?? []).some((f) => diffFiles.has(f));
+    });
+    if (diffMatched.length) {
+      console.log(`\n## on this branch`);
+      for (const r of diffMatched.slice(0, BRANCH_LIMIT))
+        console.log(fmtRow({ ...r, text: shortText(r.text) }, claims));
+      if (diffMatched.length > BRANCH_LIMIT)
+        console.log(
+          `… +${diffMatched.length - BRANCH_LIMIT} more — \`fapony mem find <word>\` for the rest`,
+        );
+    }
+
+    // Tier 3: rest by recency (newest first) — tie-breaker only, capped like
+    // ## recent (doneLines takes 10): decision/note can never close, so an
+    // uncapped tier reprints the whole log. Lines are pointers, not prose —
+    // cut at a word boundary and point at mem find for the rest.
+    const shown = new Set([...bugIds, ...diffMatched.map((r) => r.id)]);
+    const rest = open
+      .filter((r) => !shown.has(r.id))
+      .sort((a, b) => b.ts.localeCompare(a.ts));
+    if (rest.length) {
+      console.log(`\n## recent open`);
+      for (const r of rest.slice(0, RECENT_OPEN_LIMIT))
+        console.log(fmtRow({ ...r, text: shortText(r.text) }, claims));
+      if (rest.length > RECENT_OPEN_LIMIT)
+        console.log(
+          `… +${rest.length - RECENT_OPEN_LIMIT} more — \`fapony mem find <word>\` for the rest`,
+        );
+    }
+
+    // recent closes, plan sweep, rotate — after next up
+    kickoffExtras = () => {
+      console.log(`\n## recent\n${doneLines(all, 10).join("\n")}`);
+      const sweep = planSweepLine();
+      if (sweep) console.log(sweep);
+      const rotate = rotateLine(all.length);
+      if (rotate) console.log(rotate);
+    };
+  } else if (resolvedSpec) {
+    // spec.md = a brief for that spec
+    const open = openRows(all);
+    const specRows = open.filter((r) => r.spec === resolvedSpec);
+    const specDecisions = all
+      .filter(
+        (r): r is WorkRow => r.kind === "decision" && r.spec === resolvedSpec,
+      )
+      .slice(-5);
+    const specCloses = all
+      .filter((r): r is CloseRow => r.kind === "close")
+      .filter((r) => byId.get(r.ref)?.spec === resolvedSpec)
+      .slice(-3);
+
+    console.log(`# ${resolvedSpec} — ${specRows.length} open rows`);
+    if (specRows.length) {
+      console.log(`\n## open\n${specRows.map((r) => fmtRow(r)).join("\n")}`);
+    }
+    if (specDecisions.length) {
+      console.log(
+        `\n## decisions\n` +
+          specDecisions
+            .map((r) => `- ${r.ts.slice(0, 10)} ${r.text}`)
+            .join("\n"),
+      );
+    }
+    if (specCloses.length) {
+      console.log(
+        `\n## closes\n${specCloses.map((c) => fmtClose(c, byId)).join("\n")}`,
+      );
+    }
+    if (!specRows.length && !specDecisions.length && !specCloses.length) {
+      console.log("(no entries for this spec)");
+    }
+  } else if (target) {
+    // id = a brief for that task
+    const claims = claimsOf(all);
+    const claimInfo = claims.has(arg)
+      ? `\nClaimed by: ${claims.get(arg)?.agent} (${claims.get(arg)?.ts.slice(0, 10)})`
+      : "";
+
+    const spec = target.spec;
+    const open = spec
+      ? openRows(all).filter((r) => r.spec === spec && r.id !== arg)
+      : [];
+    const specDecisions = spec
+      ? all
+          .filter((r): r is WorkRow => r.kind === "decision" && r.spec === spec)
+          .slice(-5)
+      : [];
+    const specNotes = spec
+      ? all
+          .filter((r): r is WorkRow => r.kind === "note" && r.spec === spec)
+          .slice(-5)
+      : [];
+    const specCloses = spec
+      ? all
+          .filter((r): r is CloseRow => r.kind === "close")
+          .filter((r) => byId.get(r.ref)?.spec === spec)
+          .slice(-3)
+      : [];
+
+    console.log(
+      `# [${target.id}] ${target.kind} — ${target.text}${target.spec ? ` → ${target.spec}` : ""}${claimInfo}`,
+    );
+    if (open.length) {
+      console.log(
+        `\n## open (same spec)\n` +
+          open.map((r) => fmtRow(r, claims)).join("\n"),
+      );
+    }
+    if (specDecisions.length || specNotes.length) {
+      console.log(`\n## decisions & notes (spec)\n`);
+      for (const r of [...specDecisions, ...specNotes]) {
+        console.log(`- ${r.ts.slice(0, 10)} ${r.kind} ${r.text}`);
+      }
+    }
+    if (specCloses.length) {
+      console.log(
+        `\n## closes (spec)\n` +
+          specCloses.map((c) => fmtClose(c, byId)).join("\n"),
+      );
+    }
+  } else if (planFile) {
+    const title = readPlanTitle(planFile);
+    console.log(`# ${title || basename(planFile)} — plan`);
+    if (planCheckboxes.length) {
+      console.log(
+        `\n## unchecked\n${planCheckboxes.map((c) => `- [ ] ${c}`).join("\n")}`,
+      );
+    } else {
+      console.log(`\n(all chunks checked — ready to ship or archive)`);
+    }
+  } else if (arg) {
+    console.error(`no id "${arg}" in the log`);
+    process.exit(1);
   }
+
+  // For non-no-args paths, print next up at the end
+  if (arg || planFile) printNextUp();
+
+  // Deferred output from no-args path (recent closes, plan sweep, rotate)
+  kickoffExtras?.();
 };