opencode-mempalace-persistence 2.2.0 → 2.4.0

package/README.md

@@ -179,6 +179,11 @@ The model responds
 
 Session goes idle / process exits
   → Background mine of everything new since last sync
+  → TUI toast confirms what was mined (disable with `"toasts": false`)
+
+Every MemPalace call — plugin searches, model MCP calls (search, diary,
+KG) — also raises a short TUI toast with what was asked and a result
+preview, so background memory activity is always visible.
 
 Compaction starts
   → [MemPalace Pre-Compact Emergency Save]: model files everything first

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: () => Promise<{
+declare const _default: ({ client }: any) => Promise<{
     "chat.message": (input: {
         sessionID: string;
         agent?: string;
@@ -24,6 +24,16 @@ declare const _default: () => Promise<{
         context: string[];
         prompt?: string;
     }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args: any;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }) => Promise<void>;
     event: ({ event }: any) => Promise<void>;
 }>;
 export default _default;

package/dist/index.js

@@ -46,6 +46,29 @@ function errLog(msg) {
     log("ERROR: " + msg);
     hookLog("ERROR: " + msg);
 }
+function toastsEnabled() {
+    try {
+        const raw = readFileSync(PLUGIN_CONFIG, "utf-8");
+        const v = JSON.parse(raw)?.toasts;
+        if (v === false)
+            return false;
+    }
+    catch { }
+    return true;
+}
+// TUI toast client (set by the factory). Fire-and-forget: headless runs
+// (`opencode run`, no TUI attached) must never break on this.
+let tuiClient = null;
+function toast(variant, title, message) {
+    if (!toastsEnabled() || !tuiClient?.tui?.showToast)
+        return;
+    try {
+        const p = tuiClient.tui.showToast({ body: { title, message, variant, duration: 5000 } });
+        if (p && typeof p.catch === "function")
+            p.catch(() => { });
+    }
+    catch { }
+}
 // Probe for a working Python interpreter at startup instead of hardcoding
 // one installer layout (pipx vs uv tool vs system). runPython only needs
 // stdlib (sqlite3/json), so any python3 works. Priority: explicit env
@@ -228,14 +251,36 @@ function mempalaceSearch(query) {
             encoding: "utf-8",
             timeout: 15000,
         }).trim();
-        if (!out || out.includes("No results"))
+        if (!out || out.includes("No results")) {
+            toast("info", "MemPalace", `search "${query.slice(0, 50)}" → no results`);
             return "";
+        }
+        const n = (out.match(/\n\s*\[\d+\]/g) || []).length || 1;
+        toast("info", "MemPalace", `search "${query.slice(0, 50)}" → ${n} result(s)`);
         return out.slice(0, MAX_INJECT_CHARS);
     }
     catch {
         return "";
     }
 }
+// TUI visibility for model-driven MCP calls (skill recall, diary, KG):
+// the plugin can't see inside the agent, but it sees every tool result.
+function isMemPalaceTool(name) {
+    return typeof name === "string" && name.toLowerCase().includes("mempalace");
+}
+function summarizeToolCall(tool, args, out) {
+    const short = tool.replace(/^mcp_+/, "").replace(/^mempalace_mempalace_/, "").replace(/^mempalace_/, "");
+    let asked = "";
+    try {
+        const a = typeof args === "string" ? args : JSON.stringify(args || {});
+        asked = a.replace(/\s+/g, " ").slice(0, 60);
+    }
+    catch {
+        asked = "";
+    }
+    const answered = (out || "").replace(/\s+/g, " ").slice(0, 80) || "(empty)";
+    return `${short} · asked: ${asked} → ${answered}`.slice(0, 220);
+}
 function getLastSync() {
     if (!existsSync(STATE_FILE))
         return 0;
@@ -434,6 +479,8 @@ function doDbSync() {
             markSynced(now);
             cleanupExport(wings);
             log("mine done");
+            const names = [...wings.keys()].join(", ");
+            toast("success", "MemPalace", `mined ${wingCount(wings)} session(s) → ${names}`);
             return;
         }
         const [wing, files] = entries[i];
@@ -453,6 +500,7 @@ function doDbSync() {
             if (err) {
                 miningLock = false;
                 errLog(`mine err (${wing}): ${err.message}`);
+                toast("error", "MemPalace", `mine failed (${wing}): ${err.message.slice(0, 120)}`);
                 return;
             }
             log(`mined wing ${wing} (${files.length} sessions)`);
@@ -501,7 +549,8 @@ function exitSync() {
         errLog("exit save err: " + String(e));
     }
 }
-export default (async () => {
+export default (async ({ client }) => {
+    tuiClient = client || null;
     mkdirSync(OUT_DIR, { recursive: true, mode: 0o700 });
     mkdirSync(HOOK_STATE_DIR, { recursive: true });
     const autoInject = isAutoInjectEnabled();
@@ -547,6 +596,7 @@ export default (async () => {
                 c.lastCheckpoint = boundary;
                 pendingCheckpoint = { sessionID, count: c.humanMsgs };
                 hookLog(`session ${sessionID}: ${c.humanMsgs} human msgs — checkpoint armed`);
+                toast("info", "MemPalace", `checkpoint armed (~${c.humanMsgs} msgs): the model will file memories now`);
             }
             counters[sessionID] = c;
             persistCounters(counters);
@@ -624,6 +674,17 @@ export default (async () => {
                 output.context.push(`[MemPalace Rescue — core memory, must survive compaction]\n${rescue.join("\n\n")}`);
             }
         },
+        "tool.execute.after": async (input, output) => {
+            try {
+                const name = input?.tool || "";
+                if (!isMemPalaceTool(name))
+                    return;
+                const summary = summarizeToolCall(name, input?.args, output?.output || "");
+                log(`tool: ${summary}`);
+                toast("info", "MemPalace", summary);
+            }
+            catch { }
+        },
         event: async ({ event }) => {
             if (event?.type === "session.idle" || event?.type === "session.deleted") {
                 log(`${event.type} - queue sync`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mempalace-persistence",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "OpenCode plugin — auto-sync conversations to MemPalace memory in real-time. No forced wings, KG extraction via MCP tools.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",