fapony 0.2.1 → 0.3.0

package/src/hook.ts

@@ -29,8 +29,9 @@ import { homedir } from "node:os";
 import { basename, join, relative, resolve, sep } from "node:path";
 import { buildGraphCached, collectSourceFiles, SCAN_EXTS } from "./analyze.js";
 import { openDb } from "./db/index.js";
-import { debtForFile, loadConventions } from "./debt.js";
-import { readMemLog } from "./memory.js";
+import { debtForFile, loadConventions } from "./debt/index.js";
+import { detectTestRunner } from "./detect.js";
+import { readMemLog, whereMemDir } from "./memory.js";
 
 // --- Hint-fire log (PLAN-feedback-surface chunk 1) ---
 //
@@ -255,6 +256,8 @@ export function decideStop(opts: {
   verdicts: number;
   commitList?: string[];
   memLastTs?: string | null;
+  /** Logs that exist in the repo but are out of scope from this worktree. */
+  memCandidates?: string[];
 }): string | null {
   if (opts.stopHookActive) return null; // already blocked once — let it end
   if (!opts.worktree) return null;
@@ -272,16 +275,30 @@ export function decideStop(opts: {
     lines.push(
       `mem: last row ${opts.memLastTs.slice(0, 10)} — nothing newer this session`,
     );
+  } else if (opts.memCandidates?.length) {
+    // "nothing recorded" would be a lie: the log exists, it is just not in
+    // scope from here (monorepo — the log lives in the app dir). Say where.
+    lines.push(
+      `mem: no log in scope from ${opts.worktree} — found ` +
+        `${opts.memCandidates.join(", ")} (run mem commands from there, or --mem-dir)`,
+    );
   } else {
     lines.push("mem: no rows at all — nothing recorded in this project yet");
   }
+  const runner = detectTestRunner(opts.worktree);
+  const verifyLine = runner
+    ? `If you did not run \`${runner.typecheckCmd ? `${runner.typecheckCmd} and ` : ""}${runner.testCmd}\` to a real exit code, ` +
+      `the honest verdict is uncertain, not pass. `
+    : `If you did not run this repo's typecheck and test suite to a real exit code, ` +
+      `the honest verdict is uncertain, not pass. `;
+
   lines.push(
     `Call verdict_submit before ending: worktree must be the absolute path above, ` +
       `regime is one of code|fix|review|plan|inquiry|test, and the note must stand alone ` +
       `(it is read months from now with no access to this conversation). ` +
       `Grade what actually happened — pass-family when it held up, fail if the first ` +
-      `attempt was wrong, uncertain when you could not verify it. What deserves a mem ` +
-      `row (decision/bug/note) is your call — not every unit needs one.`,
+      `attempt was wrong, uncertain when you could not verify it. ${verifyLine}` +
+      `What deserves a mem row (decision/bug/note) is your call — not every unit needs one.`,
   );
   return lines.join("\n");
 }
@@ -390,6 +407,67 @@ export function stopOutput(client: StopClient, reason: string): string {
   return JSON.stringify({ decision: "block", reason });
 }
 
+// --- Block dedupe (one block per session + worktree) ---
+//
+// stop_hook_active only suppresses the block that fires *immediately* after
+// one. Every later turn that still carries ungraded commits blocks again, so
+// a session that keeps committing gets the same paragraph 4-5 times. The
+// first block already delivered it; the repeats add noise, not force (rule 9
+// — the forcing happens once, and the agent that ignored it once is not
+// persuaded by the fifth copy).
+//
+// Keyed by the transcript path, which is already the session identity the
+// commit window is measured from — no session field to thread through.
+
+const STOP_BLOCK_DIR = "stop-block";
+
+interface StopBlockRow {
+  ts: string;
+  worktree: string;
+}
+
+/** Absolute path of a session's block log — may not exist. */
+export function stopBlockPath(session: string): string {
+  const base =
+    process.env.FAPONY_STATE_DIR || join(homedir(), ".config", "fapony");
+  return join(base, STOP_BLOCK_DIR, `${sessionKey(session)}.jsonl`);
+}
+
+/**
+ * True when this session already blocked for this worktree — the caller then
+ * lets the turn end. Records the block when it has not. Every unknown (no
+ * session identity, unwritable state dir) resolves to false: a dedupe that
+ * guesses must fail towards blocking, never towards silence.
+ */
+export function stopBlockedBefore(
+  session: string | null,
+  worktree: string,
+): boolean {
+  if (!session) return false;
+  const path = stopBlockPath(session);
+  try {
+    if (existsSync(path)) {
+      for (const line of readFileSync(path, "utf-8").split("\n")) {
+        if (!line) continue;
+        try {
+          if ((JSON.parse(line) as StopBlockRow).worktree === worktree) {
+            return true;
+          }
+        } catch {
+          // a torn line must not lose the rest of the log
+        }
+      }
+    }
+    const dir = join(path, "..");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const row: StopBlockRow = { ts: new Date().toISOString(), worktree };
+    appendFileSync(path, `${JSON.stringify(row)}\n`, "utf-8");
+  } catch {
+    return false;
+  }
+  return false;
+}
+
 /** Reads the Stop-hook JSON on stdin, prints a block decision or nothing. */
 export async function cmdHookStop(): Promise<void> {
   let reason: string | null = null;
@@ -421,6 +499,7 @@ export async function cmdHookStop(): Promise<void> {
     let commitList: string[] = [];
     let verdicts = 0;
     let memLastTs: string | null = null;
+    let memCandidates: string[] = [];
     if (worktree && since) {
       const log = git(
         ["log", "--since", `${since} +0000`, "--format=%h %s"],
@@ -442,6 +521,8 @@ export async function cmdHookStop(): Promise<void> {
         try {
           const mem = readMemLog(worktree);
           memLastTs = mem.rows[0]?.ts ?? null;
+          if (!memLastTs)
+            memCandidates = whereMemDir(worktree).candidates ?? [];
         } catch {
           memLastTs = null;
         }
@@ -455,7 +536,16 @@ export async function cmdHookStop(): Promise<void> {
       verdicts,
       commitList,
       memLastTs,
+      memCandidates,
     });
+    // Already blocked for this worktree in this session — say it once.
+    if (
+      reason &&
+      worktree &&
+      stopBlockedBefore(norm.transcriptPath, worktree)
+    ) {
+      reason = null;
+    }
   } catch {
     reason = null; // any failure = allow the turn to end
   }
@@ -463,6 +553,78 @@ export async function cmdHookStop(): Promise<void> {
   if (reason) console.log(stopOutput(client, reason));
 }
 
+// --- Session start (kickoff as context, not as a thing to remember) ---
+//
+// `fapony mem kickoff` is the one command that pays for itself at session
+// open — what is open, what is stale, what the last rows touched. Asking the
+// agent to run it measured as not enough (rule 9), and an MCP tool would pay
+// schema rent in every session of every client to save one bash round
+// (rule 13). A SessionStart hook is neither: zero rent, and it fires whether
+// or not anyone remembers.
+//
+// Runs the CLI in a subprocess rather than calling cmdKickoff: kickoff prints
+// to stdout and exits on bad input, both of which would be this hook's stdout.
+
+/** Cap on injected context — kickoff is short, a broken repo's output is not. */
+export const SESSION_START_MAX_CHARS = 4_000;
+
+const TRUNCATED = "… truncated — run `fapony mem kickoff` for the rest";
+
+/** Trim to whole lines, keeping the marker's line boundary intact. */
+function headLines(text: string, max: number): string {
+  const cut = text.slice(0, max);
+  const lastNl = cut.lastIndexOf("\n");
+  return (lastNl > 0 ? cut.slice(0, lastNl) : cut).trimEnd();
+}
+
+/**
+ * Trim to whole lines within the cap, with an honest truncation marker.
+ *
+ * "## next up" is kickoff's last section and its most actionable one, so a
+ * plain head-cut drops exactly the part worth injecting in a repo with a long
+ * open list (measured here: 92 rows, the cut landed mid-history). Keep it and
+ * spend the rest of the budget on the head.
+ */
+export function capContext(
+  text: string,
+  max = SESSION_START_MAX_CHARS,
+): string {
+  if (text.length <= max) return text;
+  const at = text.lastIndexOf("\n## next up");
+  const tail = at > 0 ? text.slice(at).trimEnd() : "";
+  if (tail && tail.length < max / 2) {
+    return `${headLines(text, max - tail.length)}\n${TRUNCATED}\n${tail}`;
+  }
+  return `${headLines(text, max)}\n${TRUNCATED}`;
+}
+
+/** SessionStart hook: inject `fapony mem kickoff` output as context. */
+export async function cmdHookSessionStart(): Promise<void> {
+  try {
+    const raw = JSON.parse(await Bun.stdin.text()) as { cwd?: string };
+    const cwd = raw.cwd ?? process.cwd();
+    // No mem log in scope = nothing to say. Silence beats "no rows yet".
+    if (!whereMemDir(cwd).dir) return;
+    const p = Bun.spawnSync([process.execPath, Bun.main, "mem", "kickoff"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = p.stdout.toString().trim();
+    if (p.exitCode !== 0 || !out) return;
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: capContext(out),
+        },
+      }),
+    );
+  } catch {
+    // any failure = no context, never a broken session start
+  }
+}
+
 // --- Read hint (PreToolUse annotate — never block, never dedupe) ---
 //
 // Reading a large file in full is where an agent spends tokens without
@@ -523,7 +685,7 @@ export function readHintFor(opts: ReadHintInput): string | null {
     return (
       `fapony: ${shown} is ${lines} lines — review-seed --files ${shown} ` +
       `returns exports with line numbers, importers, and signatures first ` +
-      `(${READ_HINT_MEASURED})`
+      `(${READ_HINT_MEASURED}; skill /lookup-before-edit has the routine)`
     );
   } catch {
     return null;
@@ -785,7 +947,7 @@ export function editHintFor(opts: EditHintInput): string | null {
     return (
       `fapony: ${rel} has ${n} importer${n === 1 ? "" : "s"} — ` +
       `review-seed --files ${rel} lists them (add --callers <export> for one ` +
-      `export's callers); check before changing its shape`
+      `export's callers); check before changing its shape (skill /lookup-before-edit)`
     );
   } catch {
     return null;

package/src/install/claude.ts

@@ -353,6 +353,7 @@ function installClaudeHooks(dryRun: boolean, deps: InstallDeps): void {
   installStopHook(dryRun, deps);
   installReadHintHook(dryRun, deps);
   installEditHintHook(dryRun, deps);
+  installSessionStartHook(dryRun, deps);
 }
 
 function installStopHook(dryRun: boolean, deps: InstallDeps): void {
@@ -395,3 +396,16 @@ function installEditHintHook(dryRun: boolean, deps: InstallDeps): void {
     label: "edit hint",
   });
 }
+
+/**
+ * SessionStart hook: injects `fapony mem kickoff` as context when the repo has
+ * a mem log, and stays silent when it does not. Context only — SessionStart
+ * cannot block, and a repo without mem never sees a line.
+ */
+function installSessionStartHook(dryRun: boolean, deps: InstallDeps): void {
+  ensureClaudeHook(dryRun, deps, {
+    event: "SessionStart",
+    subcommand: "hook-session-start",
+    label: "session start",
+  });
+}

package/src/install/codex.ts

@@ -1,7 +1,7 @@
 // src/install/codex.ts — Codex install provider
 //
 // Reads/writes ~/.codex/config.toml directly for MCP config.
-// Reads/writes ~/.codex/hooks.json for lifecycle hooks (Stop).
+// Reads/writes ~/.codex/hooks.json for lifecycle hooks (Stop, SessionStart).
 // Symlinks skills into ~/.agents/skills/ (same dir as ZCode).
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -46,18 +46,25 @@ function readJsonObject(path: string): Record<string, unknown> | null {
 }
 
 /**
- * Append the fapony Stop hook to ~/.codex/hooks.json.
- * Never replaces other hook groups or foreign entries within the Stop group.
- * Fapony-owned entry is identified by the command string containing "hook-stop".
+ * Append a fapony command hook to one event group in ~/.codex/hooks.json.
+ * Never replaces other hook groups or foreign entries within the group.
+ * A fapony-owned entry is identified by the subcommand string
+ * ("hook-stop" / "hook-session-start") inside its command — per-group
+ * idempotence, so an existing install with only Stop still picks up
+ * SessionStart on the next run.
  */
-function installStopHook(dryRun: boolean, getHome: () => string): void {
+function installCodexHookGroup(
+  dryRun: boolean,
+  getHome: () => string,
+  opts: { event: "Stop" | "SessionStart"; subcommand: string; label: string },
+): void {
   const hooksPath = join(getHome(), ".codex", "hooks.json");
   let config: Record<string, unknown> = {};
   if (existsSync(hooksPath)) {
     const parsed = readJsonObject(hooksPath);
     if (!parsed) {
       console.error(
-        `  stop hook: ${hooksPath} is unreadable or malformed — skipping`,
+        `  ${opts.label}: ${hooksPath} is unreadable or malformed — skipping`,
       );
       return;
     }
@@ -70,45 +77,76 @@ function installStopHook(dryRun: boolean, getHome: () => string): void {
     (typeof hookMap !== "object" || Array.isArray(hookMap))
   ) {
     console.error(
-      `  stop hook: ${hooksPath} has an unexpected "hooks" shape — skipping`,
+      `  ${opts.label}: ${hooksPath} has an unexpected "hooks" shape — skipping`,
     );
     return;
   }
 
   const map = (hookMap ?? {}) as Record<string, unknown>;
-  // Codex Stop array: each element is { matcher?, hooks: [...] }
-  const stop = Array.isArray(map.Stop) ? (map.Stop as unknown[]) : [];
-
-  // Check if fapony stop hook already present (by command string)
-  const serialized = JSON.stringify(stop);
-  if (serialized.includes("hook-stop")) {
-    console.error(`  stop hook: already configured in hooks.json — no change`);
+  // Codex event arrays: each element is { matcher?, hooks: [...] }
+  const group = Array.isArray(map[opts.event])
+    ? (map[opts.event] as unknown[])
+    : [];
+
+  // Check if the fapony hook is already present in this group (by subcommand)
+  const serialized = JSON.stringify(group);
+  if (serialized.includes(opts.subcommand)) {
+    console.error(
+      `  ${opts.label}: already configured in hooks.json — no change`,
+    );
     return;
   }
 
-  const command = `bun ${join(INSTALL_ROOT, "fapony.ts")} hook-stop`;
+  const command = `bun ${join(INSTALL_ROOT, "fapony.ts")} ${opts.subcommand}`;
   const faponyEntry = { hooks: [{ type: "command", command }] };
   const after = {
     ...config,
-    hooks: { ...map, Stop: [...stop, faponyEntry] },
+    hooks: { ...map, [opts.event]: [...group, faponyEntry] },
   };
 
   if (!dryRun) {
     try {
       writeFileSync(hooksPath, `${JSON.stringify(after, null, 2)}\n`, "utf-8");
     } catch (e) {
-      console.error(`  stop hook: failed to write — ${(e as Error).message}`);
+      console.error(
+        `  ${opts.label}: failed to write — ${(e as Error).message}`,
+      );
       return;
     }
   }
   console.error(
-    `  stop hook: ${dryRun ? "would write" : "wrote"} hooks.Stop → ${hooksPath}`,
+    `  ${opts.label}: ${dryRun ? "would write" : "wrote"} hooks.${opts.event} → ${hooksPath}`,
   );
   console.error(
     `    review and trust via Codex /hooks before the hook will run`,
   );
 }
 
+function installStopHook(dryRun: boolean, getHome: () => string): void {
+  installCodexHookGroup(dryRun, getHome, {
+    event: "Stop",
+    subcommand: "hook-stop",
+    label: "stop hook",
+  });
+}
+
+/**
+ * SessionStart hook: injects `fapony mem kickoff` as context when the repo
+ * has a mem log, silent when it does not (cmdHookSessionStart exits quiet).
+ * Same `hookSpecificOutput.additionalContext` contract Claude uses — Codex
+ * SessionStart reads that channel too. No matcher: match-all fires on every
+ * source including `clear` and on versions that send no source at all, where
+ * a `startup|resume` matcher would silently never fire; kickoff is capped at
+ * 4k and costs one cheap spawn, so the /clear path stays fast.
+ */
+function installSessionStartHook(dryRun: boolean, getHome: () => string): void {
+  installCodexHookGroup(dryRun, getHome, {
+    event: "SessionStart",
+    subcommand: "hook-session-start",
+    label: "session start",
+  });
+}
+
 export function cmdInstallCodex(dryRun: boolean, deps: InstallDeps = {}): void {
   const exitFn = deps.exit ?? defaultExit;
   const getHome = deps.homedir ?? homedir;
@@ -144,8 +182,9 @@ export function cmdInstallCodex(dryRun: boolean, deps: InstallDeps = {}): void {
     console.error(`  restart Codex to load the MCP server`);
   }
 
-  // --- Stop hook (~/.codex/hooks.json) ---
+  // --- Stop + SessionStart hooks (~/.codex/hooks.json) ---
   installStopHook(dryRun, getHome);
+  installSessionStartHook(dryRun, getHome);
 
   // --- Skills (~/.agents/skills/) ---
   const skillsDir = agentsSkillsDir(getHome);

package/src/install/opencode.ts

@@ -114,6 +114,7 @@ export function cmdInstallOpencode(
     installReadHintPlugin(dryRun, getHome);
     installCommitHintPlugin(dryRun, getHome);
     installEditHintPlugin(dryRun, getHome);
+    installSessionStartPlugin(dryRun, getHome);
     return;
   }
 
@@ -138,6 +139,7 @@ export function cmdInstallOpencode(
     installReadHintPlugin(dryRun, getHome);
     installCommitHintPlugin(dryRun, getHome);
     installEditHintPlugin(dryRun, getHome);
+    installSessionStartPlugin(dryRun, getHome);
     return;
   }
 
@@ -160,6 +162,7 @@ export function cmdInstallOpencode(
   installReadHintPlugin(dryRun, getHome);
   installCommitHintPlugin(dryRun, getHome);
   installEditHintPlugin(dryRun, getHome);
+  installSessionStartPlugin(dryRun, getHome);
 }
 
 /**
@@ -483,3 +486,98 @@ function installEditHintPlugin(dryRun: boolean, getHome: () => string): void {
     `  edit hint: ${dryRun ? "would write" : "wrote"} ${pluginPath}`,
   );
 }
+
+/**
+ * OpenCode plugin — session-start context via `fapony mem kickoff`, the
+ * OpenCode parity of Claude's SessionStart hook.
+ *
+ * Why `experimental.chat.system.transform` and not the `event` hook on
+ * `session.created`: the event hook is observer-only (returns void, no
+ * injection channel), while system.transform's `output.system` is the
+ * documented injection point (`packages/plugin/src/index.ts`: input
+ * `{ sessionID?, model }`, output `{ system: string[] }`). The context lands
+ * on the first model dispatch instead of at session creation — one step late,
+ * the same shape as every other OpenCode hint (annotate-after), and arguably
+ * better: sessions that never dispatch never pay the spawn.
+ *
+ * Once per session (closure Set — the factory runs once per server), silent
+ * when kickoff exits nonzero or prints nothing (no mem log in scope), never
+ * throws. `process.execPath` is the bun running opencode itself — no PATH
+ * dependency. Logic shared via `capContext` in src/hook.ts, same one-copy
+ * shape as the other three plugins.
+ */
+export function sessionStartPluginSource(root: string): string {
+  const hookModule = JSON.stringify(join(root, "src", "hook.ts"));
+  const faponyTs = JSON.stringify(join(root, "fapony.ts"));
+  return `// fapony session start — injects \`fapony mem kickoff\` as context once per
+// session, silent when the repo has no mem log. Annotate only: never blocks.
+// Generated by \`fapony install\` — edit src/hook.ts in the fapony checkout.
+import { capContext } from ${hookModule};
+
+export const FaponySessionStart = async ({ directory }) => {
+  const seen = new Set();
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      try {
+        const sessionID = input?.sessionID;
+        if (!sessionID || seen.has(sessionID)) return;
+        seen.add(sessionID);
+        const { spawnSync } = require("node:child_process");
+        const kick = spawnSync(process.execPath, [${faponyTs}, "mem", "kickoff"], {
+          cwd: directory,
+          encoding: "utf-8",
+        });
+        if (kick.status !== 0) return;
+        const out = (kick.stdout ?? "").toString().trim();
+        if (!out) return;
+        output.system.push(capContext(out));
+      } catch {
+        // context must never break a session start
+      }
+    },
+  };
+};
+`;
+}
+
+function installSessionStartPlugin(
+  dryRun: boolean,
+  getHome: () => string,
+): void {
+  const pluginsDir = join(getHome(), ".config", "opencode", "plugins");
+  const pluginPath = join(pluginsDir, "fapony-session-start.ts");
+  if (existsSync(pluginPath)) {
+    let current = "";
+    try {
+      current = readFileSync(pluginPath, "utf-8");
+    } catch {
+      current = "";
+    }
+    if (current.includes("capContext")) {
+      console.error(`  session start: already installed — no change`);
+      return;
+    }
+    console.error(
+      `  session start: ${pluginPath} exists but isn't fapony's — not overwriting.`,
+    );
+    return;
+  }
+  if (!dryRun) {
+    try {
+      mkdirSync(pluginsDir, { recursive: true });
+      writeFileSync(
+        pluginPath,
+        sessionStartPluginSource(INSTALL_ROOT),
+        "utf-8",
+      );
+    } catch (e) {
+      console.error(
+        `  session start: failed to write — ${(e as Error).message}`,
+      );
+      return;
+    }
+  }
+  console.error(
+    `  session start: ${dryRun ? "would write" : "wrote"} ${pluginPath}`,
+  );
+}

package/src/lint-baseline.ts

@@ -52,12 +52,12 @@ function gitSha(cwd: string): string {
   return p.exitCode === 0 ? p.stdout.toString().trim().slice(0, 12) : "none";
 }
 
-function baselinePath(worktree: string): string {
+export function baselinePath(worktree: string): string {
   const key = worktree.replace(/[^A-Za-z0-9._-]+/g, "_");
   return join(faponyDir(), "lint-baseline", `${key}.json`);
 }
 
-function readEvidenceLintCmd(worktree: string): string | null {
+export function readEvidenceLintCmd(worktree: string): string | null {
   const evidence = join(worktree, DEFAULT_EVIDENCE_FILE);
   try {
     const parsed = JSON.parse(readFileSync(evidence, "utf-8")) as {

package/src/mcp/tools/index.ts

@@ -9,8 +9,7 @@
 import { VERDICT_GRADES } from "../../parse.js";
 import { REASON_CODES, REGIME_CODES } from "../types.js";
 
-export { toolMemAdd, toolMemFind } from "./mem.js";
-export { toolPassiveUsage } from "./usage.js";
+export { toolMemAdd, toolMemClose, toolMemFind } from "./mem.js";
 export { toolVerdictSubmit } from "./verdict.js";
 
 // --- Tool definitions ---
@@ -179,43 +178,29 @@ export const TOOLS = [
     },
   },
   {
-    name: "fapony_usage",
+    name: "mem_close",
     description:
-      "Query passive usage across every coding client on this machine — " +
-      "OpenCode, Claude Code, Codex, and ZCode — on one ruler: token counts, " +
-      "cost, and breakdown by model. No client's own session log can see " +
-      "another's, so this is the only way to compare them. Filter by " +
-      "worktree and time range.",
+      "Close a mem row by id with a tombstone message (what was done). " +
+      "The write half of closing what mem_find shows as open — id must exist. " +
+      "Returns the ref and timestamp.",
     inputSchema: {
       type: "object" as const,
       properties: {
         worktree: {
           type: "string",
-          description: "Filter by worktree path (absolute)",
-        },
-        since: {
-          type: "number",
-          description:
-            "Unix timestamp — include sessions created at or after this time",
-        },
-        until: {
-          type: "number",
           description:
-            "Unix timestamp — include sessions created at or before this time",
+            "Absolute path (git rev-parse --show-toplevel) — required",
         },
-        detail: {
-          type: "boolean",
-          description:
-            "If true, include tool-call breakdown + step counts per session " +
-            "(activity signal, not quality). Default false keeps output compact.",
+        id: {
+          type: "string",
+          description: "The row id to close",
         },
-        json: {
-          type: "boolean",
-          description:
-            "If true, return raw JSON PassiveUsageResult. If false (default), return human-readable text.",
+        text: {
+          type: "string",
+          description: "Tombstone message — what was done (commit sha counts)",
         },
       },
-      required: [],
+      required: ["worktree", "id", "text"],
     },
   },
 ];