@rvboris/opencode-mempalace 0.4.0 → 0.5.0

package/dist/plugin/lib/adapter.js

@@ -1,12 +1,91 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
+import { spawn as nodeSpawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path, { delimiter } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_ADAPTER_TIMEOUT_MS, ENV_KEYS, TOOL_ERROR_MESSAGES } from "./constants";
 const getAdapterPath = () => {
     const here = path.dirname(fileURLToPath(import.meta.url));
     return path.resolve(here, "..", "..", "bridge", "mempalace_adapter.py");
 };
-const getPythonCommand = () => process.env[ENV_KEYS.adapterPython] || "python";
+const PYTHON_BINARIES = process.platform === "win32" ? ["python.exe", "python3.exe", "python"] : ["python3", "python"];
+const MEMPALACE_BINARIES = process.platform === "win32" ? ["mempalace.exe"] : ["mempalace"];
+/** Find an executable by name somewhere on $PATH without spawning a shell. */
+const findOnPath = (name) => {
+    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        try {
+            const candidate = path.join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        catch {
+            // unreadable / permission issues — keep scanning
+        }
+    }
+    return null;
+};
+/** Extract the interpreter path from a script's shebang line, if absolute. */
+const readShebang = (file) => {
+    try {
+        const firstLine = readFileSync(file, { encoding: "utf8", flag: "r" }).split("\n", 1)[0];
+        if (!firstLine.startsWith("#!"))
+            return null;
+        const parts = firstLine.slice(2).trim().split(/\s+/);
+        // Skip `#!/usr/bin/env python` — can't resolve to an absolute path here;
+        // the $PATH fallback below handles it.
+        if (parts[0] === "env" || parts[0].endsWith("/env"))
+            return null;
+        return parts[0] || null;
+    }
+    catch {
+        return null;
+    }
+};
+let resolvedPython;
+/**
+ * Resolve the Python interpreter that owns the `mempalace` package.
+ *
+ * Resolution order:
+ *   1. `MEMPALACE_ADAPTER_PYTHON` env (explicit override).
+ *   2. The shebang of the `mempalace` CLI on $PATH — a console_script always
+ *      points at the interpreter that installed the package (pipx, uv-tool,
+ *      pip --user, or a venv), so this is the most reliable auto-detection.
+ *   3. `python3` then `python` on $PATH (best-effort; may still lack mempalace).
+ *
+ * Returns null if nothing usable was found.
+ */
+export const resolvePython = () => {
+    if (resolvedPython !== undefined)
+        return resolvedPython;
+    const envPy = process.env[ENV_KEYS.adapterPython];
+    if (envPy?.trim()) {
+        resolvedPython = envPy;
+        return envPy;
+    }
+    for (const name of MEMPALACE_BINARIES) {
+        const bin = findOnPath(name);
+        if (!bin)
+            continue;
+        const shebangPy = readShebang(bin);
+        if (shebangPy && existsSync(shebangPy)) {
+            resolvedPython = shebangPy;
+            return shebangPy;
+        }
+    }
+    for (const name of PYTHON_BINARIES) {
+        if (findOnPath(name)) {
+            resolvedPython = name;
+            return name;
+        }
+    }
+    resolvedPython = null;
+    return null;
+};
+/** Test-only: clear the cached interpreter so env/PATH changes are re-read. */
+export const resetPythonResolver = () => {
+    resolvedPython = undefined;
+};
+const getPythonCommand = () => resolvePython() ?? "python";
 const getAdapterTimeoutMs = () => {
     const raw = process.env[ENV_KEYS.adapterTimeoutMs];
     if (!raw)
@@ -23,67 +102,112 @@ const getStderrSnippet = (value) => {
         return "";
     return normalized.length > 240 ? `${normalized.slice(0, 240)}...` : normalized;
 };
-export const executeAdapter = async (_shell, payload, retries = 3) => {
-    let lastError;
+const WRITE_LIKE_MODES = new Set([
+    "save",
+    "mine_messages",
+    "diary_write",
+    "kg_add",
+    "checkpoint",
+    "delete",
+    "delete_by_source",
+]);
+const LOCK_HELD_PATTERN = /(?:palace\s+.*\s+is\s+held\s+by\s+PID|held\s+by\s+PID)/i;
+let writeLikeQueue = Promise.resolve();
+let spawnCommand = nodeSpawn;
+let adapterDelay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const setAdapterDelayForTests = (delay) => {
+    adapterDelay = delay;
+};
+export const setAdapterSpawnForTests = (spawn) => {
+    spawnCommand = spawn;
+};
+export const resetAdapterTestHooks = () => {
+    spawnCommand = nodeSpawn;
+    adapterDelay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    writeLikeQueue = Promise.resolve();
+};
+const isWriteLikeMode = (payload) => WRITE_LIKE_MODES.has(payload.mode);
+const isLockHeldError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return LOCK_HELD_PATTERN.test(message);
+};
+const executeAdapterProcess = async (payload) => {
     const timeoutMs = getAdapterTimeoutMs();
+    const { stderrText, stdoutText } = await new Promise((resolve, reject) => {
+        const child = spawnCommand(getPythonCommand(), [getAdapterPath()], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let settled = false;
+        const stdout = [];
+        const stderr = [];
+        const timeoutId = setTimeout(() => {
+            child.kill();
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`${TOOL_ERROR_MESSAGES.adapterTimedOut} after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const finish = (handler) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            handler();
+        };
+        child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+        child.on("error", (error) => finish(() => reject(error)));
+        child.on("close", (code) => {
+            finish(() => {
+                const stderrText = Buffer.concat(stderr).toString("utf8");
+                const stdoutText = Buffer.concat(stdout).toString("utf8");
+                if (code === 0) {
+                    resolve({ stderrText, stdoutText });
+                    return;
+                }
+                reject(new Error(stderrText || `Adapter exited with code ${code}`));
+            });
+        });
+        child.stdin.write(JSON.stringify(payload), "utf8");
+        child.stdin.end();
+    });
+    if (!stdoutText.trim()) {
+        const stderrSnippet = getStderrSnippet(stderrText);
+        throw new Error(stderrSnippet
+            ? `${TOOL_ERROR_MESSAGES.emptyAdapterStdout}: ${stderrSnippet}`
+            : TOOL_ERROR_MESSAGES.emptyAdapterStdout);
+    }
+    const parsed = JSON.parse(stdoutText);
+    if (!isAdapterResponse(parsed)) {
+        throw new Error(TOOL_ERROR_MESSAGES.invalidAdapterPayload);
+    }
+    return parsed;
+};
+const executeAdapterWithRetry = async (payload, retries) => {
+    let lastError;
     for (let attempt = 0; attempt <= retries; attempt += 1) {
         try {
-            const { stderrText, stdoutText } = await new Promise((resolve, reject) => {
-                const child = spawn(getPythonCommand(), [getAdapterPath()], {
-                    stdio: ["pipe", "pipe", "pipe"],
-                });
-                let settled = false;
-                const stdout = [];
-                const stderr = [];
-                const timeoutId = setTimeout(() => {
-                    child.kill();
-                    if (settled)
-                        return;
-                    settled = true;
-                    reject(new Error(`${TOOL_ERROR_MESSAGES.adapterTimedOut} after ${timeoutMs}ms`));
-                }, timeoutMs);
-                const finish = (handler) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    clearTimeout(timeoutId);
-                    handler();
-                };
-                child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
-                child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
-                child.on("error", (error) => finish(() => reject(error)));
-                child.on("close", (code) => {
-                    finish(() => {
-                        const stderrText = Buffer.concat(stderr).toString("utf8");
-                        const stdoutText = Buffer.concat(stdout).toString("utf8");
-                        if (code === 0) {
-                            resolve({ stderrText, stdoutText });
-                            return;
-                        }
-                        reject(new Error(stderrText || `Adapter exited with code ${code}`));
-                    });
-                });
-                child.stdin.write(JSON.stringify(payload), "utf8");
-                child.stdin.end();
-            });
-            if (!stdoutText.trim()) {
-                const stderrSnippet = getStderrSnippet(stderrText);
-                throw new Error(stderrSnippet
-                    ? `${TOOL_ERROR_MESSAGES.emptyAdapterStdout}: ${stderrSnippet}`
-                    : TOOL_ERROR_MESSAGES.emptyAdapterStdout);
-            }
-            const parsed = JSON.parse(stdoutText);
-            if (!isAdapterResponse(parsed)) {
-                throw new Error(TOOL_ERROR_MESSAGES.invalidAdapterPayload);
-            }
-            return parsed;
+            return await executeAdapterProcess(payload);
         }
         catch (error) {
             lastError = error;
-            if (attempt === retries)
+            if (attempt === retries || !isLockHeldError(error))
                 throw error;
-            await new Promise((resolve) => setTimeout(resolve, 150 * (attempt + 1)));
+            await adapterDelay(50 * (attempt + 1));
         }
     }
     throw lastError;
 };
+const enqueueWriteLike = (operation) => {
+    const run = writeLikeQueue.then(operation, operation);
+    writeLikeQueue = run.catch(() => undefined);
+    return run;
+};
+export const executeAdapter = async (_shell, payload, retries = 3) => {
+    // Fail fast with an actionable message if no usable interpreter was found.
+    if (resolvePython() === null) {
+        throw new Error(TOOL_ERROR_MESSAGES.pythonNotFound);
+    }
+    const operation = () => executeAdapterWithRetry(payload, retries);
+    return isWriteLikeMode(payload) ? enqueueWriteLike(operation) : operation();
+};

package/dist/plugin/lib/autosave.d.ts

@@ -44,4 +44,5 @@ export declare const clearKeywordSavePending: (sessionId: string) => void;
 export declare const extractLastUserMessage: (messages: readonly MessageLike[] | null | undefined) => string;
 export declare const markFailed: (sessionId: string) => SessionAutosaveState;
 export declare const shouldScheduleAutosave: (sessionId: string, userDigest: string, transcriptDigest: string) => boolean;
+export declare const buildAutosaveMiningTranscript: (transcript: string) => string;
 export declare const buildTranscriptText: (messages: readonly MessageLike[] | null | undefined) => string;

package/dist/plugin/lib/autosave.js

@@ -175,6 +175,29 @@ export const shouldScheduleAutosave = (sessionId, userDigest, transcriptDigest)
         return false;
     return true;
 };
+const countSignal = (text) => {
+    const tokens = text.match(/[\p{L}\p{N}][\p{L}\p{N}_'-]*/gu) ?? [];
+    const alnum = text.match(/[\p{L}\p{N}]/gu)?.length ?? 0;
+    return { alnum, tokens: tokens.length };
+};
+const stripTranscriptRole = (block) => block.replace(/^[A-Z_]+:\s*/, "");
+const hasLineSignal = (text) => {
+    const signal = countSignal(text);
+    return signal.alnum >= 3;
+};
+const hasCombinedAutosaveSignal = (text) => {
+    const signal = countSignal(text);
+    return signal.alnum >= 5 && signal.tokens >= 2;
+};
+export const buildAutosaveMiningTranscript = (transcript) => {
+    const blocks = transcript
+        .split(/\n{2,}/)
+        .map((block) => block.trim())
+        .filter((block) => block && hasLineSignal(stripTranscriptRole(block)));
+    const filtered = blocks.join("\n\n").trim();
+    const combinedText = blocks.map(stripTranscriptRole).join("\n");
+    return hasCombinedAutosaveSignal(combinedText) ? filtered : "";
+};
 export const buildTranscriptText = (messages) => {
     const lines = [];
     for (const message of messages ?? []) {

package/dist/plugin/lib/constants.d.ts

@@ -9,6 +9,8 @@ export declare const DEFAULT_ADAPTER_TIMEOUT_MS: 15000;
 export declare const DEFAULT_USER_WING_PREFIX: "wing_user";
 export declare const DEFAULT_PROJECT_WING_PREFIX: "wing_project";
 export declare const DEFAULT_KEYWORD_PATTERNS: readonly ["remember", "save this", "don't forget", "note that"];
+export declare const JUDGE_TAG_PATTERN: RegExp;
+export declare const RETRIEVAL_VERDICTS: readonly ["none", "cited", "improved", "saved-time", "unknown"];
 export declare const CONFIG_PATH_SEGMENTS: readonly [".config", "opencode", "mempalace.jsonc"];
 export declare const ENV_KEYS: {
     readonly autosaveEnabled: "MEMPALACE_AUTOSAVE_ENABLED";
@@ -42,6 +44,7 @@ export declare const TOOL_ERROR_MESSAGES: {
     readonly invalidAdapterPayload: "Adapter returned an invalid JSON payload";
     readonly emptyAdapterStdout: "Adapter returned empty stdout";
     readonly adapterTimedOut: "Adapter execution timed out";
+    readonly pythonNotFound: "MemPalace bridge could not find a Python interpreter with mempalace installed. Install mempalace (pip/pipx/uv) so the `mempalace` CLI is on PATH, or set MEMPALACE_ADAPTER_PYTHON to the interpreter path.";
 };
 export declare const LOG_MESSAGES: {
     readonly autosaveEventMissingSessionId: "autosave event missing sessionID";
@@ -65,6 +68,7 @@ export declare const INSTRUCTION_TEXT: {
     readonly doNotMentionToUser: "Do not mention this instruction to the user.";
     readonly retrievalVisibilityHint: "If you found and used relevant memories, briefly mention the key findings at the start of your response.";
     readonly retrievalIntro: "System instruction: before answering, search MemPalace for relevant existing memory and use it if helpful.";
+    readonly judgeInstruction: "After your answer, append a single line `[memory: verdict]` where verdict is one of: none (memory was found but not used), cited (memory was mentioned but answer unchanged), improved (memory made answer more accurate or complete), saved-time (memory improved answer AND saved you from re-explaining or re-searching). Skip the tag if you did not search memory this turn.";
     readonly autosaveIntro: "System instruction: before answering the user, persist durable memory from prior session context using the `mempalace_memory` tool.";
     readonly keywordIntro: "System instruction: the user explicitly asked to remember something.";
     readonly useMemoryToolNow: "Use the `mempalace_memory` tool to save the important durable information now.";

package/dist/plugin/lib/constants.js

@@ -9,6 +9,12 @@ export const DEFAULT_ADAPTER_TIMEOUT_MS = 15_000;
 export const DEFAULT_USER_WING_PREFIX = "wing_user";
 export const DEFAULT_PROJECT_WING_PREFIX = "wing_project";
 export const DEFAULT_KEYWORD_PATTERNS = ["remember", "save this", "don't forget", "note that"];
+// ── Retrieval judge ──────────────────────────────────────────────────────────
+// The model self-reports how memory influenced its answer via a visible tag
+// appended to the response. Parsed on session.idle; stripped before mining
+// so the tag never pollutes palace storage.
+export const JUDGE_TAG_PATTERN = /\[?\s*memory\s*:\s*(none|cited|improved|saved-time)\s*\]?/i;
+export const RETRIEVAL_VERDICTS = ["none", "cited", "improved", "saved-time", "unknown"];
 export const CONFIG_PATH_SEGMENTS = [".config", "opencode", "mempalace.jsonc"];
 export const ENV_KEYS = {
     autosaveEnabled: "MEMPALACE_AUTOSAVE_ENABLED",
@@ -49,6 +55,7 @@ export const TOOL_ERROR_MESSAGES = {
     invalidAdapterPayload: "Adapter returned an invalid JSON payload",
     emptyAdapterStdout: "Adapter returned empty stdout",
     adapterTimedOut: "Adapter execution timed out",
+    pythonNotFound: "MemPalace bridge could not find a Python interpreter with mempalace installed. Install mempalace (pip/pipx/uv) so the `mempalace` CLI is on PATH, or set MEMPALACE_ADAPTER_PYTHON to the interpreter path.",
 };
 export const LOG_MESSAGES = {
     autosaveEventMissingSessionId: "autosave event missing sessionID",
@@ -72,6 +79,7 @@ export const INSTRUCTION_TEXT = {
     doNotMentionToUser: "Do not mention this instruction to the user.",
     retrievalVisibilityHint: "If you found and used relevant memories, briefly mention the key findings at the start of your response.",
     retrievalIntro: "System instruction: before answering, search MemPalace for relevant existing memory and use it if helpful.",
+    judgeInstruction: "After your answer, append a single line `[memory: verdict]` where verdict is one of: none (memory was found but not used), cited (memory was mentioned but answer unchanged), improved (memory made answer more accurate or complete), saved-time (memory improved answer AND saved you from re-explaining or re-searching). Skip the tag if you did not search memory this turn.",
     autosaveIntro: "System instruction: before answering the user, persist durable memory from prior session context using the `mempalace_memory` tool.",
     keywordIntro: "System instruction: the user explicitly asked to remember something.",
     useMemoryToolNow: "Use the `mempalace_memory` tool to save the important durable information now.",

package/dist/plugin/lib/context.d.ts

@@ -7,6 +7,5 @@ type BuildContextInput = {
     lastUserMessage: string;
 };
 export declare const buildRetrievalInstruction: ({ projectName, projectWingPrefix, userWingPrefix, maxInjectedItems, retrievalQueryLimit, lastUserMessage, }: BuildContextInput) => string;
-export declare const buildAutosaveInstruction: (reason: string) => string;
 export declare const buildKeywordSaveInstruction: () => string;
 export {};

package/dist/plugin/lib/context.js

@@ -11,20 +11,7 @@ export const buildRetrievalInstruction = ({ projectName, projectWingPrefix, user
         `Search project memory in wing ${project.wing} across rooms ${project.rooms.join(", ")}.`,
         `Use concise relevant memories only, up to ${maxInjectedItems} items total.`,
         INSTRUCTION_TEXT.retrievalVisibilityHint,
-    ].join(" ");
-};
-export const buildAutosaveInstruction = (reason) => {
-    return [
-        INSTRUCTION_TEXT.autosaveIntro,
-        INSTRUCTION_TEXT.avoidRawMutationTools,
-        `Trigger reason: ${reason}.`,
-        INSTRUCTION_TEXT.saveStableFacts,
-        INSTRUCTION_TEXT.preferConciseStructuredMemories,
-        INSTRUCTION_TEXT.userScopeHint,
-        INSTRUCTION_TEXT.projectScopeHint,
-        INSTRUCTION_TEXT.avoidFullTranscript,
-        INSTRUCTION_TEXT.applyPrivacyRedaction,
-        INSTRUCTION_TEXT.doNotMentionToUser,
+        INSTRUCTION_TEXT.judgeInstruction,
     ].join(" ");
 };
 export const buildKeywordSaveInstruction = () => {

package/dist/plugin/lib/derive.d.ts

@@ -1 +1,3 @@
 export declare const sanitizeText: (text: string) => string;
+export declare const stripJudgeTag: (text: string) => string;
+export declare const parseJudgeTag: (text: string) => string | null;

package/dist/plugin/lib/derive.js

@@ -1,6 +1,8 @@
+import { JUDGE_TAG_PATTERN } from "./constants";
 const ANSI_PATTERN = /\u001B(?:\][^\u0007]*(?:\u0007|\u001B\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
 const ZERO_WIDTH_PATTERN = /[\u200B-\u200D\uFEFF]/g;
 const CONTROL_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
+const JUDGE_TAG_STRIP_PATTERN = /\n*\[?\s*memory\s*:\s*(?:none|cited|improved|saved-time)\s*\]?\s*$/i;
 const stripInvalidSurrogates = (text) => {
     let result = "";
     for (let i = 0; i < text.length; i += 1) {
@@ -34,3 +36,22 @@ export const sanitizeText = (text) => {
         .replace(ZERO_WIDTH_PATTERN, "")
         .replace(CONTROL_PATTERN, "");
 };
+export const stripJudgeTag = (text) => {
+    if (!text)
+        return text;
+    return text.replace(JUDGE_TAG_STRIP_PATTERN, "").trimEnd();
+};
+export const parseJudgeTag = (text) => {
+    if (!text)
+        return null;
+    // Find all matches, return the last verdict (transcript may contain tags from prior turns)
+    const global = new RegExp(JUDGE_TAG_PATTERN.source, "gi");
+    let last = null;
+    for (;;) {
+        const m = global.exec(text);
+        if (m === null)
+            break;
+        last = m[1].toLowerCase();
+    }
+    return last;
+};

package/dist/plugin/lib/status.d.ts

@@ -1,8 +1,15 @@
-import type { AdapterResponse, MemoryScope } from "./types";
+import type { AdapterResponse, MemoryScope, RetrievalVerdict } from "./types";
+declare const DEFAULT_JUDGE_COUNTERS: () => {
+    none: number;
+    cited: number;
+    improved: number;
+    savedTime: number;
+    unknown: number;
+};
 export type StatusCounters = {
     retrievalPrompts: number;
     retrievalSearches: number;
-    retrievalHits: number;
+    retrievalJudge: ReturnType<typeof DEFAULT_JUDGE_COUNTERS>;
     autosavesCompleted: number;
     autosavesSkipped: number;
     autosavesFailed: number;
@@ -10,7 +17,7 @@ export type StatusCounters = {
 };
 export type StatusSessionCounters = {
     retrievalSearches: number;
-    retrievalHits: number;
+    retrievalJudge: ReturnType<typeof DEFAULT_JUDGE_COUNTERS>;
     autosavesCompleted: number;
     autosavesSkipped: number;
     autosavesFailed: number;
@@ -81,6 +88,10 @@ export declare const recordRetrievalSearch: (input: {
     query: string;
     result: AdapterResponse;
 }) => Promise<void>;
+export declare const recordRetrievalJudge: (input: {
+    sessionId?: string;
+    verdict: RetrievalVerdict;
+}) => Promise<void>;
 export declare const recordMemoryWrite: (input: {
     sessionId?: string;
     mode: "save" | "kg_add" | "diary_write";

package/dist/plugin/lib/status.js

@@ -2,12 +2,19 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { ENV_KEYS, STATUS_FILE_NAME } from "./constants";
+const DEFAULT_JUDGE_COUNTERS = () => ({
+    none: 0,
+    cited: 0,
+    improved: 0,
+    savedTime: 0,
+    unknown: 0,
+});
 const MAX_SESSION_IDS = 50;
 const MAX_PREVIEWS = 3;
 const MAX_PREVIEW_LENGTH = 140;
 const DEFAULT_SESSION_COUNTERS = () => ({
     retrievalSearches: 0,
-    retrievalHits: 0,
+    retrievalJudge: DEFAULT_JUDGE_COUNTERS(),
     autosavesCompleted: 0,
     autosavesSkipped: 0,
     autosavesFailed: 0,
@@ -23,7 +30,7 @@ const DEFAULT_STATE = () => ({
     counters: {
         retrievalPrompts: 0,
         retrievalSearches: 0,
-        retrievalHits: 0,
+        retrievalJudge: DEFAULT_JUDGE_COUNTERS(),
         autosavesCompleted: 0,
         autosavesSkipped: 0,
         autosavesFailed: 0,
@@ -58,6 +65,14 @@ const readStringArray = (value) => {
         return [];
     return value.map((item) => normalizeString(item)).filter((item) => Boolean(item));
 };
+const readJudgeCounters = (value) => {
+    const input = isRecord(value) ? value : {};
+    const rc = (key) => {
+        const item = input[key];
+        return typeof item === "number" && Number.isFinite(item) && item >= 0 ? Math.floor(item) : 0;
+    };
+    return { none: rc("none"), cited: rc("cited"), improved: rc("improved"), savedTime: rc("savedTime"), unknown: rc("unknown") };
+};
 const readCounters = (value) => {
     const input = isRecord(value) ? value : {};
     const readCount = (key) => {
@@ -67,7 +82,7 @@ const readCounters = (value) => {
     return {
         retrievalPrompts: readCount("retrievalPrompts"),
         retrievalSearches: readCount("retrievalSearches"),
-        retrievalHits: readCount("retrievalHits"),
+        retrievalJudge: readJudgeCounters(input.retrievalJudge),
         autosavesCompleted: readCount("autosavesCompleted"),
         autosavesSkipped: readCount("autosavesSkipped"),
         autosavesFailed: readCount("autosavesFailed"),
@@ -82,7 +97,7 @@ const readSessionCounters = (value) => {
     };
     return {
         retrievalSearches: readCount("retrievalSearches"),
-        retrievalHits: readCount("retrievalHits"),
+        retrievalJudge: readJudgeCounters(input.retrievalJudge),
         autosavesCompleted: readCount("autosavesCompleted"),
         autosavesSkipped: readCount("autosavesSkipped"),
         autosavesFailed: readCount("autosavesFailed"),
@@ -305,10 +320,6 @@ export const recordRetrievalSearch = async (input) => {
     const summary = summarizeSearchResult(input.result);
     await updateState((state) => {
         state.counters.retrievalSearches += 1;
-        if ((summary.resultCount ?? 0) > 0) {
-            state.counters.retrievalHits += 1;
-            addHelpedSession(state, input.sessionId);
-        }
         state.lastRetrieval = {
             sessionId: input.sessionId,
             timestamp: new Date().toISOString(),
@@ -320,13 +331,22 @@ export const recordRetrievalSearch = async (input) => {
         };
         updateSessionState(state, input.sessionId, (sessionState) => {
             sessionState.counters.retrievalSearches += 1;
-            if ((summary.resultCount ?? 0) > 0) {
-                sessionState.counters.retrievalHits += 1;
-            }
             sessionState.lastRetrieval = state.lastRetrieval;
         });
     });
 };
+export const recordRetrievalJudge = async (input) => {
+    await updateState((state) => {
+        const key = input.verdict === "saved-time" ? "savedTime" : input.verdict;
+        state.counters.retrievalJudge[key] += 1;
+        if (input.verdict === "improved" || input.verdict === "saved-time") {
+            addHelpedSession(state, input.sessionId);
+        }
+        updateSessionState(state, input.sessionId, (sessionState) => {
+            sessionState.counters.retrievalJudge[key] += 1;
+        });
+    });
+};
 export const recordMemoryWrite = async (input) => {
     await updateState((state) => {
         state.counters.manualWrites += 1;
@@ -389,25 +409,49 @@ const isCurrentSession = (expectedSessionId, actualSessionId) => {
 export const formatSessionHud = (state, sessionId) => {
     const sessionState = state.sessions[sessionId];
     if (!sessionState)
-        return "MEM no activity yet";
-    const parts = [
-        `hits ${sessionState.counters.retrievalHits}`,
-        `saved ${sessionState.counters.autosavesCompleted}`,
-        `failed ${sessionState.counters.autosavesFailed}`,
-    ];
-    if (sessionState.counters.autosavesSkipped > 0) {
-        parts.push(`skipped ${sessionState.counters.autosavesSkipped}`);
+        return "MEM quiet";
+    const j = sessionState.counters.retrievalJudge;
+    const helps = j.improved + j.savedTime;
+    const judged = j.none + j.cited + j.improved + j.savedTime;
+    let label;
+    if (helps > 0) {
+        label = `MEM helps ${helps}`;
     }
-    if (sessionState.counters.manualWrites > 0) {
-        parts.push(`writes ${sessionState.counters.manualWrites}`);
+    else if (j.cited > 0) {
+        label = `MEM cited ${j.cited}`;
     }
-    if (sessionState.lastAutosave?.outcome === "failed") {
-        return `MEM FAILED · ${parts.join(" · ")}`;
+    else if (judged > 0) {
+        label = "MEM no help";
     }
-    if (sessionState.lastAutosave?.outcome === "skipped") {
-        return `MEM SKIPPED · ${parts.join(" · ")}`;
+    else if (j.unknown > 0) {
+        label = "MEM unknown";
+    }
+    else if (sessionState.lastRetrieval) {
+        const count = sessionState.lastRetrieval.resultCount;
+        if (count && count > 0) {
+            label = `MEM found ${count}`;
+        }
+        else if (count === 0) {
+            label = "MEM no hits";
+        }
+        else {
+            label = "MEM searched";
+        }
+    }
+    else if (sessionState.counters.retrievalSearches > 0) {
+        label = "MEM searched";
+    }
+    else {
+        label = "MEM quiet";
+    }
+    const flags = [];
+    if (sessionState.counters.autosavesFailed > 0) {
+        flags.push(`fail ${sessionState.counters.autosavesFailed}`);
+    }
+    if (sessionState.counters.autosavesSkipped > 0) {
+        flags.push(`skip ${sessionState.counters.autosavesSkipped}`);
     }
-    return `MEM ${parts.join(" · ")}`;
+    return flags.length ? `${label} · ${flags.join(" · ")}` : label;
 };
 const pushRetrievalLines = (lines, retrieval, verbose) => {
     if ("scope" in retrieval) {
@@ -527,8 +571,9 @@ export const formatStatusSummary = (state, sessionId, options = {}) => {
     }
     lines.push("- Totals:");
     lines.push(`  retrieval prompts: ${state.counters.retrievalPrompts}`);
+    const j = state.counters.retrievalJudge;
     lines.push(`  retrieval searches: ${state.counters.retrievalSearches}`);
-    lines.push(`  retrieval hits: ${state.counters.retrievalHits}`);
+    lines.push(`  retrieval judge: none ${j.none} · cited ${j.cited} · improved ${j.improved} · saved-time ${j.savedTime} · unknown ${j.unknown}`);
     lines.push(`  autosaves completed: ${state.counters.autosavesCompleted}`);
     lines.push(`  autosaves skipped: ${state.counters.autosavesSkipped}`);
     lines.push(`  autosaves failed: ${state.counters.autosavesFailed}`);