dsh-context-memory 0.7.1 → 0.9.0

package/lib/memory.js

@@ -6,56 +6,173 @@
  * what is remembered, and a cache would let one process's view of history outlive the
  * events that contradict it.
  *
+ * There are two logs, one per scope. They are folded together rather than merged on
+ * disk: a project convention and a working preference are different statements kept in
+ * different places for different reasons, and collapsing them would make "this checkout"
+ * and "everywhere" the same claim. Which log an event is appended to follows the
+ * memory's own scope, never the caller's convenience.
+ *
  * @module context-memory/memory
  */
-import { compileGuard, runGuard } from './guard.js';
+import { join } from 'node:path';
+import { CandidateQueue } from './candidates.js';
+import { compileGuard, GUARD_KINDS, runGuard } from './guard.js';
 import { memoryId, normaliseSubject } from './identity.js';
-import { recall as rankRecall } from './recall.js';
+import { recall as rankRecall, inTarget, isContradicted } from './recall.js';
 import { MemoryStore } from './store.js';
+/**
+ * Accept only a guard this version can evaluate.
+ *
+ * Logs written before 0.8.0 recorded guards as `{ command: '<shell string>' }`. Those
+ * are dropped rather than read: the field no longer means what it did, and a memory
+ * evaluated through a stale shape would be answered by whichever predicate branch
+ * happened to match its `undefined` kind. Dropping it makes the memory `uncheckable`,
+ * which is true — this version cannot carry out that check — and leaves the record
+ * intact for a reader that can.
+ */
+function usableGuard(guard) {
+    if (guard === undefined)
+        return undefined;
+    const kind = guard.kind;
+    // A whitelist, not a denylist: a guard written by a newer version must be dropped here
+    // rather than reach `runGuard`, whose branches would answer it with whichever predicate
+    // their fallthrough happens to be. The list lives in `guard.ts`, next to the union it
+    // mirrors, so adding a kind is one edit and forgetting it is a compile error.
+    if (typeof kind === 'string' && GUARD_KINDS.includes(kind))
+        return guard;
+    return undefined;
+}
+/** The identity a memory is addressed by inside this process. */
+function keyOf(scope, id) {
+    return `${scope}\u0000${id}`;
+}
 export class ContextMemory {
     projectDir;
-    store;
-    constructor(projectDir) {
+    projectStore;
+    userStore;
+    queue;
+    /**
+     * The last fold, keyed by the identity of both log files.
+     *
+     * The pre-step asks the same question several times in one pass — who is relevant,
+     * who is contradicted, who disagrees — and each answer used to re-fold both logs. The
+     * fold is still recomputed whenever either file changes, so two processes reading one
+     * log still agree: everything below re-derives from the files, this only avoids
+     * deriving the same state from the same bytes more than once.
+     */
+    folded;
+    constructor(projectDir, options = {}) {
         this.projectDir = projectDir;
-        this.store = new MemoryStore(projectDir);
+        this.projectStore = new MemoryStore(join(projectDir, '.memory'));
+        this.userStore = options.userDir === undefined ? undefined : new MemoryStore(options.userDir);
+        // The queue is per project, beside the project log: a statement noticed while working
+        // in one checkout is a question about that checkout, and offering it in another
+        // project would be offering it out of context.
+        this.queue = new CandidateQueue(join(projectDir, '.memory'));
+    }
+    /** Where each scope is written, for the panel and the CLI. */
+    get locations() {
+        return { project: this.projectStore.path, user: this.userStore?.path };
     }
+    /** The project log's path. Kept for callers that only know about the project scope. */
     get logPath() {
-        return this.store.path;
+        return this.projectStore.path;
+    }
+    storeFor(scope) {
+        if (scope === 'project')
+            return this.projectStore;
+        if (this.userStore === undefined) {
+            throw new Error('this instance has no user-global log; construct it with a userDir');
+        }
+        return this.userStore;
     }
     /**
-     * Fold the log into current state.
+     * Fold the logs into current state.
      *
      * Events are applied in log order and a memory is always addressable by id, so a
      * supersede or verify that names a memory not yet seen is skipped rather than
      * creating a phantom entry — a log that lost its `remember` line must not resurrect
      * the memory from its consequences.
+     *
+     * A memory's scope is part of its identity here: the same sentence can legitimately
+     * exist in both logs, and they are two claims about two different domains, so both
+     * are kept rather than one shadowing the other.
      */
     all() {
+        // Both files' identities, so an append by another process invalidates this exactly
+        // as an append by this one does.
+        const key = this.scopes()
+            .map((scope) => `${scope}=${this.storeFor(scope).signature() ?? '-'}`)
+            .join('|');
+        if (this.folded !== undefined && this.folded.key === key)
+            return this.folded.value;
         const byId = new Map();
-        for (const event of this.store.readAll()) {
-            if (event.type === 'remember') {
-                byId.set(event.memory.id, { ...event.memory, status: 'active' });
-                continue;
-            }
-            const target = byId.get(event.id);
-            if (!target)
-                continue;
-            if (event.type === 'supersede') {
-                target.status = 'superseded';
-                target.supersededReason = event.reason;
-                if (event.replacedBy !== undefined)
-                    target.supersededBy = event.replacedBy;
-                continue;
+        for (const scope of this.scopes()) {
+            const store = this.storeFor(scope);
+            for (const event of store.readAll()) {
+                if (event.type === 'remember') {
+                    const recorded = event.memory;
+                    const guard = usableGuard(recorded.guard);
+                    // Rebuild rather than spread-and-overwrite: with exactOptionalPropertyTypes a
+                    // spread carrying `guard: undefined` is not the same type as omitting it, and
+                    // the log's own field must not survive as an unevaluable shape. The recorded
+                    // `subject` is kept as written rather than re-derived from the text: it may
+                    // have been supplied explicitly, and recomputing it here would quietly discard
+                    // that choice.
+                    const { guard: _dropped, scope: _recordedScope, ...rest } = recorded;
+                    byId.set(keyOf(scope, recorded.id), {
+                        ...rest,
+                        // A log's own scope field cannot override the log's location: events are
+                        // appended to the store that owns them, so the location is authoritative.
+                        scope,
+                        ...(guard ? { guard } : {}),
+                        status: 'active',
+                    });
+                    continue;
+                }
+                const target = byId.get(keyOf(scope, event.id));
+                if (!target)
+                    continue;
+                if (event.type === 'supersede') {
+                    target.status = 'superseded';
+                    target.supersededReason = event.reason;
+                    if (event.replacedBy !== undefined)
+                        target.supersededBy = event.replacedBy;
+                    continue;
+                }
+                target.verification = { at: event.at, outcome: event.outcome, exitCode: event.exitCode, output: event.output };
             }
-            target.verification = { at: event.at, outcome: event.outcome, exitCode: event.exitCode, output: event.output };
         }
-        return [...byId.values()].sort((a, b) => b.createdAt - a.createdAt);
+        const value = [...byId.values()].sort((a, b) => b.createdAt - a.createdAt);
+        this.folded = { key, value };
+        return value;
+    }
+    scopes() {
+        return this.userStore === undefined ? ['project'] : ['project', 'user'];
     }
     active() {
         return this.all().filter((memory) => memory.status === 'active');
     }
-    get(id) {
-        return this.all().find((memory) => memory.id === id);
+    /**
+     * Active memories no check has contradicted — the population recall ranks and the
+     * pre-step may offer the model.
+     */
+    guidance() {
+        return this.active().filter((memory) => !isContradicted(memory));
+    }
+    /** Active memories a check ran against and failed — visible, never offered. */
+    contradicted() {
+        return this.active().filter(isContradicted);
+    }
+    get(id, scope) {
+        const all = this.all();
+        if (scope !== undefined)
+            return all.find((memory) => memory.id === id && memory.scope === scope);
+        return all.find((memory) => memory.id === id);
+    }
+    /** Whether a memory with this id exists in either scope — the candidate queue's dedupe. */
+    has(id) {
+        return this.get(id) !== undefined;
     }
     /**
      * Record a memory.
@@ -71,28 +188,45 @@ export class ContextMemory {
      * command would be an injection path.
      */
     remember(input, now = Date.now()) {
+        return this.record(input, now).memory;
+    }
+    /**
+     * `remember`, plus whether the statement was already on file.
+     *
+     * The distinction exists for the model-facing tool: "recorded" and "already knew that"
+     * are different answers, and a caller reporting the first when the second happened is
+     * claiming work it did not do. It is computed here rather than by the caller because
+     * the id is derived from the subject and text, and a second copy of that derivation
+     * would drift from this one.
+     */
+    record(input, now = Date.now()) {
         const text = input.text.trim();
         if (text.length === 0)
             throw new Error('cannot remember an empty statement');
+        const scope = input.scope ?? 'project';
+        const store = this.storeFor(scope);
         const subject = input.subject !== undefined && input.subject.trim().length > 0
             ? normaliseSubject(input.subject)
             : normaliseSubject(text);
         const id = memoryId(subject, text);
         const guard = compileGuard(text);
-        const memory = { id, subject, text, kind: input.kind ?? 'fact', source: input.source ?? 'user', createdAt: now };
+        // The id deliberately excludes the scope: the same sentence recorded in both logs is
+        // the same sentence, and a panel that showed two unrelated hex strings for it would
+        // hide the fact that one statement was promoted from a project to a preference.
+        const memory = { id, subject, text, kind: input.kind ?? 'fact', source: input.source ?? 'user', scope, createdAt: now };
         if (input.sessionId !== undefined)
             memory.sessionId = input.sessionId;
         if (input.step !== undefined)
             memory.step = input.step;
         if (guard)
             memory.guard = guard;
-        const existing = this.get(id);
+        const existing = this.get(id, scope);
         // Keep the original creation time: re-stating a memory is not the memory being new,
         // and resetting it would let any repeat silently outrank older, better-evidenced ones.
         if (existing)
             memory.createdAt = existing.createdAt;
-        this.store.append({ type: 'remember', at: now, memory });
-        return memory;
+        store.append({ type: 'remember', at: now, memory });
+        return { memory, updated: existing !== undefined };
     }
     /**
      * Retire a memory, with a reason.
@@ -102,15 +236,20 @@ export class ContextMemory {
      * marked superseded and kept, and the reason is required because "why did this stop
      * being true" is the question that will be asked later.
      */
-    forget(id, reason, replacedBy, now = Date.now()) {
-        if (!this.get(id))
+    forget(id, reason, options = {}) {
+        // The id does not carry a scope, so the same sentence held in both logs is two rows
+        // with one id. Without an explicit scope the choice between them would be whichever
+        // the fold happened to list first — a coin flip presented as a decision. Callers that
+        // show both rows (the panel) pass the scope they were looking at.
+        const target = this.get(id, options.scope);
+        if (!target)
             return false;
         if (reason.trim().length === 0)
             throw new Error('a memory can only be superseded with a reason');
-        const event = { type: 'supersede', at: now, id, reason: reason.trim() };
-        if (replacedBy !== undefined)
-            event.replacedBy = replacedBy;
-        this.store.append(event);
+        const event = { type: 'supersede', at: options.now ?? Date.now(), id, reason: reason.trim() };
+        if (options.replacedBy !== undefined)
+            event.replacedBy = options.replacedBy;
+        this.storeFor(target.scope).append(event);
         return true;
     }
     /**
@@ -120,10 +259,13 @@ export class ContextMemory {
      * and different text means one of them is wrong and the log does not say which; a
      * plausible-looking choice would be exactly the unfounded assertion this plugin exists
      * to eliminate.
+     *
+     * A contradicted memory is left out: it is not an open question, the world already
+     * answered it. Keeping it here would present a settled matter as undecided.
      */
     conflicts() {
         const groups = new Map();
-        for (const memory of this.active()) {
+        for (const memory of this.guidance()) {
             const group = groups.get(memory.subject);
             if (group)
                 group.push(memory);
@@ -132,14 +274,89 @@ export class ContextMemory {
         }
         const conflicts = [];
         for (const [subject, memories] of groups) {
-            if (memories.length > 1)
-                conflicts.push({ subject, memories });
+            // Disagreement means a *different claim*, and a claim is identified by its id. The
+            // same sentence can legitimately be recorded in both logs; it then appears twice
+            // with the same id, which is one statement held twice, not a question to answer.
+            // Without this, recording one convention per scope would report a memory as
+            // conflicting with itself and offer "resolve" for a choice that does not exist.
+            const seen = new Set();
+            const distinct = memories.filter((memory) => {
+                if (seen.has(memory.id))
+                    return false;
+                seen.add(memory.id);
+                return true;
+            });
+            if (distinct.length > 1)
+                conflicts.push({ subject, memories: distinct });
         }
         return conflicts.sort((a, b) => b.memories.length - a.memories.length);
     }
-    /** Rank active memories against a query. */
-    recall(query, limit = 5, now = Date.now()) {
-        return rankRecall(this.all(), query, limit, now);
+    /**
+     * Rank memories against a query.
+     *
+     * Defaults to guidance — the population the pre-step may offer. The pull tool widens
+     * the target explicitly when the model asks what is *recorded* rather than what is
+     * *true*, and that difference is carried by the argument instead of by a second
+     * implementation.
+     */
+    recall(query, limit = 5, now = Date.now(), target = 'guidance') {
+        return rankRecall(this.all(), query, limit, now, target);
+    }
+    /**
+     * The newest memories in one population, for a caller that asked without a query.
+     *
+     * "What do you remember" has no lexical content to rank, and answering it with an
+     * empty result would be pedantically correct and useless. Newest-first is the one
+     * ordering that needs no claim about relevance — it is simply the log's own order,
+     * read backwards.
+     */
+    recent(limit = 5, target = 'guidance') {
+        return this.all().filter((memory) => inTarget(memory, target)).slice(0, limit);
+    }
+    // ─── Candidates ─
+    //
+    // A statement the heuristics noticed but the user never asked to keep. It lives in the
+    // queue until a person decides; nothing here reaches recall.
+    /**
+     * Offer a statement.
+     *
+     * Returns undefined when it is already settled — an active memory, an open candidate,
+     * or one already dismissed. That check is against the *log*, not against the message,
+     * so a sentence repeated across a session is asked once rather than on every step.
+     */
+    propose(input) {
+        return this.queue.propose(input, this);
+    }
+    candidates() {
+        return this.queue.pending();
+    }
+    dismiss(id, now = Date.now()) {
+        return this.queue.decide(id, 'dismissed', now);
+    }
+    /**
+     * Turn a candidate into a memory.
+     *
+     * The decision is recorded *before* the memory is written, so a write that throws
+     * leaves a dismissed-looking proposal rather than a candidate that reappears beside a
+     * memory it duplicates. The candidate keeps the kind and provenance it was proposed
+     * with, and the user's acceptance is the reason it exists — which is why the memory is
+     * written with `source: 'user'`: a person said yes to it.
+     */
+    accept(id, overrides = {}, now = Date.now()) {
+        const candidate = this.queue.get(id);
+        if (candidate === undefined || candidate.status !== 'pending')
+            return undefined;
+        const text = overrides.text?.trim() ?? candidate.text;
+        if (text.length === 0)
+            return undefined;
+        this.queue.decide(id, 'accepted', now);
+        return this.remember({
+            text,
+            kind: overrides.kind ?? candidate.kind,
+            scope: overrides.scope ?? 'project',
+            source: 'user',
+            ...(candidate.sessionId === undefined ? {} : { sessionId: candidate.sessionId }),
+        }, now);
     }
     /**
      * Re-run every compiled guard.
@@ -148,8 +365,16 @@ export class ContextMemory {
      * disagreeing with a memory, `broken` is the check itself being unusable, and
      * `uncheckable` is there being no check. Only the first is evidence about the memory,
      * so only the first may influence a caller's exit code.
+     *
+     * @param options.record - when false, results are computed but not appended. The
+     *   pre-step re-checks often; a log entry per check per step would grow the file
+     *   without saying anything new.
+     * @param options.changedOnly - append only when the outcome differs from the last
+     *   recorded one, so a memory that keeps passing does not add a line per run.
      */
-    verify(now = Date.now()) {
+    verify(now = Date.now(), options = {}) {
+        const record = options.record ?? true;
+        const changedOnly = options.changedOnly ?? false;
         const summary = { passed: 0, violated: 0, broken: 0, uncheckable: 0, results: [] };
         for (const memory of this.active()) {
             if (!memory.guard) {
@@ -157,9 +382,27 @@ export class ContextMemory {
                 summary.results.push({ id: memory.id, text: memory.text, outcome: 'uncheckable', exitCode: null, output: '' });
                 continue;
             }
+            // Guards describe files in the project, so they resolve against the project even
+            // when the statement itself is user-global.
             const run = runGuard(memory.id, memory.guard, this.projectDir, new Date(now));
-            this.store.append({ type: 'verify', at: now, id: memory.id, outcome: run.outcome, exitCode: run.exitCode, output: run.output });
-            const result = { id: memory.id, text: memory.text, outcome: run.outcome, exitCode: run.exitCode, output: run.output };
+            if (record && (!changedOnly || memory.verification?.outcome !== run.outcome)) {
+                this.storeFor(memory.scope).append({
+                    type: 'verify',
+                    at: now,
+                    id: memory.id,
+                    outcome: run.outcome,
+                    exitCode: run.exitCode,
+                    output: run.output,
+                });
+            }
+            const result = {
+                id: memory.id,
+                text: memory.text,
+                guard: memory.guard,
+                outcome: run.outcome,
+                exitCode: run.exitCode,
+                output: run.output,
+            };
             summary.results.push(result);
             if (run.outcome === 'passed')
                 summary.passed += 1;
@@ -184,16 +427,23 @@ export class ContextMemory {
         const all = this.all();
         const active = all.filter((memory) => memory.status === 'active');
         const superseded = all.filter((memory) => memory.status === 'superseded');
+        const contradicted = active.filter(isContradicted);
+        const guidance = active.filter((memory) => !isContradicted(memory));
+        const candidates = this.candidates();
         return {
-            active,
+            active: guidance,
             superseded,
+            contradicted,
             conflicts: this.conflicts(),
+            candidates,
             totals: {
-                active: active.length,
+                active: guidance.length,
                 superseded: superseded.length,
+                contradicted: contradicted.length,
                 withGuard: active.filter((memory) => memory.guard).length,
                 verified: active.filter((memory) => memory.verification?.outcome === 'passed').length,
                 unverified: active.filter((memory) => memory.verification?.outcome !== 'passed').length,
+                candidates: candidates.length,
             },
         };
     }

package/lib/memory.web.js

@@ -73,7 +73,13 @@ var zh = {
   "memoryTextPlaceholder": "\u8981\u8BB0\u4F4F\u7684\u5185\u5BB9\uFF0C\u4E00\u53E5\u8BDD\u8BF4\u6E05",
   "subjectPlaceholder": "\u7559\u7A7A\u5219\u81EA\u52A8\u53D6\u4E3B\u8BED",
   "forgotten": "\u5DF2\u9057\u5FD8",
-  "confirmForget": "\u8FD9\u6761\u8BB0\u5FC6\u4F1A\u88AB\u5220\u9664\uFF0C\u4E14\u4E0D\u518D\u53C2\u4E0E\u53EC\u56DE\u3002"
+  "confirmForget": "\u8FD9\u6761\u8BB0\u5FC6\u4F1A\u88AB\u5220\u9664\uFF0C\u4E14\u4E0D\u518D\u53C2\u4E0E\u53EC\u56DE\u3002",
+  "candidates": "\u5F85\u786E\u8BA4",
+  "candidatesHint": "\u8FD9\u4E9B\u662F\u4F60\u8BF4\u8FC7\u3001\u4F46\u6CA1\u8BA9\u6211\u8BB0\u7684\u8BDD\u3002\u786E\u8BA4\u540E\u624D\u4F1A\u8FDB\u53EC\u56DE\uFF0C\u4E0D\u786E\u8BA4\u5C31\u4E00\u76F4\u7559\u5728\u8FD9\u91CC\u3002",
+  "accept": "\u8BB0\u4E0B",
+  "dismiss": "\u4E0D\u7528",
+  "candidateAccepted": "\u5DF2\u8BB0\u4E0B",
+  "candidateDismissed": "\u5DF2\u5FFD\u7565"
 };
 var en = {
   "nav": "Context memory",
@@ -119,7 +125,13 @@ var en = {
   "memoryTextPlaceholder": "What to remember, in one sentence",
   "subjectPlaceholder": "Leave empty to infer the subject",
   "forgotten": "Forgotten",
-  "confirmForget": "This memory is deleted and no longer recalled."
+  "confirmForget": "This memory is deleted and no longer recalled.",
+  "candidates": "Suggested",
+  "candidatesHint": "Things you said that were not asked to be remembered. They only enter recall once you accept them.",
+  "accept": "Remember it",
+  "dismiss": "No thanks",
+  "candidateAccepted": "Remembered",
+  "candidateDismissed": "Dismissed"
 };
 
 // src/client/view.tsx
@@ -661,6 +673,7 @@ var RECALL_PATH = "/api/context-memory.recall";
 var REMEMBER_PATH = "/api/context-memory.remember";
 var FORGET_PATH = "/api/context-memory.forget";
 var PREFS_PATH = "/api/context-memory.prefs";
+var CANDIDATES_PATH = "/api/context-memory.candidates";
 function checkLabel(memory, t) {
   if (!memory.guard) return t("checkNone");
   switch (memory.verification?.outcome) {
@@ -675,7 +688,10 @@ function checkLabel(memory, t) {
   }
 }
 function provenance(memory) {
-  return [memory.source, memory.sessionId !== void 0 ? `session ${memory.sessionId}` : null, memory.step !== void 0 ? `step ${String(memory.step)}` : null].filter((part) => part !== null).join(" \xB7 ");
+  return [memory.scope, memory.source, memory.sessionId !== void 0 ? `session ${memory.sessionId}` : null, memory.step !== void 0 ? `step ${String(memory.step)}` : null].filter((part) => part !== null).join(" \xB7 ");
+}
+function memoryKey(memory) {
+  return `${memory.scope}:${memory.id}`;
 }
 function AddMemoryModal({ t, onClose, onAdded }) {
   const toast = useToast();
@@ -766,6 +782,13 @@ function ContextMemoryPanelInner({ t }) {
       reload();
     }
   }, [forgetTarget, t, toast, reload]);
+  const decideCandidate = (0, import_react2.useCallback)(async (id, action) => {
+    const r = await fetch(CANDIDATES_PATH, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id, action }) });
+    if (r.ok) {
+      toast("success", action === "accept" ? t("candidateAccepted") : t("candidateDismissed"));
+      reload();
+    }
+  }, [t, toast, reload]);
   const header = /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("header", { style: { display: "flex", alignItems: "center", gap: 12, marginBottom: 4 }, children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("strong", { style: { fontSize: 15 }, children: [
       "\u{1F9E0} ",
@@ -796,7 +819,8 @@ function ContextMemoryPanelInner({ t }) {
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.active, label: t("active") }),
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.verified, label: t("checkPassed") }),
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.unverified, label: t("unverified") }),
-      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.superseded, label: t("superseded") })
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.superseded, label: t("superseded") }),
+      payload.totals.candidates > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StatCard, { value: payload.totals.candidates, label: t("candidates") })
     ] }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Card, { title: t("integration"), icon: "\u2699\uFE0F", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [["autoCapture", "autoCaptureLabel"], ["recallInject", "recallInjectLabel"]].map(([key, labelKey]) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("label", { style: { display: "flex", alignItems: "center", gap: 8, fontSize: 13, cursor: "pointer" }, children: [
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("input", { type: "checkbox", checked: prefs?.[key] ?? true, onChange: () => togglePref(key) }),
@@ -838,6 +862,23 @@ function ContextMemoryPanelInner({ t }) {
         /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, reason: `conflict resolved: ${conflict.subject}` }), children: t("resolve") })
       ] }, memory.id)) }, conflict.subject))
     ] }),
+    payload.candidates.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(SectionTitle, { icon: "\u{1F4A1}", children: [
+        t("candidates"),
+        " (",
+        payload.candidates.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Card, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { style: { margin: "0 0 10px", fontSize: 12, opacity: 0.7 }, children: t("candidatesHint") }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: payload.candidates.map((candidate) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Badge, { children: candidate.kind }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: { fontSize: 12, flex: 1 }, children: candidate.text }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { variant: "primary", size: "sm", onClick: () => void decideCandidate(candidate.id, "accept"), children: t("accept") }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { variant: "secondary", size: "sm", onClick: () => void decideCandidate(candidate.id, "dismiss"), children: t("dismiss") })
+        ] }, candidate.id)) })
+      ] })
+    ] }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SectionTitle, { icon: "\u2705", children: t("active") }),
     payload.active.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(EmptyState, { icon: "\u{1F4ED}", message: t("empty") }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Card, { padding: 0, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("table", { style: tableStyles.table, children: [
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("tr", { children: [
@@ -854,8 +895,8 @@ function ContextMemoryPanelInner({ t }) {
         /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Badge, { children: memory.kind }) }),
         /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: checkLabel(memory, t) }),
         /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: { ...tableStyles.td, fontSize: 11, opacity: 0.6 }, children: provenance(memory) }),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, reason: "superseded from panel" }), children: "\u{1F5D1}" }) })
-      ] }, memory.id)) })
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, scope: memory.scope, reason: "superseded from panel" }), children: "\u{1F5D1}" }) })
+      ] }, memoryKey(memory))) })
     ] }) }),
     payload.superseded.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
       /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(SectionTitle, { icon: "\u{1F4E6}", children: [
@@ -876,7 +917,7 @@ function ContextMemoryPanelInner({ t }) {
           /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: memory.text }),
           /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Badge, { children: memory.kind }) }),
           /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { style: tableStyles.td, children: checkLabel(memory, t) })
-        ] }, memory.id)) })
+        ] }, memoryKey(memory))) })
       ] }) })
     ] }),
     addOpen && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AddMemoryModal, { t, onClose: () => setAddOpen(false), onAdded: reload }),