fapony 0.3.5 → 0.4.0

package/README.md

@@ -38,26 +38,9 @@ quietly counted as free.
 
 That is day one. Past that, fapony keeps what coding agents actually did — the frozen
 ledger of graded runs (rounds, pass/fail, cost per grade, readable via CLI, no new grades)
-plus the live mem log — through 3 MCP tools any agent can call. If you juggle more than
-one agent, this is the point: the numbers come from the same yardstick everywhere, so
-"which model earns its keep on which kind of task" becomes a data question instead of a
-vibe. On top of history it checks claims against git facts: handoff conformance and
-allowlisted evidence — with everything the agent claimed but couldn't prove marked as such.
-
-**What that question looks like answered, from one project's own (frozen — reads history,
-no new grades) ledger — the top of the `n≥5` frontier (`fapony stats --mode verdict --regime code`):**
-
-| model | tokens/pass | quality | n |
-|---|---|---|---|
-| `claude-opus-5` | 22.5M | 3.8 | 10 |
-| `claude-sonnet-5` | 5.6M | 3.5 | 11 |
-| `muse-spark-1.3-contributor-free` | 4.3M | 4.0 | 5 |
-
-Same quality band, an 8× token spread — the kind of answer a session log can't give (it has tokens,
-no grades) and a benchmark can't give either (it has grades, not your codebase). One caveat that's
-on you to hold: work isn't randomly assigned to models, so a gap this size is a strong prior, not a
-controlled trial — you likely route easy tasks to the cheap model already. `n≥5` is fapony's own
-floor before a model counts toward the frontier at all; below that it's a data point, not a pick.
+plus the live mem log — through 3 MCP tools any agent can call. It checks claims against
+git facts: handoff conformance and allowlisted evidence — with everything the agent claimed
+but couldn't prove marked as such.
 
 **The reason to keep it running is the third layer: knowledge accumulation — and the thing it
 accumulates is pain.** An agent has no memory of pain across sessions: it writes the 37th
@@ -72,7 +55,7 @@ already decided on, that is the loop: notice the repeated cost, name the shared
 migration finish. Finding dead code and duplication is *not* part of it — knip and friends already
 do that better, and a convention with a `checker` is deliberately left to the checker.
 
-**The measurement layer underneath it:** Any single client already logs its own session — timing, tokens, tool calls. What none of them see is *across* runs, clients and task shapes: which model earns its keep on which kind of work **in this project**, at what token cost. The frozen ledger still answers that from history — every old verdict carries a `regime` (`code` / `fix` / `review` / `plan` / `inquiry` / `test`), and runs split by whether there was a plan at all — so "does planning beat diving in, and for which model" stays a table, not an argument. New accumulation goes to the mem log instead: decisions, bugs and notes with `files[]`, written by the agents doing the work.
+**The measurement layer underneath it:** Any single client already logs its own session — timing, tokens, tool calls. What none of them see is *across* runs, clients and task shapes: what each model costs you, across clients, on one yardstick, in this project (`fapony usage-web`, above) — tokens and cost, nothing self-graded. The frozen ledger still has old verdict rows (`fapony stats`), but the tool that wrote them (`verdict_submit`) is gone from the MCP surface: no new rows, for anyone, ever again, so a count of old rows (`n`) means nothing without the grading that stopped. New accumulation goes to the mem log instead: decisions, bugs and notes with `files[]`, written by the agents doing the work.
 
 Three tiers, deliberately: **measurement ships today** and needs no per-project setup — raw facts nobody can call unfair. **Verification is the sharper edge** but stays beta until its evidence layer is hardened; fapony doesn't control your agent's flow, so it never promises "verified" as a headline. **Knowledge accumulation is the compounding one** — it's worthless on run 1 and gets more useful every run after, which is exactly why it's the layer competitors can't clone by copying a feature list.
 
@@ -381,6 +364,12 @@ at once. ZCode and Codex get the same skills linked into `~/.agents/skills`. A d
 that already exists and isn't a fapony link is reported and left alone — replace it by hand
 if you want fapony's version.
 
+OpenCode is the one client whose hooks are generated files rather than `fapony hook-*`
+commands, so `fapony update` also re-runs the installer in a fresh process to refresh them —
+with `--plugins-only`, so a refresh touches fapony's plugin files and never your
+`opencode.json`. A fapony-owned plugin is rewritten in place; a file that isn't fapony's is
+reported and left alone, same as the skill links.
+
 `plan-with-pony` is vendor-neutral — the SKILL.md *is* the prompt, so pipe it to any agent:
 
 ```bash
@@ -434,9 +423,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 +454,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.4.0",
   "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)",
@@ -35,6 +35,7 @@
     "check": "bun run lint && bun run typecheck && bun test --timeout 20000 --parallel",
     "prepublishOnly": "bash scripts/smoke-publish.sh",
     "release": "git checkout main && git pull --ff-only && npm version patch -m 'release v%s' && git push origin main --follow-tags",
+    "release:minor": "git checkout main && git pull --ff-only && npm version minor -m 'release v%s' && git push origin main --follow-tags",
     "overview": "bun fapony.ts report-web /tmp/fapony-overview.html && open /tmp/fapony-overview.html"
   },
   "devDependencies": {

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"],
     },