opencode-self-improvement 0.1.0 → 0.1.1

package/README.md

@@ -105,6 +105,11 @@ 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_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
+entry of that scope and type. A `query` matching nothing, or matching several rows,
+writes nothing and says so rather than updating the wrong memory.
+
 ## Admin Tool
 
 Editing and deleting memories is easy!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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": {
@@ -41,6 +41,7 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "semantic-release": "^25.0.9",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
@@ -51,4 +52,4 @@
     "typecheck": "bunx tsc --noEmit -p tsconfig.json",
     "memory-view": "bun run src/viewer/server.ts"
   }
-}
+}

package/src/index.ts

@@ -10,7 +10,14 @@
 // logic still lives in the decoupled helper modules.
 import { join } from "node:path";
 import { evidenceDir, memoryRoot, dateStr } from "./config.ts";
-import { loadAll, isActive, markSuperseded, type Memory } from "./memory.ts";
+import {
+  clearSuperseded,
+  isActive,
+  loadAll,
+  markSuperseded,
+  resolveMemoryTarget,
+  type Memory,
+} from "./memory.ts";
 import { runWriteGate, type GateContext, type WriteCandidate } from "./gates.ts";
 import { pruneMemory } from "./prune.ts";
 import { listSnapshots, restoreSnapshot } from "./undo.ts";
@@ -249,24 +256,58 @@ const plugin = {
 
       editor.add({
         name: "memory_update",
-        description: "Update an existing memory (gated like remember; the prior entry is superseded, not erased).",
+        description:
+          "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,
         input: obj(
-          { scope: str(), type: en(TYPES), content: str(), query: str(), status: en(STATUSES) },
+          {
+            scope: str(),
+            type: en(TYPES),
+            content: str(),
+            query: withDesc(
+              str(),
+              "Row selector: id (ts), clock fragment, or unique content substring. Omit to target the newest active row of scope+type.",
+            ),
+            status: en(STATUSES),
+          },
           ["scope", "type", "content"],
         ),
         async execute(args: any): Promise<{ content: string }> {
           const prior = (await loadAll()).filter(
             (m) => m.scope === args.scope && m.type === args.type && isActive(m),
           );
-          const target = prior[prior.length - 1];
+          // Resolve the row BEFORE the gate: an update that cannot identify its
+          // target must write nothing, rather than silently superseding whichever
+          // row happened to be newest in this scope+type.
+          const resolved = resolveMemoryTarget(prior, args.query);
+          if (resolved.status === "not_found") {
+            const where = args.query ? ` matches ${JSON.stringify(args.query)}` : "";
+            return {
+              content: `memory_update blocked: no active ${args.type} row in ${args.scope}${where}. Nothing was written.`,
+            };
+          }
+          if (resolved.status === "ambiguous") {
+            return {
+              content:
+                `memory_update blocked: ${JSON.stringify(args.query)} matches ${resolved.candidates.length} active ` +
+                `${args.type} rows in ${args.scope} (${resolved.candidates.map((m) => m.ts).join(", ")}). ` +
+                "Pass a row id or a unique content substring. Nothing was written.",
+            };
+          }
+          const target = resolved.target;
           const outcome = await runWriteGate(
             { type: args.type, scope: args.scope, content: args.content, status: args.status },
             gateContext(),
           );
           if (outcome.action === "promoted" && outcome.ts && target) {
-            await markSuperseded(target.ts, { superseded_by: outcome.ts, reason: "update" });
-            return { content: `Updated ${args.type} in ${args.scope}` };
+            await markSuperseded(target.ts, {
+              superseded_by: outcome.ts,
+              reason: "update",
+              symbol: target.ts,
+              from: target.ts,
+              to: outcome.ts,
+            });
+            return { content: `Updated ${args.type} in ${args.scope} (superseded ${target.ts})` };
           }
           if (outcome.action === "promoted") return { content: `Remembered: ${args.type} in ${args.scope}` };
           if (outcome.action === "collapsed") return { content: `Duplicate ignored: ${args.type}/${args.scope}` };
@@ -348,7 +389,7 @@ const plugin = {
       editor.add({
         name: "memory_merge_review",
         description:
-          "Resolve an open merge/review gate non-destructively: mark the loser as superseded_by the survivor. Both rows stay active data (the loser is recoverable via memory_undo); nothing is deleted. Fails closed (no partial apply) when the reason or the survivor id is missing, or the loser is a canonical/settled/thin row that must not be superseded.",
+          "Resolve an open merge/review gate non-destructively: mark the loser as superseded_by the survivor, and clear any supersession the survivor itself carries so the canonical row stays recallable. Both rows stay active data (the loser is recoverable via memory_undo); nothing is deleted. Fails closed (no partial apply) when the reason or the survivor id is missing, or the loser is already superseded.",
         options: direct,
         input: obj(
           {
@@ -372,8 +413,15 @@ const plugin = {
           if (!ok) {
             return { content: "merge_review: loser not found or already superseded — nothing to resolve. No evidence written." };
           }
+          // The survivor may itself have been superseded earlier (e.g. by a row
+          // this very call just made the loser). Declaring it canonical has to
+          // make it recallable, so clear its own marker too.
+          const revived = await clearSuperseded(args.survivor);
           return {
-            content: `Resolved merge: ${args.survivor} is canonical; ${args.loser} superseded (recoverable via memory_undo). Evidence recorded for reason='${args.reason}'.`,
+            content:
+              `Resolved merge: ${args.survivor} is canonical; ${args.loser} superseded (recoverable via memory_undo). ` +
+              (revived ? `Survivor's own supersession cleared, it is active again. ` : "") +
+              `Evidence recorded for reason='${args.reason}'.`,
           };
         },
       });

package/src/memory.ts

@@ -140,6 +140,18 @@ export interface SupersedeFields {
   entity?: string;
 }
 
+// Copy `file` into snapshots/ before a mutation. Names follow
+// `<stamp>-<original>` because /undo strips the stamp to find its target, so a
+// same-millisecond collision would clobber an earlier, still-undoable snapshot
+// (supersede + clear in one merge_review can land in the same millisecond).
+async function snapshotBefore(file: string): Promise<void> {
+  await ensureDir(snapshotDir());
+  let stamp = Date.now();
+  let snap = join(snapshotDir(), `${stamp}-${basename(file)}`);
+  while (await Bun.file(snap).exists()) snap = join(snapshotDir(), `${++stamp}-${basename(file)}`);
+  await Bun.write(snap, (await Bun.file(file).text()) || "");
+}
+
 // Mark an existing memory as superseded IN PLACE (entry retained, recoverable).
 // Idempotent: a second call is a no-op, so no double `superseded_by`.
 export async function markSuperseded(ts: string, fields: SupersedeFields): Promise<boolean> {
@@ -161,15 +173,87 @@ export async function markSuperseded(ts: string, fields: SupersedeFields): Promi
       entity: fields.entity,
     });
     lines[idx] = `${lines[idx]} ${extra}`;
-    await ensureDir(snapshotDir());
-    const snap = join(snapshotDir(), `${Date.now()}-${basename(file)}`);
-    await Bun.write(snap, (await Bun.file(file).text()) || "");
+    await snapshotBefore(file);
+    await Bun.write(file, lines.join("\n") + "\n");
+    return true;
+  }
+  return false;
+}
+
+// Drop a row's supersession markers IN PLACE (snapshot-first), making it active
+// again. Used by memory_merge_review: a declared survivor must be recallable
+// even when an earlier row — now the loser — had superseded it first.
+export async function clearSuperseded(ts: string): Promise<boolean> {
+  for (const file of await memoryFiles()) {
+    const lines = await readLines(file);
+    const idx = lines.findIndex((l) => {
+      const f = parseLine(l);
+      return f && f.ts === ts;
+    });
+    if (idx === -1) continue;
+    const parsed = parseLine(lines[idx]);
+    if (!parsed || typeof parsed.superseded_by !== "string") return false;
+    // These five keys are written only by markSuperseded (drift, canonical,
+    // update and merge_review), never by appendMemory, so they are all part of
+    // the marker and go with it. Field order round-trips because parseLine
+    // inserts keys in source order.
+    for (const key of ["superseded_by", "reason", "symbol", "from", "to", "entity"]) {
+      delete parsed[key];
+    }
+    lines[idx] = formatLine(parsed);
+    await snapshotBefore(file);
     await Bun.write(file, lines.join("\n") + "\n");
     return true;
   }
   return false;
 }
 
+export type TargetResolution =
+  | { status: "ok"; target: Memory }
+  | { status: "not_found" }
+  | { status: "ambiguous"; candidates: Memory[] };
+
+// Score one row against a query: exact row id first, then content.
+function targetScore(m: Memory, query: string): number {
+  const ts = m.ts.toLowerCase();
+  if (ts === query) return 100;
+  // A clock fragment ("00:11:25.867") is unique enough to identify a row.
+  if (query.length >= 8 && ts.includes(query)) return 95;
+  const content = m.content.toLowerCase();
+  if (content === query) return 90;
+  if (content.includes(query)) return 80;
+  if (query.includes(content)) return 70;
+  return 0;
+}
+
+// Pick the row an update/merge call means. Without a query the caller keeps the
+// legacy "most recent active row of this scope+type" behaviour; with one, a
+// miss or a tie fails CLOSED rather than silently rewriting a different row.
+export function resolveMemoryTarget(rows: Memory[], query?: string): TargetResolution {
+  if (!query || !query.trim()) {
+    const last = rows[rows.length - 1];
+    return last ? { status: "ok", target: last } : { status: "not_found" };
+  }
+  const q = query.trim().toLowerCase();
+  let best: Memory | undefined;
+  let bestScore = 0;
+  const tied: Memory[] = [];
+  for (const m of rows) {
+    const score = targetScore(m, q);
+    if (score > bestScore) {
+      best = m;
+      bestScore = score;
+      tied.length = 0;
+      tied.push(m);
+    } else if (score === bestScore && score > 0) {
+      tied.push(m);
+    }
+  }
+  if (!best) return { status: "not_found" };
+  if (tied.length > 1) return { status: "ambiguous", candidates: tied };
+  return { status: "ok", target: best };
+}
+
 export interface DeletedMemory {
   memory: Memory;
   reason: string;