opencode-self-improvement 0.8.12 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.12",
+  "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": {

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,
@@ -661,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.
@@ -716,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> =>
@@ -733,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",
         {

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/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}>