fapony 0.3.6 → 0.5.0

package/src/seed/plan-seed.ts

@@ -1,4 +1,4 @@
-// src/seed/plan-seed.ts — `fapony plan-seed <name> [--spec] [--scope <path>]...`
+// src/seed/plan-seed.ts — `fapony plan-seed <name> [--spec] [--scope <path>[,<path>]]...`
 //
 // Writes PLAN + SPEC straight into planDir/specDir. What it pre-fills is the
 // structure (frontmatter, the 8 sections, prior art, ledger context) — the
@@ -43,8 +43,9 @@ import {
   planDir,
   specDir,
 } from "../core/config.js";
+import { MEM_TEXT_MAX } from "../core/mem-log.js";
 import { extractExports } from "../map.js";
-import { readRecentMemDecisions } from "../memory.js";
+import { readMemLog, readRecentMemDecisions } from "../memory.js";
 import { capLines, execGit, SIG_MAX } from "./primitives.js";
 
 // One chunk = one module's signatures — past ~40 lines a module is its own
@@ -301,6 +302,7 @@ One step = one chunk = one session: finish it, close it, **stop** — starting t
 1. _(agent fills in — each step must be verifiable)_
 
 **Closing a step:** tick TL;DR with sha · \`git commit\` files only · \`fapony mem add note "<what chunk N+1 must know>" --files <f1,f2> ${planRel}\` · next opens with \`kickoff ${planRel}\` (or \`kickoff PLAN-${name}.md\` — kickoff resolves by filename too).
+- [ ] handoff: the mem note is the handoff — this box only opts the plan into the Stop-hook check
 
 ## 7. Examples
 ${
@@ -507,6 +509,7 @@ function specTemplate(
   name: string,
   chunks: Chunk[],
   scopeEcho: string | null,
+  traps: string[],
 ): string {
   const index = chunks.map((c) => `- [${c.title}](#${c.slug})`).join("\n");
   // The index is one string with a newline per chunk; budgeting it as one line
@@ -534,12 +537,18 @@ function specTemplate(
   const tail = [
     "## (agent fills in — wireframes / edge cases / API shapes the plan references)",
   ];
-  const bodyLines = chunks.flatMap((c) => [
-    `## <a id="${c.slug}"></a>${c.title}`,
-    "",
-    ...c.body.split("\n"),
-    "",
-  ]);
+  const bodyLines = [
+    // Known traps sit after the index, before the first chunk body — budgeted
+    // with the bodies so the whole-SPEC cap still cuts from the tail and the
+    // count line above survives (a silent section would teach skipping it).
+    ...(traps.length > 0 ? [...traps, ""] : []),
+    ...chunks.flatMap((c) => [
+      `## <a id="${c.slug}"></a>${c.title}`,
+      "",
+      ...c.body.split("\n"),
+      "",
+    ]),
+  ];
   // Whole-file cap runs last and the agent section survives it, same way
   // review-seed reserves its disclaimer: reserve the tail, cut the middle,
   // say how much was dropped.
@@ -552,10 +561,107 @@ function specTemplate(
   return `${[...head, ...cappedBody, ...tail].join("\n")}\n`;
 }
 
+// --- Known traps (PLAN-active-pain chunk 2): mem rows on this scope ---
+//
+// The one place a seed is allowed to be opinionated: past pain about exactly
+// these files. bug rows first, then decision (note carries no "this hurt"
+// signal), newest first within a kind. Match mirrors mem_find: files[] first;
+// the text/spec fallback runs ONLY for rows with no files[] at all — a row
+// that named files already spoke, its text may quote any path.
+//
+// Measured base rate on this repo before building (rule 2, 2026-09-23):
+// 248 rows total; scope src/seed → 5 matched (3 bug/2 decision, 0 lacked) ·
+// src/mem → 12 (4/8, 0) · src/adapters/hooks → 6 (2/4, 0) · whole repo → 61
+// (20/41, 0). The "M lacked files[]" fallback layer fired 0/4 scopes here —
+// kept because a pre-files[] repo (vela's 2,672 rows) depends on it.
+const MAX_TRAP_ROWS = 5;
+
+interface TrapHit {
+  row: {
+    ts: string;
+    kind: string;
+    text: string;
+    files?: string[];
+    spec?: string;
+  };
+  /** First in-scope file[] entry that matched — null for the text fallback. */
+  file: string | null;
+  viaText: boolean;
+}
+
+export function renderKnownTraps(
+  worktree: string,
+  cwd: string,
+  roots: string[],
+  scoped: boolean,
+): { lines: string[]; matched: number; lacked: number } {
+  const empty = { lines: [], matched: 0, lacked: 0 };
+  try {
+    const { rows, filesFound } = readMemLog(worktree);
+    if (filesFound === 0 || rows.length === 0) return empty;
+
+    const scopeFiles = new Set<string>();
+    for (const r of roots)
+      for (const f of scopeSourceFiles(r)) scopeFiles.add(relative(cwd, f));
+    if (scopeFiles.size === 0) return empty;
+    const scopeKeys = roots
+      .map((r) => relative(cwd, r))
+      .filter((k) => k !== "" && k !== ".");
+
+    const hits: TrapHit[] = [];
+    for (const row of rows) {
+      if (row.kind !== "bug" && row.kind !== "decision") continue;
+      const files = row.files ?? [];
+      const inScope = files.find((f) => scopeFiles.has(f));
+      if (inScope) {
+        hits.push({ row, file: inScope, viaText: false });
+        continue;
+      }
+      // Fallback: only a row with NO files[] — see comment above.
+      if (files.length === 0 && scoped) {
+        const hay = `${row.text}\n${row.spec ?? ""}`;
+        if (scopeKeys.some((k) => hay.includes(k))) {
+          hits.push({ row, file: null, viaText: true });
+        }
+      }
+    }
+    if (hits.length === 0) return empty;
+
+    // Stable sort: bug before decision, recency preserved inside each kind.
+    hits.sort((a, b) =>
+      a.row.kind === b.row.kind ? 0 : a.row.kind === "bug" ? -1 : 1,
+    );
+    const lacked = hits.filter((h) => h.viaText).length;
+    const lines = [
+      "## Known traps (fapony mem)",
+      "",
+      `- ${hits.length} relevant row(s) on this scope (${lacked} lacked files[]${lacked > 0 ? " — matched via text" : ""})`,
+    ];
+    for (const h of hits.slice(0, MAX_TRAP_ROWS)) {
+      const text =
+        h.row.text.length > MEM_TEXT_MAX
+          ? `${h.row.text.slice(0, MEM_TEXT_MAX - 1)}…`
+          : h.row.text;
+      lines.push(
+        `- ${h.row.ts.slice(0, 10)} ${h.row.kind} — ${text}${h.file ? ` (${h.file})` : ""}`,
+      );
+    }
+    if (hits.length > MAX_TRAP_ROWS) {
+      lines.push(
+        `- … +${hits.length - MAX_TRAP_ROWS} more at cap ${MAX_TRAP_ROWS} (bug first, then decision)`,
+      );
+    }
+    return { lines, matched: hits.length, lacked };
+  } catch {
+    return empty; // no mem log / unreadable = a seed with no traps, never an error
+  }
+}
+
 // --- CLI entry ---
 
 export function cmdPlanSeed(args: string[]): void {
-  const usage = "usage: fapony plan-seed <name> [--spec] [--scope <path>]...";
+  const usage =
+    "usage: fapony plan-seed <name> [--spec] [--scope <path>[,<path>]]...";
   // Positional parse, not args.find(!startsWith("--")) — a --scope VALUE is
   // a non-flag argument and must never be mistaken for the plan name.
   let name: string | undefined;
@@ -571,7 +677,20 @@ export function cmdPlanSeed(args: string[]): void {
         console.error(`plan-seed: --scope needs a path\n${usage}`);
         process.exit(1);
       }
-      scopeArgs.push(v);
+      // Agents expect `--scope a,b,c` — same comma shape as `--files` — so a
+      // comma list is split here instead of failing on a path that never is.
+      // A real repo dir can't contain a literal ",x" tail; any comma splits.
+      // Trim each segment too: `a, b` is the same habit as `a,b`, and the
+      // space must not become part of the path (PLAN-comma-x).
+      const syms = v
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (syms.length === 0) {
+        console.error(`plan-seed: --scope needs a path\n${usage}`);
+        process.exit(1);
+      }
+      scopeArgs.push(...syms);
       i++;
     } else if (a.startsWith("--")) {
       console.error(`plan-seed: unknown flag "${a}"\n${usage}`);
@@ -643,6 +762,7 @@ export function cmdPlanSeed(args: string[]): void {
   );
 
   let specLink: string | null = null;
+  let traps = { lines: [] as string[], matched: 0, lacked: 0 };
   if (withSpec) {
     const specDirAbs = join(cwd, specDir());
     const specPath = join(specDirAbs, `SPEC-${name}.md`);
@@ -652,6 +772,7 @@ export function cmdPlanSeed(args: string[]): void {
       );
       process.exit(1);
     }
+    traps = renderKnownTraps(worktree, cwd, roots, scoped);
     const chunks = buildChunks(roots, cwd);
     mkdirSync(specDirAbs, { recursive: true });
     writeFileSync(
@@ -662,6 +783,7 @@ export function cmdPlanSeed(args: string[]): void {
         requested.length > 0
           ? roots.map((r) => relative(cwd, r) || ".").join(", ")
           : null,
+        traps.lines,
       ),
     );
     specLink = `../${specDir().split("/").pop()}/SPEC-${name}.md`;
@@ -691,6 +813,13 @@ export function cmdPlanSeed(args: string[]): void {
   }
   writeFileSync(planPath, planBody);
   console.log(`wrote ${planPath}${specLink ? ` + SPEC-${name}.md` : ""}`);
+  // Measurement surface (plan §3): a silent section is indistinguishable from
+  // "no mem log" — say what was injected so a week of seeds is countable.
+  if (traps.matched > 0) {
+    console.log(
+      `Known traps: ${traps.matched} row(s) injected (${traps.lacked} lacked files[])`,
+    );
+  }
   console.log("Existing plans:");
   for (const l of listExistingPlans(cwd, config, `PLAN-${name}.md`))
     console.log(l);

package/src/seed/review-seed.ts

@@ -21,7 +21,7 @@
 
 import type { Stats } from "node:fs";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { basename, isAbsolute, join, resolve } from "node:path";
 import {
   buildGraph,
   collectSourceFiles,
@@ -61,7 +61,7 @@ const LOOKUP_OUTPUT_CAP = 120;
 const DISCLAIMER =
   "static graph only — seed is where to enter, not what is verified";
 const USAGE =
-  "usage: fapony review-seed [--staged | --commit <sha> | --range <a...b> | --files f1,f2,dir | --plan <PLAN.md>] [--body sym[,sym]] [--callers sym]";
+  "usage: fapony review-seed [--staged | --commit <sha> | --range <a...b> | --files f1,f2,dir | --plan <PLAN.md>] [--body sym[,sym]] [--callers sym[,sym]]";
 // --body / --callers are the executor's lookup, not the reviewer's seed: when
 // either is present the output is only those sections (plus worktree line and
 // disclaimer) — the standard sections would be a wall around the one answer.
@@ -82,13 +82,13 @@ type Scope =
 interface LookupFlags {
   /** --body sym[,sym] — declaration slices from the named file(s). */
   body: string[];
-  /** --callers sym — symbol→symbol grep over importer files. */
-  callers: string | null;
+  /** --callers sym[,sym] — symbol→symbol grep over importer files. */
+  callers: string[];
 }
 
 function parseLookup(args: string[]): LookupFlags {
   const body: string[] = [];
-  let callers: string | null = null;
+  const callers: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "--body" || a === "--callers") {
@@ -97,29 +97,21 @@ function parseLookup(args: string[]): LookupFlags {
         throw new SeedError(`review-seed: ${a} needs a value\n${USAGE}`);
       }
       i++;
-      if (a === "--body") {
-        for (const s of v
-          .split(",")
-          .map((s) => s.trim())
-          .filter(Boolean)) {
-          if (!/^[A-Za-z_$][\w$]*$/.test(s)) {
-            throw new SeedError(`review-seed: invalid symbol: ${s}`);
-          }
-          body.push(s);
-        }
-        if (body.length === 0) {
-          throw new SeedError(`review-seed: --body needs a symbol\n${USAGE}`);
-        }
-      } else {
-        if (!/^[A-Za-z_$][\w$]*$/.test(v)) {
-          throw new SeedError(`review-seed: invalid symbol: ${v}`);
-        }
-        if (callers) {
-          throw new SeedError(
-            `review-seed: --callers takes one symbol\n${USAGE}`,
-          );
+      // Both flags take the same comma shape --files takes: split, trim,
+      // drop empties, validate each symbol (PLAN-comma-x).
+      const syms = v
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (syms.length === 0) {
+        throw new SeedError(`review-seed: ${a} needs a symbol\n${USAGE}`);
+      }
+      for (const s of syms) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(s)) {
+          throw new SeedError(`review-seed: invalid symbol: ${s}`);
         }
-        callers = v;
+        if (a === "--body") body.push(s);
+        else callers.push(s);
       }
     }
   }
@@ -176,12 +168,32 @@ function parseScope(args: string[]): Scope {
     }
   }
   if (flags.length === 0) return { kind: "default" };
-  if (flags.length > 1) {
+  // Repeats of the SAME kind: --files occurrences merge into one scope list
+  // (an agent splitting a lookup across two --files tokens is the same shape
+  // as the comma list it already accepts); an identical scalar repeat is
+  // idempotent; a scalar repeated with a DIFFERENT value is ambiguous and
+  // errors — never last-wins (PLAN-comma-x chunk 2). The mixed-scope guard
+  // below counts distinct kinds, not occurrences, so `--files a --files b`
+  // is one scope, not "files, files".
+  const merged = new Map<string, Scope>();
+  for (const f of flags) {
+    const prev = merged.get(f.kind);
+    if (prev === undefined) {
+      merged.set(f.kind, f);
+    } else if (f.kind === "files" && prev.kind === "files") {
+      prev.list = [...new Set([...prev.list, ...f.list])];
+    } else if (JSON.stringify(prev) !== JSON.stringify(f)) {
+      throw new SeedError(
+        `review-seed: --${f.kind} given twice with different values\n${USAGE}`,
+      );
+    }
+  }
+  if (merged.size > 1) {
     throw new SeedError(
-      `review-seed: one scope flag at a time (got ${flags.map((f) => f.kind).join(", ")})\n${USAGE}`,
+      `review-seed: one scope flag at a time (got ${[...merged.keys()].join(", ")})\n${USAGE}`,
     );
   }
-  return flags[0];
+  return [...merged.values()][0];
 }
 
 // --- Scope resolution: one flag = one declared git call ---
@@ -376,6 +388,57 @@ function resolvePlanPath(arg: string, cwd: string, worktree: string): string {
   throw new SeedError(`review-seed: plan file not found: ${arg}`);
 }
 
+// Fallback commit resolution for --plan without files[] frontmatter.
+// Tries two sources in order:
+//   1. `> **Commits:** sha1 sha2 …` line in the plan header
+//   2. `git log --grep <PLAN-filename> --format=%h`
+// Returns the first source that yields commits, with metadata for the label.
+function isCommitObject(sha: string, cwd: string): boolean {
+  return execGit(`git cat-file -e ${sha}^{commit}`, cwd).ok;
+}
+
+function planFallbackCommits(
+  planText: string,
+  planBase: string,
+  cwd: string,
+): { sha: string; short: string; source: "header" | "git log grep" }[] {
+  // Source 1: > **Commits:** line in the plan header (first 2048 bytes)
+  const head = planText.slice(0, 2048);
+  const commitsLine = />\s*\*?\*?Commits:?\*?\*?\s+(.+)/i.exec(head);
+  if (commitsLine) {
+    const shas = commitsLine[1]
+      .match(/\b[0-9a-f]{7,12}\b/g)
+      ?.filter((s) => isCommitObject(s, cwd))
+      .map((s) => ({
+        sha: s,
+        short: s,
+        source: "header" as const,
+      }));
+    if (shas && shas.length > 0) return shas;
+  }
+  // Source 2: git log --grep for the plan name. Chunk commits cite the plan
+  // as "(PLAN-x chunk N)" — never with the .md suffix — so grep the stem:
+  // it still matches messages that do carry the suffix (substring).
+  const stem = planBase.replace(/\.md$/, "");
+  const logResult = execGit(
+    `git log --grep=${stem} --format=%h --max-count=10`,
+    cwd,
+  );
+  if (logResult.ok && logResult.output.trim()) {
+    const shas = logResult.output
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((s) => ({
+        sha: s,
+        short: s,
+        source: "git log grep" as const,
+      }));
+    if (shas.length > 0) return shas;
+  }
+  return [];
+}
+
 function resolveScope(
   scope: Scope,
   cwd: string,
@@ -394,15 +457,33 @@ function resolveScope(
   }
   if (scope.kind === "plan") {
     const planPath = resolvePlanPath(scope.path, cwd, worktree);
-    const planFiles = planFrontFiles(readFileSync(planPath, "utf-8"));
+    const planText = readFileSync(planPath, "utf-8");
+    const planFiles = planFrontFiles(planText);
     if (planFiles === null) {
-      // No files[] to scope from — fall back to the default diff, say so.
+      // No files[] — try fallback commit sources before default diff.
+      const planBase = basename(planPath);
+      const fallbackCommits = planFallbackCommits(planText, planBase, cwd);
+      if (fallbackCommits.length > 0) {
+        // Use the fallback commits as the scope: get the files touched by those commits.
+        const shaList = fallbackCommits.map((c) => c.sha).join(" ");
+        const entries = parseNumstat(
+          execGit(`git diff-tree --no-commit-id --numstat -r ${shaList}`, cwd)
+            .output,
+        );
+        const source = fallbackCommits[0].source;
+        return {
+          label: `--plan ${scope.path} (commits via ${source}: ${fallbackCommits.map((c) => c.short).join(", ")})`,
+          entries,
+        };
+      }
+      // No commits found either — fall back to the default diff, say so.
       const entries = [
         ...parseNumstat(execGit("git diff HEAD --numstat -M", cwd).output),
         ...untrackedFiles(execGit("git status --porcelain -uall", cwd).output),
       ];
       return {
-        label: "--plan (no files: frontmatter) — diff HEAD + untracked",
+        label:
+          "--plan (no files: frontmatter, no commits found) — diff HEAD + untracked",
         entries,
       };
     }
@@ -597,7 +678,7 @@ function renderLookup(
   lines.push(`worktree: ${worktree} (${lookupLabel(flags)})`);
 
   let resolved: ResolvedScope | null = null;
-  if (flags.callers) {
+  if (flags.callers.length > 0) {
     resolved = resolveScope(scope, cwd, worktree);
   }
 
@@ -651,30 +732,34 @@ function renderLookup(
     }
   }
 
-  if (flags.callers) {
+  if (flags.callers.length > 0) {
     const graph = buildGraph(worktree);
     const targets = (resolved?.entries ?? [])
       .map((e) => e.path)
       .filter(hasGraph);
-    const found = findCallers(flags.callers, targets, graph, worktree);
-    if (targets.length === 0) {
-      lines.push(`callers of ${flags.callers}: no source files in scope`);
-    } else if (found.rows.length === 0) {
-      lines.push(
-        `callers of ${flags.callers}: none found in static importers (dynamic or non-importing use is out of reach)`,
-      );
-    } else {
-      lines.push(
-        `callers of ${flags.callers} (textual hits, may be comments/strings):`,
-      );
-      for (const f of found.rows) {
-        const more = f.more > 0 ? ` (+${f.more} more hits)` : "";
-        lines.push(`  ${f.file}:${f.hits.join(",")}${more}`);
-      }
-      if (found.filesCapped) {
+    // One section per symbol — a merged any-of scan would lose which
+    // symbol hit, and a single symbol's output stays byte-identical.
+    for (const sym of flags.callers) {
+      const found = findCallers(sym, targets, graph, worktree);
+      if (targets.length === 0) {
+        lines.push(`callers of ${sym}: no source files in scope`);
+      } else if (found.rows.length === 0) {
         lines.push(
-          `  ⚠ more importer files matched — capped at ${MAX_CALLER_FILES}`,
+          `callers of ${sym}: none found in static importers (dynamic or non-importing use is out of reach)`,
         );
+      } else {
+        lines.push(
+          `callers of ${sym} (textual hits, may be comments/strings):`,
+        );
+        for (const f of found.rows) {
+          const more = f.more > 0 ? ` (+${f.more} more hits)` : "";
+          lines.push(`  ${f.file}:${f.hits.join(",")}${more}`);
+        }
+        if (found.filesCapped) {
+          lines.push(
+            `  ⚠ more importer files matched — capped at ${MAX_CALLER_FILES}`,
+          );
+        }
       }
     }
   }
@@ -686,7 +771,9 @@ function renderLookup(
 function lookupLabel(flags: LookupFlags): string {
   const parts: string[] = [];
   if (flags.body.length > 0) parts.push(`--body ${flags.body.join(",")}`);
-  if (flags.callers) parts.push(`--callers ${flags.callers}`);
+  if (flags.callers.length > 0) {
+    parts.push(`--callers ${flags.callers.join(",")}`);
+  }
   return parts.join(" ");
 }
 
@@ -709,7 +796,7 @@ export function renderSeed(args: string[], cwd: string): string {
   // feeds --callers its targets), but the standard sections are suppressed —
   // the caller asked for one answer, not the review seed around it.
   const lookup = parseLookup(args);
-  if (lookup.body.length > 0 || lookup.callers) {
+  if (lookup.body.length > 0 || lookup.callers.length > 0) {
     return renderLookup(lookup, scope, cwd, worktree);
   }
 

package/src/update.ts

@@ -2,10 +2,12 @@
 // ROOT must be the repo root: import.meta.dir is src/, one level below it.
 // Shows old → new version, recent commits, and warns if uncommitted changes.
 
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
+import { opencodePluginFiles } from "./install/opencode.js";
 import { isAffirmative } from "./util.js";
 
 /** Repo root (parent of src/) — where package.json and bun.lock live.
@@ -27,12 +29,59 @@ function defaultInstall(): void {
   execSync("bun install", { cwd: ROOT, stdio: "pipe", timeout: 300_000 });
 }
 
+/** argv for the spawned plugin refresh — exported so tests can pin the flags:
+ *  a wrong flag fails silently (the child would just do a full install and
+ *  rewrite opencode.json, the exact bug `--plugins-only` exists to prevent). */
+export function refreshArgv(files: string[]): string[] {
+  const argv = [
+    join(ROOT, "fapony.ts"),
+    "install",
+    "--platform",
+    "opencode",
+    // Plugins only: a refresh touches fapony-owned plugin files, never the
+    // user's opencode.json (rule 6c).
+    "--plugins-only",
+  ];
+  // Opt-in plugin: refresh it when the user installed it, never create it.
+  if (files.includes("fapony-git-autonomy.ts")) argv.push("--git-autonomy");
+  return argv;
+}
+
+/**
+ * Refresh OpenCode's generated plugin bodies after the pull.
+ *
+ * OpenCode is the only client whose hooks are baked files — every other client
+ * writes a `fapony hook-*` command resolved at run time, so a pull alone keeps
+ * them current. Spawning a *fresh* process is the whole point: this one already
+ * loaded the pre-pull templates, so calling the installer in-process would
+ * rewrite the old body — the exact bug this exists to fix. `process.execPath`
+ * is the bun running fapony, so no PATH dependency. Runs `--plugins-only`, so
+ * the refresh never reads or writes opencode.json or the skills symlink.
+ * Best-effort: a refresh must never fail an update.
+ */
+function defaultRefreshPlugins(): void {
+  const getHome = (): string => homedir();
+  const files = opencodePluginFiles(getHome);
+  if (files.length === 0) return;
+  console.log("\n  Refreshing OpenCode plugins...");
+  const r = spawnSync(process.execPath, refreshArgv(files), {
+    stdio: "pipe",
+    timeout: 30_000,
+  });
+  if (r.error || r.status !== 0) {
+    console.log(
+      "  ⚠  plugin refresh failed — run manually: fapony install --platform opencode --plugins-only",
+    );
+  }
+}
+
 /** Minimal seam for cmdUpdate — git runner (map args→result, throws on failure),
- *  prompt, exit, and bun-install. Every field is used by both the default
- *  (production) path and the test path. */
+ *  prompt, exit, bun-install, and the post-pull OpenCode plugin refresh. Every
+ *  field is used by both the default (production) path and the test path. */
 export interface UpdateDeps {
   git?: (args: string) => string;
   install?: () => void;
+  refresh?: () => void;
   prompt?: (question: string, defaultVal?: string) => Promise<string>;
   exit?: (code: number) => never;
 }
@@ -88,6 +137,7 @@ function defaultPrompt(question: string, defaultVal?: string): Promise<string> {
 export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
   const git = deps.git ?? defaultGit;
   const installFn = deps.install ?? defaultInstall;
+  const refreshFn = deps.refresh ?? defaultRefreshPlugins;
   const promptFn = deps.prompt ?? defaultPrompt;
   const exitFn = deps.exit ?? ((code: number): never => process.exit(code));
   const gitQuiet = (args: string): string | null => {
@@ -173,6 +223,10 @@ export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
   // --- show what changed ---
   if (isUpToDate(oldSha, newSha)) {
     console.log(`\n  ✓  Already up to date (${oldVersion} @ ${oldSha}).`);
+    // The repo being current says nothing about the generated plugin bodies —
+    // a user who pulled by hand, or installed before the template changed, is
+    // exactly who needs this. Refresh is a no-op when nothing is stale.
+    refreshFn();
     return;
   }
 
@@ -201,6 +255,9 @@ export async function cmdUpdate(deps: UpdateDeps = {}): Promise<void> {
     }
   }
 
+  // --- refresh generated plugin bodies (after deps — the fresh process needs them) ---
+  refreshFn();
+
   console.log(`
   ┌──────────────────────────────────────────┐
   │  Update complete!                        │