opencode-self-improvement 0.8.4 → 0.8.6

package/README.md

@@ -302,6 +302,8 @@ Run `/repo-init` once in every repo you work in. It:
 Ongoing use is just the memory tools. Ask the agent to remember something and it
 sticks across sessions; check what's stored with `memory_list`, refine with
 `memory_update`, retract with `memory_forget`, roll back with `memory_undo`.
+`memory_undo` only lists and restores its own `<stamp>-YYYY-MM-DD.logfmt`
+snapshots; any other file in `snapshots/` is ignored.
 
 `memory_update` takes a `query` that picks the row: its id, a clock fragment such
 as `00:11:25.867`, or a unique substring of its text. Omit it to update the newest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.4",
+  "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,
@@ -399,7 +400,7 @@ const impl = {
       editor.add(validated(UndoArgs, {
         name: "memory_undo",
         description:
-          "List memory snapshots, or restore one (rollback). Only snapshots inside this store's snapshots directory are accepted: pass a bare name from the list or its full path. SAFE BY DEFAULT: restore refuses if the current file has rows added or edited since the snapshot, and audited human/tool deletions stay deleted. Re-run with merge=true to restore AND keep divergent rows, or force=true for an explicit exact rollback. Blocklisted rows remain inactive in every mode.",
+          "List memory snapshots, or restore one (rollback). Only snapshots inside this store's snapshots directory are accepted: pass a bare name from the list or its full path. Non-standard files in snapshots/ are not listed or restorable. SAFE BY DEFAULT: restore refuses if the current file has rows added or edited since the snapshot, and audited human/tool deletions stay deleted. Re-run with merge=true to restore AND keep divergent rows, or force=true for an explicit exact rollback. Blocklisted rows remain inactive in every mode.",
         options: direct,
         async execute(args): Promise<{ content: string }> {
           if (args.snapshot) {
@@ -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;
+	}
+}

package/src/undo.ts

@@ -19,6 +19,23 @@ import { snapshotFiles } from "./memory.ts";
 
 const SNAPSHOT_NAME = /^(\d+)-(\d{4}-\d{2}-\d{2}\.logfmt)$/;
 
+function matchSnapshotName(name: string): RegExpExecArray | null {
+  const match = SNAPSHOT_NAME.exec(name);
+  if (!match) return null;
+  const original = match[2];
+  if (!original) return null;
+  const year = Number(original.slice(0, 4));
+  const month = Number(original.slice(5, 7));
+  const day = Number(original.slice(8, 10));
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getUTCFullYear() === year &&
+    date.getUTCMonth() === month - 1 &&
+    date.getUTCDate() === day
+    ? match
+    : null;
+}
+
 export interface SnapshotInfo {
   file: string;
   name: string;
@@ -31,7 +48,7 @@ export async function listSnapshots(): Promise<SnapshotInfo[]> {
   const out: SnapshotInfo[] = [];
   try {
     for await (const f of glob.scan(snapshotDir())) {
-      if (!SNAPSHOT_NAME.test(f)) continue;
+      if (!matchSnapshotName(f)) continue;
       const info = Bun.file(join(snapshotDir(), f));
       out.push({
         file: join(snapshotDir(), f),
@@ -83,7 +100,7 @@ async function resolveSnapshot(
   memoryRootDir: string,
 ): Promise<{ path: string; original: string }> {
   const name = basename(snapshot);
-  const match = SNAPSHOT_NAME.exec(name);
+  const match = matchSnapshotName(name);
   const original = match?.[2];
   const stamp = match ? Number(match[1]) : Number.NaN;
   if (!original || !Number.isSafeInteger(stamp)) {