opencode-self-improvement 0.6.2 → 0.6.4

package/package.json

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

@@ -62,7 +62,7 @@ import {
   onCompacting,
 } from "./triggers.ts";
 import { getCurrent, setCurrent } from "./state.ts";
-import { resolveRepo, setRepoScope } from "./repokey.ts";
+import { resolveRepo, setRepoScope, rememberSessionDir, sessionDir } from "./repokey.ts";
 import { readLines } from "./logfmt.ts";
 import { buildCapturePrompt, flattenTranscript, parseCandidates, parseModelRef } from "./capture.ts";
 
@@ -168,12 +168,13 @@ const PLUGIN_ID = "opencode-self-improvement";
 // (the only members of the V2 context this plugin actually touches).
 const impl = {
   async setup(ctx: PluginCtx): Promise<Cleanup | void> {
-    const liveRoot = ctx?.location?.directory ?? process.cwd();
-
-    // Repo scoping: resolve this workspace's identity ONCE. Every
-    // append stamps it; every model-facing read filters by it. Never throws —
-    // a non-git dir simply scopes by path.
-    setRepoScope(resolveRepo(liveRoot));
+    // Identity vs verification tree are separate concerns: the repo STAMP is
+    // resolved per session from the event stream (never from process.cwd(),
+    // which is the server launch dir and poisons rows invisibly); cwd remains
+    // only as the gate's verification tree when no session location is known.
+    const setupRoot = ctx?.location?.directory;
+    const liveRoot = setupRoot ?? process.cwd();
+    setRepoScope(setupRoot ? resolveRepo(setupRoot) : null);
 
     // Character budget for the epoch-frozen injection block: plugin options
     // (object form in opencode.json(c)) win, then OPENCODE_MEMORY_INJECT_BUDGET,
@@ -197,12 +198,42 @@ const impl = {
     }
 
     const gateContext = (): GateContext => ({
-      liveRoot,
+      liveRoot: sessionDir(getCurrent().sid) ?? liveRoot,
       evidenceCalls: evidenceCalls(getCurrent().sid),
       hasGateCheck: hasGateCheck(getCurrent().sid),
       hasEngagement: hasEngagement(getCurrent().sid),
     });
 
+    // 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.
+    // One-shot: never overwrites an event-bound entry.
+    const bindingSids = new Set<string>();
+    async function bindSessionFromMessages(sid: string | undefined): Promise<void> {
+      if (!sid || sid === "?" || sessionDir(sid) || bindingSids.has(sid)) return;
+      bindingSids.add(sid);
+      try {
+        const msgs = await ctx.session?.context?.({ sessionID: sid });
+        if (Array.isArray(msgs)) {
+          for (const m of msgs) {
+            if (!m || typeof m !== "object") continue;
+            const r = m as Record<string, any>;
+            const dir = r.location?.directory ?? r.info?.location?.directory;
+            if (typeof dir === "string" && dir) {
+              rememberSessionDir(sid, dir);
+              break;
+            }
+          }
+        }
+      } catch {
+        // no context access or host error: the event stream still binds later
+      } finally {
+        bindingSids.delete(sid);
+      }
+    }
+
     // ---- tools --------------------------------------------------------------
     await ctx.tool?.transform((editor) => {
       const direct = { codemode: false } as const;
@@ -222,6 +253,7 @@ const impl = {
             status: args.status,
             repo: args.global ? "global" : undefined,
           };
+          await bindSessionFromMessages(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}` };
@@ -239,7 +271,8 @@ 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 }> {
-          const summary = await runInit({ liveRoot, force: args.force, mode: args.mode });
+          await bindSessionFromMessages(getCurrent().sid);
+          const summary = await runInit({ liveRoot: gateContext().liveRoot, force: args.force, mode: args.mode });
           return { content: formatInit(summary) };
         },
       }));
@@ -285,6 +318,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);
           const prior = (await loadAll()).filter(
             (m) => m.scope === args.scope && m.type === args.type && isActive(m) && isVisibleHere(m),
           );
@@ -647,6 +681,8 @@ const impl = {
     // Tiny system digest + open-thread frontier block, injected into the system prompt.
     await ctx.session?.hook("context", (event: any) =>
       guarded("session.context (systemDigest)", async () => {
+        // Route store reads in this hook through the right session's scope.
+        setCurrent({ sessionID: event?.sessionID });
         const parts: string[] = [];
         await systemDigest({ sessionID: event?.sessionID }, { system: parts });
         for (const text of parts) event?.system?.push?.({ type: "text", text });
@@ -676,10 +712,12 @@ const impl = {
     // the UI.
     await ctx.session?.hook("prompt", (event: any) =>
       guarded("session.prompt (inject)", async () => {
+        setCurrent({ sessionID: event?.sessionID });
         const sid = event?.sessionID;
         if (typeof sid === "string") {
           markTurn(sid);
           await checkNewSession(sid);
+          await bindSessionFromMessages(sid);
           const version = await storeVersion();
           const cached = epoch.get(sid);
           if (!cached || cached.version !== version) {
@@ -724,6 +762,7 @@ const impl = {
     // the summarizer call entirely.
     await ctx.session?.hook("compaction", (event: any) =>
       guarded("session.compaction (onCompacting)", async () => {
+        setCurrent({ sessionID: event?.sessionID });
         await onCompacting({ sessionID: event?.sessionID });
         if (typeof event?.sessionID === "string") epoch.delete(event.sessionID);
         const anchor = await compactionAnchor();
@@ -747,6 +786,22 @@ const impl = {
         try {
           for await (const raw of eventApi.subscribe({ signal: measuredController.signal })) {
             const ev = raw as Record<string, any>;
+            // Session identity: created fires for new sessions, execution.started
+            // every turn (covers sessions resumed across a restart), moved on a
+            // workspace change. Stamps and visibility resolve through this.
+            if (
+              ev?.type === "session.created" ||
+              ev?.type === "session.execution.started" ||
+              ev?.type === "session.moved"
+            ) {
+              const d = ev.data ?? ev.properties ?? {};
+              const info = d.info ?? d;
+              const sid = info.sessionID ?? d.sessionID;
+              const dir =
+                info.location?.directory ?? d.location?.directory ?? ev.location?.directory ?? info.directory;
+              if (typeof sid === "string" && typeof dir === "string") rememberSessionDir(sid, dir);
+              continue;
+            }
             if (ev?.type !== "message.updated") continue;
             const info = ev.properties?.info ?? ev.info;
             if (!info || info.role !== "assistant") continue;
@@ -812,6 +867,9 @@ const impl = {
               if (event?.type !== "session.idle") continue;
               const sid = event.sessionID ?? event.properties?.sessionID;
               if (typeof sid !== "string") continue;
+              // Bind the idle session so captures stamp (and gate against)
+              // that session's repo, not whatever tool call ran last.
+              setCurrent({ sessionID: sid });
               const now = Date.now();
               if (now - (lastRun.get(sid) ?? 0) < 5 * 60_000) continue; // 5-min cooldown
               lastRun.set(sid, now);

package/src/memory.ts

@@ -5,7 +5,8 @@
 import { existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { memoryRoot, deletionsFile, snapshotDir } from "./config.ts";
-import { repoScope } from "./repokey.ts";
+import { repoScopeFor } from "./repokey.ts";
+import { getCurrent } from "./state.ts";
 import { appendLog, ensureDir, formatLine, parseLine, readLines } from "./logfmt.ts";
 import { blockedTs } from "./blocklist.ts";
 
@@ -173,11 +174,13 @@ export async function appendMemory(input: AppendMemoryInput): Promise<string> {
   }
   // Repo stamp at the single write choke point: gated writes,
   // viewer restores and edits all pass through here. Explicit "global"
-  // survives; an unscoped process (viewer) stamps nothing = global.
+  // survives; an unscoped process (viewer) stamps nothing = global. Session
+  // identity wins over the module scope so a server hosting several workspaces
+  // stamps the writing session's repo.
   let repo = input.repo;
   let repoPath = input.repoPath;
   if (repo === undefined) {
-    const cur = repoScope();
+    const cur = repoScopeFor(getCurrent().sid);
     if (cur) {
       repo = cur.key;
       repoPath = cur.path;
@@ -416,7 +419,7 @@ export function isActive(m: Memory): boolean {
 // entry points.
 export function isVisibleHere(m: Memory): boolean {
   if (!m.repo || m.repo === "global") return true;
-  const cur = repoScope();
+  const cur = repoScopeFor(getCurrent().sid);
   if (!cur) return true; // unscoped process: no partitioning
   return m.repo === cur.key || (!!m.repoPath && m.repoPath === cur.path);
 }

package/src/repokey.ts

@@ -1,6 +1,8 @@
-// Repo identity for memory scoping. One plugin process serves one
-// workspace, so the scope resolves ONCE at setup; every store write stamps
-// it and every model-facing read filters by it.
+// Repo identity for memory scoping. A server process can host sessions from
+// several workspaces, and setup() can run before the host attaches a session
+// location — so identity is resolved PER SESSION from the event stream and
+// falls back to the module scope (which itself may be null, never a guessed
+// cwd). Every store write stamps it; every model-facing read filters by it.
 //
 // Two keys, both cheap, with opposite failure modes:
 //   key  — sha1 of the normalized origin URL: survives re-clone, moves, and
@@ -64,3 +66,46 @@ export function resolveRepo(startDir: string): RepoScope {
     : path;
   return { key, path };
 }
+
+// --- per-session identity -----------------------------------------------------
+// Learned from session events (created / execution.started / moved). Bounded:
+// a long-lived server must not grow this with every session ever seen.
+const SESSION_CAP = 64;
+const byDir = new Map<string, RepoScope>();
+const bySession = new Map<string, { dir: string; scope: RepoScope }>();
+
+function scopeForDir(dir: string): RepoScope {
+  let s = byDir.get(dir);
+  if (!s) {
+    s = resolveRepo(dir);
+    byDir.set(dir, s);
+  }
+  return s;
+}
+
+export function rememberSessionDir(sid: string, dir: string): void {
+  const prev = bySession.get(sid);
+  if (prev && prev.dir === dir) return;
+  bySession.set(sid, { dir, scope: scopeForDir(dir) });
+  while (bySession.size > SESSION_CAP) bySession.delete(bySession.keys().next().value as string);
+}
+
+export function sessionDir(sid?: string): string | undefined {
+  if (!sid || sid === "?") return undefined;
+  return bySession.get(sid)?.dir;
+}
+
+// The scope a write/read belongs to: the session's when known, else the
+// module scope (null = unscoped process = global rows).
+export function repoScopeFor(sid?: string): RepoScope | null {
+  if (sid && sid !== "?") {
+    const e = bySession.get(sid);
+    if (e) return e.scope;
+  }
+  return current;
+}
+
+export function resetSessionScopes(): void {
+  bySession.clear();
+  byDir.clear();
+}