opencode-self-improvement 0.8.5 → 0.8.6

package/package.json

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

@@ -29,6 +29,7 @@ import { runWriteGate, type GateContext, type WriteCandidate } from "./gates.ts"
 import { pruneMemory } from "./prune.ts";
 import { exportMemories, findStaleOpen, importMemories } from "./portable.ts";
 import { listSnapshots, restoreSnapshot } from "./undo.ts";
+import { SESSION_CAP, SessionLru } from "./sessions.ts";
 import { record } from "./evidence.ts";
 import {
   capToBudget,
@@ -604,13 +605,15 @@ 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 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.
+    // fingerprint it was computed against. Recomputed on the first prompt of a
+    // tracked 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. 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" }>();
-    // 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.
+    // 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.
     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).
@@ -622,6 +625,13 @@ const impl = {
     // (memory_status, in-process).
     const sessionStats = new Map<string, SessionStats>();
     const measuredTurns = new Map<string, Measured>();
+    // Every map above is keyed by session and dropped together on eviction.
+    const sessions = new SessionLru(SESSION_CAP, (sid) => {
+      epoch.delete(sid);
+      latestPrompt.delete(sid);
+      sessionStats.delete(sid);
+      measuredTurns.delete(sid);
+    });
     const statsFor = (sid: string): SessionStats => {
       let st = sessionStats.get(sid);
       if (!st) {
@@ -739,6 +749,7 @@ const impl = {
         // Route store reads in this hook through the right session's scope.
         setCurrent({ sessionID: event?.sessionID });
         const sid = event?.sessionID;
+        if (typeof sid === "string") sessions.touch(sid);
         const mems = await injectableRows();
         if (typeof sid === "string") await refreshEpoch(sid, mems);
         const parts: string[] = [];
@@ -773,6 +784,7 @@ const impl = {
         setCurrent({ sessionID: event?.sessionID });
         const sid = event?.sessionID;
         if (typeof sid === "string") {
+          sessions.touch(sid);
           markTurn(sid);
           await checkNewSession(sid);
           await bindSessionFromMessages(sid);
@@ -839,6 +851,7 @@ const impl = {
             const sid = info.sessionID;
             const t = info.tokens;
             if (typeof sid !== "string" || !t) continue;
+            sessions.touch(sid);
             measuredTurns.set(sid, {
               at: new Date().toISOString(),
               input: Number(t.input) || 0,

package/src/sessions.ts

@@ -0,0 +1,34 @@
+// Bounded per-session state for a long-lived server. The plugin keeps several
+// session-keyed maps (epoch, latest prompt, stats, measured usage); a resident
+// `opencode serve` would otherwise hold an entry per session it ever saw. One
+// recency list owns eviction so the maps are always dropped together: an
+// evicted session simply starts over (no block until its next prompt, then a
+// "first" epoch), which costs one recompute and never serves stale state.
+// Same cap as repokey.ts's session-scope cache.
+export const SESSION_CAP = 64;
+
+export class SessionLru {
+	private readonly order = new Set<string>();
+	private readonly cap: number;
+	private readonly onEvict: (sid: string) => void;
+
+	constructor(cap: number, onEvict: (sid: string) => void) {
+		this.cap = cap;
+		this.onEvict = onEvict;
+	}
+
+	// Mark a session as just used; evicts the least recently used beyond the cap.
+	touch(sid: string): void {
+		this.order.delete(sid);
+		this.order.add(sid);
+		while (this.order.size > this.cap) {
+			const oldest = this.order.values().next().value as string;
+			this.order.delete(oldest);
+			this.onEvict(oldest);
+		}
+	}
+
+	get size(): number {
+		return this.order.size;
+	}
+}