opencode-self-improvement 0.8.11 → 0.9.0

package/README.md

@@ -225,6 +225,10 @@ Opencode installs the package (and its dependencies) automatically with Bun at
 startup. Quit and restart opencode; the plugin loads and `/repo-init` installs
 itself. Nothing else to do.
 
+The plugin runs on the Bun embedded in your opencode build; if that Bun is
+older than 1.3.0 (this repo's tested floor) the plugin says so once at startup
+and memory features may misbehave.
+
 An unpinned entry resolves `@latest` exactly once and is never re-resolved
 afterwards, so updates are deliberate: `opencode plugin update
 opencode-self-improvement`. To install a specific release, append

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.11",
+  "version": "0.9.0",
   "description": "Durable memory for opencode: remember facts, decisions, and commands across sessions, plus a one-command per-repo setup (/repo-init).",
   "main": "index.ts",
   "exports": {
@@ -10,6 +10,9 @@
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "author": "Alex Bogartz",
   "repository": {
     "type": "git",

package/src/attribution.ts

@@ -0,0 +1,150 @@
+// Memory attribution: which of this session's answers came from an injected
+// memory instead of re-deriving the fact from the filesystem. Pure and
+// deterministic — no model, no I/O, no ambient clock. The caller (src/index.ts)
+// feeds it the session's tool ledger and the refs cited by the memories that
+// were actually injected this session, and renders the result through the
+// shared status builders (tool + TUI panel stay 1:1).
+//
+// Epistemics (label every number by how it was obtained):
+//   [measured]  an observed fact about tool calls that did or did not happen.
+//   [inferred]  a coverage statement — memory named something the agent did not
+//               re-read — which is consistent with "memory answered it" but does
+//               not prove the model used it. Never presented as a certainty.
+import { extractPathRefs } from "./resolver.ts";
+import type { Memory } from "./memory.ts";
+
+// A tool call as recorded by the ledger (see src/state.ts ToolResult). Only the
+// fields attribution needs; extra fields are ignored.
+export interface CallLike {
+  tool: string;
+  arg?: string;
+  ts: string;
+}
+
+// Facts the injected memories assert, used as the join key against tool calls.
+export interface MemoryRefs {
+  paths: string[]; // repo-relative code paths the memories cite
+  commands: string[]; // shell commands the memories state (backticked)
+}
+
+export interface Attribution {
+  // Tier A — command reuse [measured]: the agent ran a remembered command
+  // without first reading/searching for its terms.
+  commandSaves: number;
+  commandsMatched: number; // remembered commands the agent did run
+  // Tier B — file coverage: memory named a path; did the agent re-open it?
+  pathsCited: number;
+  pathsReRead: number; // [measured] cited path WAS opened again this session
+  pathsSkipped: number; // [inferred] cited path NOT opened this session
+  // Honest denominator for "new work": file lookups memory did not cover.
+  readsTotal: number;
+  readsNotCovered: number; // [measured] reads of paths no memory cited
+}
+
+const READ_TOOLS = new Set(["read", "glob", "grep"]);
+const BASH_TOOLS = new Set(["bash", "shell"]);
+
+// Command-shaped bins. A backticked span only counts as a remembered command
+// if it starts with a known runner/build tool AND has arguments, so prose like
+// `the store` or `src/gates.ts` is never mistaken for a command.
+const BIN_RE =
+  /^(?:bun|bunx|npm|npx|pnpm|yarn|node|make|go|cargo|pytest|tsc|gh|git|docker|python3?|deno|uv|pip3?)(?:\s|$)/;
+
+// Small words that carry no lookup signal; a command "save" is credited only
+// when nothing the agent read earlier mentioned a distinctive term.
+const STOP = new Set(["run", "the", "and", "for", "with", "to", "all", "test", "tests"]);
+
+function norm(s: string | undefined): string {
+  return (s ?? "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+// Backticked shell commands a memory asserts. Conservative on purpose: false
+// positives here would inflate the headline "saves" number, so we require a
+// known bin plus at least one argument.
+export function extractCommandRefs(content: string): string[] {
+  if (content.length > 10_000) return [];
+  const out: string[] = [];
+  for (const m of content.matchAll(/`([^`\n]{2,120})`/g)) {
+    const s = (m[1] ?? "").trim();
+    if (s.includes(" ") && BIN_RE.test(s)) out.push(s);
+  }
+  return [...new Set(out)];
+}
+
+export function deriveMemoryRefs(mems: Memory[]): MemoryRefs {
+  const paths = new Set<string>();
+  const commands = new Set<string>();
+  for (const m of mems) {
+    for (const p of extractPathRefs(m.content)) paths.add(p.replace(/:\d+$/, ""));
+    for (const c of extractCommandRefs(m.content)) commands.add(c);
+  }
+  return { paths: [...paths], commands: [...commands] };
+}
+
+// A read/grep arg "hits" a cited path when they name the same file: exact,
+// suffix, or same basename (memory cites `src/gates.ts`, the agent opened
+// `/abs/src/gates.ts` or `gates.ts`). Deliberately loose — Tier B is coverage,
+// not an exact-path proof.
+function pathHit(arg: string, path: string): boolean {
+  if (!arg || !path) return false;
+  const base = path.split("/").pop() || path;
+  return arg === path || arg.endsWith("/" + base) || path.endsWith("/" + arg) || arg.includes(path);
+}
+
+function distinctiveTokens(command: string): string[] {
+  return command.split(/[^a-z0-9_.-]+/).filter((t) => t.length > 2 && !STOP.has(t) && !BIN_RE.test(t));
+}
+
+export function attributeSession(calls: CallLike[], refs: MemoryRefs): Attribution {
+  const readCalls = calls.filter((c) => READ_TOOLS.has(c.tool));
+  const bashCalls = calls.filter((c) => BASH_TOOLS.has(c.tool));
+
+  // ---- Tier A: remembered command run without a prior lookup of its terms ----
+  let commandSaves = 0;
+  let commandsMatched = 0;
+  const credited = new Set<string>();
+  for (const b of bashCalls) {
+    const arg = norm(b.arg);
+    if (!arg) continue;
+    for (const mem of refs.commands) {
+      const mc = norm(mem);
+      if (mc.length < 3 || credited.has(mc)) continue;
+      if (!(arg.includes(mc) || mc.includes(arg))) continue;
+      commandsMatched++;
+      credited.add(mc);
+      const terms = distinctiveTokens(mc);
+      // "Looked it up" = an earlier file-touching call mentioned any distinctive
+      // term of the command. If none did, the command came from context, not a
+      // fresh search — attributable to memory (which was injected).
+      const lookedUp = readCalls.some((r) => {
+        if (!(r.ts < b.ts)) return false;
+        const ra = norm(r.arg);
+        return !!ra && terms.some((t) => ra.includes(t));
+      });
+      if (!lookedUp) commandSaves++;
+      break;
+    }
+  }
+
+  // ---- Tier B: coverage of the paths the memories named ----
+  const readArgs = readCalls.map((c) => norm(c.arg)).filter(Boolean);
+  let pathsReRead = 0;
+  for (const p of refs.paths) {
+    if (readArgs.some((ra) => pathHit(ra, norm(p)))) pathsReRead++;
+  }
+  const pathsCited = refs.paths.length;
+  const pathsSkipped = pathsCited - pathsReRead;
+
+  // ---- New work: file lookups no memory covered ----
+  const readsNotCovered = readArgs.filter((ra) => !refs.paths.some((p) => pathHit(ra, norm(p)))).length;
+
+  return {
+    commandSaves,
+    commandsMatched,
+    pathsCited,
+    pathsReRead,
+    pathsSkipped,
+    readsTotal: readArgs.length,
+    readsNotCovered,
+  };
+}

package/src/index.ts

@@ -36,10 +36,11 @@ import {
   compactionAnchor,
   contextualPull,
   formatMemory,
-  relevantKnowledge,
+  selectRelevant,
   storeVersion,
   systemDigest,
 } from "./inject.ts";
+import { attributeSession, deriveMemoryRefs, type MemoryRefs } from "./attribution.ts";
 import { formatInit, runInit } from "./init.ts";
 import { ensureInitCommand, ensureMemoryReportCommand } from "./command.ts";
 import {
@@ -53,6 +54,7 @@ import {
 } from "./status.ts";
 import {
   afterTool,
+  callsFor,
   checkNewSession,
   evidenceCalls,
   firstFrontierTap,
@@ -68,6 +70,7 @@ import { readLines } from "./logfmt.ts";
 import { buildCapturePrompt, flattenTranscript, parseCandidates, parseModelRef } from "./capture.ts";
 import { redactSecrets } from "./secrets.ts";
 import { flattenMemoryText } from "./sanitize.ts";
+import { bunFloorWarning } from "./runtime.ts";
 
 // Tool/input boundaries are zod schemas (src/schema.ts): the JSON Schema the
 // host sees is GENERATED from them, and raw args are re-parsed at execution.
@@ -130,6 +133,7 @@ interface PluginCtx {
       delivery?: "steer" | "queue";
     }) => Promise<unknown>;
     context?: (input: { sessionID: string }) => Promise<unknown>;
+    get?: (input: { sessionID: string }) => Promise<unknown>;
   };
   event?: {
     subscribe: (o?: { signal?: AbortSignal }) => AsyncIterable<unknown>;
@@ -167,6 +171,10 @@ function resultMeta(result: unknown): Record<string, unknown> {
 
 const PLUGIN_ID = "opencode-self-improvement";
 
+// The setup-time Bun-floor warning fires once per process (setup can run for
+// more than one location).
+let bunFloorChecked = false;
+
 // The real setup implementation, written against the loose local PluginCtx
 // (the only members of the V2 context this plugin actually touches).
 const impl = {
@@ -186,6 +194,15 @@ const impl = {
     const budget = Number(ctx.options?.injectBudget) || injectBudget();
     const openBudget = Number(ctx.options?.frontierBudget) || frontierBudget(budget);
 
+    // Warn-once Bun floor check (same setup-time warning style as the
+    // captureModel warnings below): opencode embeds Bun, and the store code's
+    // fs failure modes are Bun-version dependent, so flag an old host.
+    if (!bunFloorChecked) {
+      bunFloorChecked = true;
+      const floorWarning = bunFloorWarning(typeof Bun === "undefined" ? undefined : Bun.version);
+      if (floorWarning) console.warn(floorWarning);
+    }
+
     // Mirror the /repo-init slash command into opencode's global commands dir
     // (idempotent, write-if-missing). OpenCode 2.x loads `*.md` from
     // ~/.config/opencode/commands, so this is the canonical V2 install path.
@@ -212,8 +229,10 @@ const impl = {
     // Identity-event race backstop: a resumed session's FIRST turn can write
     // before the subscription has delivered its execution.started, and the
     // module-scope fallback is the last setup instance — possibly another
-    // workspace. The session context API is synchronous and its messages
-    // carry location.directory, so bind once from them for unmapped sids.
+    // workspace. Bind once from the session context API for unmapped sids —
+    // but note host 2.1.4 sends message payloads WITHOUT any location field,
+    // so this path is a legacy-shape best-effort; the session-row fallback
+    // below is what actually resolves serve-host sessions.
     // One-shot: never overwrites an event-bound entry.
     const bindingSids = new Set<string>();
     async function bindSessionFromMessages(sid: string | undefined): Promise<void> {
@@ -239,6 +258,37 @@ const impl = {
       }
     }
 
+    // Serve-host reality (recorded on 2.1.4 `serve --service`): the plugin
+    // instance loads AFTER the session was created, so `session.created` — the
+    // only event carrying a location — is never delivered; `execution.started`
+    // arrives with just {sessionID}. The session ROW is the remaining source
+    // of truth: the host's session get returns `location.directory`. One
+    // lookup per session; a miss is remembered so a host without the API is
+    // not re-asked on every turn (bounded LRU, same cap as the scope cache).
+    const apiBindTried = new Set<string>();
+    const apiBindOrder = new SessionLru(SESSION_CAP, (evicted) => apiBindTried.delete(evicted));
+    async function bindSessionFromApi(sid: string | undefined): Promise<void> {
+      if (!sid || sid === "?" || sessionDir(sid) || apiBindTried.has(sid)) return;
+      apiBindTried.add(sid);
+      apiBindOrder.touch(sid);
+      try {
+        const got = (await ctx.session?.get?.({ sessionID: sid })) as Record<string, any> | undefined;
+        const row = (got?.data ?? got) as Record<string, any> | undefined;
+        const dir = row?.location?.directory ?? row?.directory;
+        if (typeof dir === "string" && dir) rememberSessionDir(sid, dir);
+      } catch {
+        // no session.get on this host (or unknown session): stay unbound
+      }
+    }
+
+    // Identity must resolve BEFORE a row is stamped or a read is partitioned:
+    // try the (legacy) message payloads, then the session row.
+    async function bindSessionIdentity(sid: string | undefined): Promise<void> {
+      if (!sid || sid === "?" || sessionDir(sid)) return;
+      await bindSessionFromMessages(sid);
+      if (!sessionDir(sid)) await bindSessionFromApi(sid);
+    }
+
     // ---- tools --------------------------------------------------------------
     await ctx.tool?.transform((editor) => {
       const direct = { codemode: false } as const;
@@ -258,7 +308,7 @@ const impl = {
             status: args.status,
             repo: args.global ? "global" : undefined,
           };
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const outcome = await runWriteGate(candidate, gateContext());
           if (outcome.action === "promoted") return { content: `Remembered: ${args.type} in ${args.scope}` };
           if (outcome.action === "collapsed") return { content: `Duplicate ignored: ${args.type}/${args.scope}` };
@@ -276,7 +326,7 @@ const impl = {
           "Initialize repository memory and knowledge graph. Ensures the codebase-memory graph for this repo is indexed (one-shot `cli` spawn; no session MCP needed) and re-derives build/lint/test/typecheck command memories through the write gate, then stores an init stamp keyed on git HEAD. Idempotent: a no-op when the stamp matches HEAD, unless force=true (refresh after a refactor).",
         options: direct,
         async execute(args): Promise<{ content: string }> {
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const summary = await runInit({ liveRoot: gateContext().liveRoot, force: args.force, mode: args.mode });
           return { content: formatInit(summary) };
         },
@@ -323,7 +373,7 @@ const impl = {
           "Update an existing memory (gated like remember; the prior entry is superseded, not erased). `query` selects which row to update: its exact id (ts), a clock fragment (e.g. HH:MM:SS.mmm), or a unique substring of its content. Omitting `query` targets the most recent active row of scope+type. An unmatched or ambiguous `query` fails closed and writes nothing.",
         options: direct,
         async execute(args): Promise<{ content: string }> {
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const prior = (await loadAll()).filter(
             (m) => m.scope === args.scope && m.type === args.type && isActive(m) && isVisibleHere(m),
           );
@@ -613,7 +663,10 @@ const impl = {
     // the prompt/context/compaction hooks) — so the system prefix, and with it
     // the provider prompt cache, survives ordinary requests. The shared LRU
     // below may evict the whole session state; a later prompt starts it fresh.
-    const epoch = new Map<string, { version: string; block: string; at: string; reason: "first" | "store_changed" }>();
+    const epoch = new Map<
+      string,
+      { version: string; block: string; at: string; reason: "first" | "store_changed"; refs: MemoryRefs }
+    >();
     // Latest user prompt per tracked session. A changed store is re-scored
     // against it even when the change happened during a tool loop with no new
     // prompt. It is evicted together with the epoch and session ledgers.
@@ -668,6 +721,7 @@ const impl = {
         },
         stats: statsFor(sid),
         measured: measuredTurns.get(sid) ?? null,
+        attribution: attributeSession(callsFor(sid), ep.refs),
       };
     };
     const flushStatus = (sid: string): Promise<void> =>
@@ -685,11 +739,14 @@ const impl = {
       const version = await storeVersion(mems);
       const cached = epoch.get(sid);
       if (cached?.version === version) return;
-      const raw = await relevantKnowledge(latestPrompt.get(sid) ?? "", 5, mems); // widen candidate pool
-      const block = raw ? capToBudget(raw, budget) : "";
+      const sel = await selectRelevant(latestPrompt.get(sid) ?? "", 5, mems); // widen candidate pool
+      const block = sel.block ? capToBudget(sel.block, budget) : "";
+      // Refs the injected rows assert (paths + commands), the join key for
+      // attribution. Derived once per epoch — the block is frozen, so is this.
+      const refs = deriveMemoryRefs(sel.selected);
       const at = new Date().toISOString();
       const reason: "first" | "store_changed" = cached ? "store_changed" : "first";
-      epoch.set(sid, { version, block, at, reason });
+      epoch.set(sid, { version, block, at, reason, refs });
       await record(
         "epoch_recompute",
         {
@@ -794,7 +851,7 @@ const impl = {
           sessions.touch(sid);
           markTurn(sid);
           await checkNewSession(sid);
-          await bindSessionFromMessages(sid);
+          await bindSessionIdentity(sid);
           latestPrompt.set(sid, event?.prompt?.text ?? "");
           await refreshEpoch(sid);
         }
@@ -850,6 +907,9 @@ const impl = {
               const dir =
                 info.location?.directory ?? d.location?.directory ?? ev.location?.directory ?? info.directory;
               if (typeof sid === "string" && typeof dir === "string") rememberSessionDir(sid, dir);
+              // 2.1.4 serve sends execution.started with no location at all:
+              // resolve the session row instead of leaving the session unbound.
+              else if (typeof sid === "string") void guarded("session bind (api)", () => bindSessionFromApi(sid));
               continue;
             }
             if (ev?.type !== "message.updated") continue;

package/src/inject.ts

@@ -239,14 +239,29 @@ export async function systemDigest(
   );
 }
 
-export async function relevantKnowledge(message: string, limit = 3, rows?: Memory[]): Promise<string> {
+// Select the rows relevant to a prompt and render the injection block, AND
+// return the rows themselves so attribution (src/attribution.ts) can join the
+// injected facts against the session's later tool calls. `relevantKnowledge`
+// keeps its string contract for every existing caller; this is the richer seam.
+export async function selectRelevant(
+  message: string,
+  limit = 3,
+  rows?: Memory[],
+): Promise<{ block: string; selected: Memory[] }> {
   const text = message.trim();
-  if (!text) return "";
+  if (!text) return { block: "", selected: [] };
   // Repo-scoped: model-facing reads see this repo + global rows.
   const mems = rows ?? visibleHere((await loadAll()).filter(isActive));
   const top = scoreMemories(text, mems, limit);
-  if (!top.length) return "";
-  return `## Relevant durable memory${FRAME}\n${top.map(formatMemory).join("\n")}`;
+  if (!top.length) return { block: "", selected: [] };
+  return {
+    block: `## Relevant durable memory${FRAME}\n${top.map(formatMemory).join("\n")}`,
+    selected: top,
+  };
+}
+
+export async function relevantKnowledge(message: string, limit = 3, rows?: Memory[]): Promise<string> {
+  return (await selectRelevant(message, limit, rows)).block;
 }
 
 // Deterministic fingerprint of the rows that can affect injection. Hash the

package/src/runtime.ts

@@ -0,0 +1,40 @@
+// Bun version floor. The plugin runs inside opencode, whose v2 compiled
+// binaries embed Bun (upstream builds with BUN_COMPILE_RELEASE=bun-v1.4.4;
+// older v2 builds embed older bun). The store code's filesystem calls have
+// version-divergent failure modes — e.g. DirHandle.close() behaves differently
+// on some Bun+Windows combos — so an old host shows up as odd memory errors,
+// not as a clean "unsupported" signal. MIN_BUN is the lower bound of the Bun
+// versions this repo has actually been run against: 1.3.10 and 1.4.4. Pure
+// module: nothing here reads the environment; the caller (src/index.ts)
+// injects the version string, so these helpers are unit-testable anywhere.
+
+export const MIN_BUN: readonly [number, number, number] = [1, 3, 0];
+
+// Pulls the first x.y.z triple out of a version string: "1.4.4",
+// "v1.4.4-canary" and "bun-v1.4.4" all parse; junk or a partial version
+// (no patch component) yields null. Never throws.
+export function parseBunVersion(raw: string): [number, number, number] | null {
+  const m = /v?(\d+)\.(\d+)\.(\d+)/.exec(raw);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+// Numeric (not lexical) triple compare: 1.10.0 > 1.3.0.
+function cmpTriples(a: readonly number[], b: readonly number[]): number {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+
+// One-line startup warning when the host's Bun is below MIN_BUN or its version
+// could not be parsed; null when the version looks fine. Warn-only by design:
+// an old embedded bun should be visible, but must not stop memory from
+// loading. The caller decides how often to emit it (src/index.ts: once).
+export function bunFloorWarning(versionString: string | undefined): string | null {
+  const floor = MIN_BUN.join(".");
+  const seen = typeof versionString === "string" ? parseBunVersion(versionString) : null;
+  if (seen) {
+    if (cmpTriples(seen, MIN_BUN) >= 0) return null;
+    return `[opencode-self-improvement] Bun ${seen.join(".")} is below the supported minimum ${floor}; memory features may misbehave.`;
+  }
+  const shown = versionString === undefined ? "unknown" : JSON.stringify(versionString);
+  return `[opencode-self-improvement] Bun version ${shown} is unrecognized (supported minimum ${floor}); memory features may misbehave.`;
+}

package/src/state.ts

@@ -10,6 +10,11 @@ export interface ToolResult {
   status: "FAIL" | "PASS" | null;
   cmd?: string;
   gateCheck?: boolean;
+  // Input arg that identifies the target (command / pattern / path), kept for
+  // memory attribution (src/attribution.ts): what the call was looking at.
+  arg?: string;
+  // Turn index (from markTurn) at the time of the call, for ordering.
+  turn?: number;
 }
 
 export interface FirstTap {

package/src/status.ts

@@ -16,6 +16,7 @@ import { readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { dateStr, evidenceDir, memoryRoot } from "./config.ts";
 import { parseLine, readLines } from "./logfmt.ts";
+import type { Attribution } from "./attribution.ts";
 
 export interface StoreCounts {
   active: number;
@@ -81,6 +82,8 @@ export interface StatusPayload {
   /** optional for backward-compatible reads of pre-v2 files. */
   stats?: SessionStats;
   measured?: Measured | null;
+  /** memory-vs-files attribution for the session; null/undefined = not computed. */
+  attribution?: Attribution | null;
 }
 
 export interface BlockedRow {
@@ -292,6 +295,59 @@ export function cacheLines(p: StatusPayload): string[] {
   ];
 }
 
+/**
+ * CONTEXT WINDOW — the "is memory bloating my context?" answer, built ONLY from
+ * numbers we trust: the exact injected block (we wrote those bytes), the
+ * provider's own cache receipts, and the memory-caused bust count. No estimated
+ * decomposition of the system prompt or history (we cannot measure those); the
+ * one honest share we can state is memory as a slice of what was actually sent.
+ */
+export function windowLines(p: StatusPayload): string[] {
+  const memTok = estTok(p.blockChars);
+  const pct = p.budget > 0 ? Math.round((p.blockChars / p.budget) * 100) : 0;
+  const out: string[] = [
+    `  memory slice   ${p.blockChars}c ≈ ${memTok} tok · ${pct}% of the ${p.budget}c inject budget (hard-capped by design)`,
+  ];
+  const m = p.measured;
+  const used = m ? (m.input || 0) + (m.read || 0) + (m.write || 0) : 0;
+  if (used > 0) {
+    const share = Math.round((memTok / used) * 1000) / 10;
+    const rate = cacheRate(m);
+    out.push(`  of what you sent  ≈ ${fmtCount(used)} prompt tok · memory is ${share}% of it`);
+    out.push(
+      rate
+        ? `  cache served     ${rate.pct}% of that prompt from cache → memory rides free after turn 1`
+        : "  cache served     provider has not reported a split yet",
+    );
+  } else {
+    out.push("  of what you sent  not measured yet — receipts appear after the first assistant turn");
+  }
+  const busts = p.stats?.invalidations ?? 0;
+  out.push(
+    `  memory busts     ${busts} this session${busts ? "" : " — memory never invalidated your cache prefix"}`,
+  );
+  return out;
+}
+
+/**
+ * MEMORY ATTRIBUTION — which answers came from memory instead of re-reading
+ * files. Every line is labeled [measured] (an observed tool-call fact) or
+ * [inferred] (a coverage statement). Misses are shown alongside saves so the
+ * panel reads as an audit, not marketing.
+ */
+export function attributionLines(p: StatusPayload): string[] {
+  const a = p.attribution;
+  if (!a) return ["  not computed — no memory was injected this session"];
+  if (a.pathsCited === 0 && a.commandsMatched === 0 && a.readsTotal === 0) {
+    return ["  the injected memory cited no file paths or commands yet — nothing to attribute"];
+  }
+  return [
+    `  Tier A · commands   ${a.commandSaves} lookup(s) avoided [measured] · ran a remembered command with no prior file lookup`,
+    `  Tier B · coverage   cited ${a.pathsCited} · re-read ${a.pathsReRead} [measured] · not opened ${a.pathsSkipped} [inferred]`,
+    `  new work            ${a.readsNotCovered}/${a.readsTotal} file lookups had no memory coverage [measured]`,
+  ];
+}
+
 /**
  * Plain-text rendering shared by the memory_status tool (and any other chat
  * client). Sections match the terminal /memory panel one-for-one.
@@ -312,12 +368,14 @@ export function renderMemoryReport(input: {
   } else {
     out.push("CONTEXT", ...contextLines(status));
     out.push("", "CACHE — the receipts on your prompt-cache cost", ...cacheLines(status));
+    out.push("", "CONTEXT WINDOW — is memory bloating your context?", ...windowLines(status));
     out.push("", "INJECTED BLOCK (verbatim)");
     if (status.block) out.push(...status.block.split("\n").map((l) => `  ${l}`));
     else
       out.push(
         "  abstained — your prompt shares no content vocabulary with any memory, so nothing was injected (by design, no noise).",
       );
+    out.push("", "MEMORY ATTRIBUTION — answered from memory vs re-reading files", ...attributionLines(status));
   }
 
   out.push("", "RECENT BLOCKED WRITES");

package/src/triggers.ts

@@ -93,8 +93,16 @@ export async function afterTool(input: AfterInput, out: AfterOutput): Promise<vo
   const status = classify(tool, out);
   const ts = new Date().toISOString();
 
-  const rec: ToolResult = { call, tool, summary: summarize(text), ts, status: null };
   const s = session(sid);
+  const rec: ToolResult = {
+    call,
+    tool,
+    summary: summarize(text),
+    ts,
+    status: null,
+    arg: cmd || undefined,
+    turn: s.turns,
+  };
   const family = tool === "bash" || tool === "shell" ? gateCmd(cmd) : null;
 
   // Generic capture (data, not chat).
@@ -183,6 +191,11 @@ export function evidenceCalls(sid: string): string[] {
   return session(sid).calls.map((c) => c.call);
 }
 
+// The full per-session tool ledger, for memory attribution (src/attribution.ts).
+export function callsFor(sid: string): ToolResult[] {
+  return session(sid).calls;
+}
+
 export function hasGateCheck(sid: string): boolean {
   return session(sid).calls.some((c) => c.gateCheck === true);
 }

package/src/tui.tsx

@@ -14,6 +14,7 @@ import { Plugin, usePlugin } from "@opencode/plugin/tui";
 import type { PanelInput } from "@opencode/plugin/tui/context";
 import { memoryRoot, evidenceDir } from "./config.ts";
 import {
+  attributionLines,
   blockedRecent,
   cacheHealth,
   cacheRate,
@@ -21,6 +22,7 @@ import {
   contextLines,
   readStatus,
   statusDir,
+  windowLines,
   type BlockedRow,
   type CacheHealth,
   type StatusPayload,
@@ -261,6 +263,11 @@ function MemoryPanel(props: {
         <For each={cacheLines(s()!)}>{(line) => <text fg={context.theme.text.base}>{line}</text>}</For>
       </Show>
 
+      <Section t="CONTEXT WINDOW — is memory bloating your context?" />
+      <Show when={s()} fallback={<text fg={context.theme.text.base}>  nothing injected yet</text>}>
+        <For each={windowLines(s()!)}>{(line) => <text fg={context.theme.text.base}>{line}</text>}</For>
+      </Show>
+
       <Section t="INJECTED BLOCK (VERBATIM)" />
       <Show when={s()}>
         <Show
@@ -275,6 +282,11 @@ function MemoryPanel(props: {
         </Show>
       </Show>
 
+      <Section t="MEMORY ATTRIBUTION — answered from memory vs re-reading files" />
+      <Show when={s()} fallback={<text fg={context.theme.text.base}>  nothing injected yet</text>}>
+        <For each={attributionLines(s()!)}>{(line) => <text fg={context.theme.text.base}>{line}</text>}</For>
+      </Show>
+
       <Section t="RECENT BLOCKED WRITES" />
       <Show when={props.blocked.length} fallback={<text fg={context.theme.text.base}>  (none today or yesterday)</text>}>
         <For each={props.blocked}>