opencode-self-improvement 0.8.2 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "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/index.ts

@@ -602,10 +602,13 @@ const impl = {
 
     // Per-session frozen injection epochs: the relevance block plus the store
     // fingerprint it was computed against. Recomputed ONLY on the first prompt
-    // of a session, when the store changes, or after a compaction (see the
-    // prompt/compaction hooks) — so the system prefix, and with it the
-    // provider prompt cache, survives ordinary turns.
+    // of a session, when injectable rows change, or after a compaction (see the
+    // prompt/context/compaction hooks) — so the system prefix, and with it the
+    // provider prompt cache, survives ordinary requests.
     const epoch = new Map<string, { version: string; block: string; at: string; reason: "first" | "store_changed" }>();
+    // Latest user prompt per session. A changed store is re-scored against it
+    // even when the change happened during a tool loop with no new prompt.
+    const latestPrompt = new Map<string, string>();
     // Recomputes since server start: every one invalidated a prompt cache, so
     // it is the honest cost number the surfaces show (status files / tools).
     let epochRecomputes = 0;
@@ -654,6 +657,47 @@ const impl = {
     const flushStatus = (sid: string): Promise<void> =>
       buildPayload(sid).then((p) => (p ? writeStatus(p) : undefined));
 
+    // Called when a prompt arrives (to keep status surfaces current) and again
+    // at the injection decision on every model request. The latter keeps
+    // removals fail-closed: an out-of-band redaction or a block during a tool
+    // loop cannot ride one more request waiting for another user prompt.
+    const injectableRows = async (): Promise<Memory[]> =>
+      (await loadAll()).filter((m) => isActive(m) && isVisibleHere(m));
+    const refreshEpoch = async (sid: string, rows?: Memory[]): Promise<void> => {
+      if (!latestPrompt.has(sid)) return;
+      const mems = rows ?? await injectableRows();
+      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 at = new Date().toISOString();
+      const reason: "first" | "store_changed" = cached ? "store_changed" : "first";
+      epoch.set(sid, { version, block, at, reason });
+      await record(
+        "epoch_recompute",
+        {
+          session: sid,
+          reason,
+          chars: block.length,
+        },
+        false,
+      );
+      epochRecomputes++;
+      // Ledger: a store_changed recompute of a live epoch is an
+      // invalidation (the first epoch of a session busts nothing). The
+      // epoch request count restarts with the new block.
+      const st = statsFor(sid);
+      st.epochRequests = 0;
+      if (reason === "store_changed") {
+        st.invalidations++;
+        st.lastInvalidation = { at, reason };
+      }
+      // Status hand-off for the terminal panel (src/tui.tsx) and any
+      // out-of-process surface. Best-effort; never breaks injection.
+      await flushStatus(sid);
+    };
+
     // ---- hooks (all fail-closed) -------------------------------------------
     // Bookkeeping: track the active session/tool/call before a tool runs.
     await ctx.tool?.hook("execute.before", (event: any) =>
@@ -691,12 +735,14 @@ const impl = {
       guarded("session.context (systemDigest)", async () => {
         // Route store reads in this hook through the right session's scope.
         setCurrent({ sessionID: event?.sessionID });
+        const sid = event?.sessionID;
+        const mems = await injectableRows();
+        if (typeof sid === "string") await refreshEpoch(sid, mems);
         const parts: string[] = [];
-        await systemDigest({ sessionID: event?.sessionID }, { system: parts });
+        await systemDigest({ sessionID: event?.sessionID }, { system: parts }, mems);
         for (const text of parts) event?.system?.push?.({ type: "text", text });
         // Deliver this epoch's relevance-ranked memory via the system channel.
         // The UI never renders system parts, unlike appended prompt text.
-        const sid = event?.sessionID;
         const knowledge = typeof sid === "string" ? epoch.get(sid)?.block : undefined;
         if (knowledge) event?.system?.push?.({ type: "text", text: knowledge });
         // Count AT THE INJECTION DECISION so badge/panel numbers match exactly
@@ -712,10 +758,11 @@ const impl = {
       }),
     );
 
-    // Memory-first injection, frozen per epoch (cache-safe). The block is
-    // relevance-scored against the prompt that STARTED the epoch — accepted
-    // staleness, traded for a stable system prefix across ordinary turns. An
-    // epoch is invalidated only on first prompt, store change, or compaction.
+    // Memory-first injection, frozen per epoch (cache-safe). Remember the
+    // latest user prompt here; the request-time context hook builds or
+    // invalidates the epoch immediately before delivery. Relevance staleness
+    // is accepted while the injectable rows stay unchanged, preserving a
+    // stable system prefix across ordinary turns.
     // Never mutate event.prompt.text — it is stored verbatim and rendered in
     // the UI.
     await ctx.session?.hook("prompt", (event: any) =>
@@ -726,38 +773,8 @@ const impl = {
           markTurn(sid);
           await checkNewSession(sid);
           await bindSessionFromMessages(sid);
-          const version = await storeVersion();
-          const cached = epoch.get(sid);
-          if (!cached || cached.version !== version) {
-            const text = event?.prompt?.text ?? "";
-            const raw = await relevantKnowledge(text, 5); // widen candidate pool
-            const block = raw ? capToBudget(raw, budget) : "";
-            const at = new Date().toISOString();
-            const reason: "first" | "store_changed" = cached ? "store_changed" : "first";
-            epoch.set(sid, { version, block, at, reason });
-            await record(
-              "epoch_recompute",
-              {
-                session: sid,
-                reason,
-                chars: block.length,
-              },
-              false,
-            );
-            epochRecomputes++;
-            // Ledger: a store_changed recompute of a live epoch is an
-            // invalidation (the first epoch of a session busts nothing). The
-            // epoch request count restarts with the new block.
-            const st = statsFor(sid);
-            st.epochRequests = 0;
-            if (reason === "store_changed") {
-              st.invalidations++;
-              st.lastInvalidation = { at, reason };
-            }
-            // Status hand-off for the terminal panel (src/tui.tsx) and any
-            // out-of-process surface. Best-effort; never breaks injection.
-            await flushStatus(sid);
-          }
+          latestPrompt.set(sid, event?.prompt?.text ?? "");
+          await refreshEpoch(sid);
         }
       }),
     );
@@ -772,7 +789,10 @@ const impl = {
       guarded("session.compaction (onCompacting)", async () => {
         setCurrent({ sessionID: event?.sessionID });
         await onCompacting({ sessionID: event?.sessionID });
-        if (typeof event?.sessionID === "string") epoch.delete(event.sessionID);
+        if (typeof event?.sessionID === "string") {
+          epoch.delete(event.sessionID);
+          latestPrompt.delete(event.sessionID);
+        }
         const anchor = await compactionAnchor();
         if (anchor) event?.system?.push?.({ type: "text", text: anchor });
       }),

package/src/inject.ts

@@ -5,6 +5,7 @@
 // results. Evidence is never injected. Open threads (status=
 // "open") get a single capped frontier block in the digest so planning sessions
 // start at the previous session's frontier instead of re-deriving it.
+import { createHash } from "node:crypto";
 import { isActive, loadAll, visibleHere, type Memory } from "./memory.ts";
 import { record } from "./evidence.ts";
 import { dateStr } from "./config.ts";
@@ -141,9 +142,10 @@ const frontierInjectedSessions = new Set<string>();
 export async function systemDigest(
   _input: unknown,
   output: TransformOutput,
+  rows?: Memory[],
 ): Promise<void> {
   // Repo-scoped: model-facing reads see this repo + global rows.
-  const mems = visibleHere((await loadAll()).filter(isActive));
+  const mems = rows ?? visibleHere((await loadAll()).filter(isActive));
   if (!mems.length) return;
   const latest = flattenMemoryText(mems.map((m) => m.ts).sort().pop() ?? "?");
   output.system.push(
@@ -190,26 +192,33 @@ export async function systemDigest(
   );
 }
 
-export async function relevantKnowledge(message: string, limit = 3): Promise<string> {
+export async function relevantKnowledge(message: string, limit = 3, rows?: Memory[]): Promise<string> {
   const text = message.trim();
   if (!text) return "";
   // Repo-scoped: model-facing reads see this repo + global rows.
-  const mems = visibleHere((await loadAll()).filter(isActive));
+  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")}`;
 }
 
-// Deterministic fingerprint of the active store: `${activeCount}:${maxActiveTs}`.
-// Cheap change detector for the per-session epoch cache in index.ts: the frozen
-// injection block is recomputed only when this string changes (or after a
-// compaction). Evidence and superseded rows never affect it (I3, memory.ts).
-export async function storeVersion(): Promise<string> {
+// Deterministic fingerprint of the rows that can affect injection. Hash the
+// exact rendered row plus its full id, in load order: content edits, blocklist
+// changes and supersession all invalidate an epoch, while evidence, hidden
+// rows and non-rendered metadata do not. This is only a linear hash over rows
+// loadAll() already had to read and parse for the request.
+export async function storeVersion(rows?: Memory[]): Promise<string> {
   // Repo-scoped: model-facing reads see this repo + global rows.
-  const mems = visibleHere((await loadAll()).filter(isActive));
+  const mems = rows ?? visibleHere((await loadAll()).filter(isActive));
+  if (!mems.length) return "0:";
   let max = "";
-  for (const m of mems) if (m.ts > max) max = m.ts;
-  return `${mems.length}:${max}`;
+  const hash = createHash("sha256");
+  for (const m of mems) {
+    if (m.ts > max) max = m.ts;
+    hash.update(JSON.stringify([m.ts, formatMemory(m)]));
+    hash.update("\n");
+  }
+  return `${mems.length}:${max}:${hash.digest("hex")}`;
 }
 
 // Trim an injection block to `budget` characters at WHOLE-line boundaries: