@rvboris/opencode-mempalace 0.2.1 → 0.4.0

package/dist/plugin/lib/status.js

@@ -0,0 +1,537 @@
+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 MAX_SESSION_IDS = 50;
+const MAX_PREVIEWS = 3;
+const MAX_PREVIEW_LENGTH = 140;
+const DEFAULT_SESSION_COUNTERS = () => ({
+    retrievalSearches: 0,
+    retrievalHits: 0,
+    autosavesCompleted: 0,
+    autosavesSkipped: 0,
+    autosavesFailed: 0,
+    manualWrites: 0,
+});
+const DEFAULT_SESSION_STATE = () => ({
+    updatedAt: new Date(0).toISOString(),
+    counters: DEFAULT_SESSION_COUNTERS(),
+});
+const DEFAULT_STATE = () => ({
+    version: 2,
+    updatedAt: new Date(0).toISOString(),
+    counters: {
+        retrievalPrompts: 0,
+        retrievalSearches: 0,
+        retrievalHits: 0,
+        autosavesCompleted: 0,
+        autosavesSkipped: 0,
+        autosavesFailed: 0,
+        manualWrites: 0,
+    },
+    helpedSessionIds: [],
+    sessions: {},
+});
+let writeQueue = Promise.resolve();
+const getStatusFilePath = () => {
+    return process.env[ENV_KEYS.statusFile] || path.join(os.homedir(), ".mempalace", STATUS_FILE_NAME);
+};
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const normalizeString = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized || undefined;
+};
+const previewText = (value) => {
+    if (!value)
+        return "";
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= MAX_PREVIEW_LENGTH)
+        return normalized;
+    return `${normalized.slice(0, MAX_PREVIEW_LENGTH - 3)}...`;
+};
+const readStringArray = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => normalizeString(item)).filter((item) => Boolean(item));
+};
+const readCounters = (value) => {
+    const input = isRecord(value) ? value : {};
+    const readCount = (key) => {
+        const item = input[key];
+        return typeof item === "number" && Number.isFinite(item) && item >= 0 ? Math.floor(item) : 0;
+    };
+    return {
+        retrievalPrompts: readCount("retrievalPrompts"),
+        retrievalSearches: readCount("retrievalSearches"),
+        retrievalHits: readCount("retrievalHits"),
+        autosavesCompleted: readCount("autosavesCompleted"),
+        autosavesSkipped: readCount("autosavesSkipped"),
+        autosavesFailed: readCount("autosavesFailed"),
+        manualWrites: readCount("manualWrites"),
+    };
+};
+const readSessionCounters = (value) => {
+    const input = isRecord(value) ? value : {};
+    const readCount = (key) => {
+        const item = input[key];
+        return typeof item === "number" && Number.isFinite(item) && item >= 0 ? Math.floor(item) : 0;
+    };
+    return {
+        retrievalSearches: readCount("retrievalSearches"),
+        retrievalHits: readCount("retrievalHits"),
+        autosavesCompleted: readCount("autosavesCompleted"),
+        autosavesSkipped: readCount("autosavesSkipped"),
+        autosavesFailed: readCount("autosavesFailed"),
+        manualWrites: readCount("manualWrites"),
+    };
+};
+const readRetrievalPrompt = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const timestamp = normalizeString(value.timestamp);
+    const queryPreview = normalizeString(value.queryPreview);
+    if (!timestamp || !queryPreview)
+        return undefined;
+    return {
+        sessionId: normalizeString(value.sessionId),
+        timestamp,
+        queryPreview,
+    };
+};
+const readRetrieval = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const timestamp = normalizeString(value.timestamp);
+    const scope = value.scope === "user" || value.scope === "project" ? value.scope : undefined;
+    const queryPreview = normalizeString(value.queryPreview);
+    if (!timestamp || !scope || !queryPreview)
+        return undefined;
+    const count = typeof value.resultCount === "number" && Number.isFinite(value.resultCount) && value.resultCount >= 0
+        ? Math.floor(value.resultCount)
+        : undefined;
+    return {
+        sessionId: normalizeString(value.sessionId),
+        timestamp,
+        scope,
+        room: normalizeString(value.room),
+        queryPreview,
+        resultCount: count,
+        previews: readStringArray(value.previews).slice(0, MAX_PREVIEWS),
+    };
+};
+const readAutosave = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const timestamp = normalizeString(value.timestamp);
+    const sessionId = normalizeString(value.sessionId);
+    const reason = normalizeString(value.reason);
+    const outcome = value.outcome === "saved" || value.outcome === "skipped" || value.outcome === "failed"
+        ? value.outcome
+        : undefined;
+    if (!timestamp || !sessionId || !reason || !outcome)
+        return undefined;
+    return {
+        sessionId,
+        timestamp,
+        outcome,
+        reason,
+        wing: normalizeString(value.wing),
+        sourcePreview: normalizeString(value.sourcePreview),
+    };
+};
+const readWrite = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const timestamp = normalizeString(value.timestamp);
+    const preview = normalizeString(value.preview);
+    const mode = value.mode === "save" || value.mode === "kg_add" || value.mode === "diary_write" ? value.mode : undefined;
+    if (!timestamp || !preview || !mode)
+        return undefined;
+    return {
+        timestamp,
+        mode,
+        scope: value.scope === "user" || value.scope === "project" ? value.scope : undefined,
+        room: normalizeString(value.room),
+        preview,
+    };
+};
+const readSessionState = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        updatedAt: normalizeString(value.updatedAt) || new Date(0).toISOString(),
+        counters: readSessionCounters(value.counters),
+        lastRetrievalPrompt: readRetrievalPrompt(value.lastRetrievalPrompt),
+        lastRetrieval: readRetrieval(value.lastRetrieval),
+        lastAutosave: readAutosave(value.lastAutosave),
+        lastWrite: readWrite(value.lastWrite),
+    };
+};
+const readSessions = (value) => {
+    if (!isRecord(value))
+        return {};
+    const sessions = Object.entries(value)
+        .map(([sessionId, sessionState]) => {
+        const normalizedSessionId = normalizeString(sessionId);
+        const parsed = readSessionState(sessionState);
+        if (!normalizedSessionId || !parsed)
+            return undefined;
+        return [normalizedSessionId, parsed];
+    })
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => a[1].updatedAt.localeCompare(b[1].updatedAt))
+        .slice(-MAX_SESSION_IDS);
+    return Object.fromEntries(sessions);
+};
+const parseState = (value) => {
+    if (!isRecord(value))
+        return DEFAULT_STATE();
+    return {
+        version: 2,
+        updatedAt: normalizeString(value.updatedAt) || new Date(0).toISOString(),
+        counters: readCounters(value.counters),
+        helpedSessionIds: readStringArray(value.helpedSessionIds).slice(-MAX_SESSION_IDS),
+        sessions: readSessions(value.sessions),
+        lastRetrievalPrompt: readRetrievalPrompt(value.lastRetrievalPrompt),
+        lastRetrieval: readRetrieval(value.lastRetrieval),
+        lastAutosave: readAutosave(value.lastAutosave),
+        lastWrite: readWrite(value.lastWrite),
+    };
+};
+const loadState = async () => {
+    try {
+        const raw = await fs.readFile(getStatusFilePath(), "utf8");
+        return parseState(JSON.parse(raw));
+    }
+    catch {
+        return DEFAULT_STATE();
+    }
+};
+const persistState = async (state) => {
+    const filePath = getStatusFilePath();
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+};
+const updateState = async (updater) => {
+    writeQueue = writeQueue.then(async () => {
+        const state = await loadState();
+        updater(state);
+        state.updatedAt = new Date().toISOString();
+        await persistState(state);
+    }).catch(() => { });
+    await writeQueue;
+};
+const addHelpedSession = (state, sessionId) => {
+    if (!sessionId || state.helpedSessionIds.includes(sessionId))
+        return;
+    state.helpedSessionIds.push(sessionId);
+    if (state.helpedSessionIds.length > MAX_SESSION_IDS) {
+        state.helpedSessionIds.splice(0, state.helpedSessionIds.length - MAX_SESSION_IDS);
+    }
+};
+const updateSessionState = (state, sessionId, updater) => {
+    if (!sessionId)
+        return;
+    const sessionState = state.sessions[sessionId] ?? DEFAULT_SESSION_STATE();
+    updater(sessionState);
+    sessionState.updatedAt = new Date().toISOString();
+    state.sessions[sessionId] = sessionState;
+    const entries = Object.entries(state.sessions);
+    if (entries.length <= MAX_SESSION_IDS)
+        return;
+    entries.sort((a, b) => a[1].updatedAt.localeCompare(b[1].updatedAt));
+    state.sessions = Object.fromEntries(entries.slice(-MAX_SESSION_IDS));
+};
+const collectCandidateTexts = (value, bucket) => {
+    if (bucket.length >= MAX_PREVIEWS)
+        return;
+    if (typeof value === "string") {
+        const preview = previewText(value);
+        if (preview)
+            bucket.push(preview);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    for (const key of ["content", "text", "entry", "summary", "memory", "drawer", "object"]) {
+        const preview = previewText(normalizeString(value[key]));
+        if (preview) {
+            bucket.push(preview);
+            return;
+        }
+    }
+};
+const extractResultArray = (result) => {
+    for (const key of ["results", "items", "matches", "entries", "drawers", "data"]) {
+        const value = result[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return undefined;
+};
+export const summarizeSearchResult = (result) => {
+    const array = extractResultArray(result);
+    const previews = [];
+    if (array) {
+        for (const item of array) {
+            collectCandidateTexts(item, previews);
+            if (previews.length >= MAX_PREVIEWS)
+                break;
+        }
+    }
+    return {
+        resultCount: array?.length,
+        previews,
+    };
+};
+export const recordRetrievalPrompt = async (input) => {
+    await updateState((state) => {
+        state.counters.retrievalPrompts += 1;
+        state.lastRetrievalPrompt = {
+            sessionId: input.sessionId,
+            timestamp: new Date().toISOString(),
+            queryPreview: previewText(input.queryPreview),
+        };
+        updateSessionState(state, input.sessionId, (sessionState) => {
+            sessionState.lastRetrievalPrompt = state.lastRetrievalPrompt;
+        });
+    });
+};
+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(),
+            scope: input.scope,
+            room: input.room,
+            queryPreview: previewText(input.query),
+            resultCount: summary.resultCount,
+            previews: summary.previews,
+        };
+        updateSessionState(state, input.sessionId, (sessionState) => {
+            sessionState.counters.retrievalSearches += 1;
+            if ((summary.resultCount ?? 0) > 0) {
+                sessionState.counters.retrievalHits += 1;
+            }
+            sessionState.lastRetrieval = state.lastRetrieval;
+        });
+    });
+};
+export const recordMemoryWrite = async (input) => {
+    await updateState((state) => {
+        state.counters.manualWrites += 1;
+        state.lastWrite = {
+            timestamp: new Date().toISOString(),
+            mode: input.mode,
+            scope: input.scope,
+            room: input.room,
+            preview: previewText(input.preview),
+        };
+        updateSessionState(state, input.sessionId, (sessionState) => {
+            sessionState.counters.manualWrites += 1;
+            sessionState.lastWrite = state.lastWrite;
+        });
+    });
+};
+export const recordAutosave = async (input) => {
+    await updateState((state) => {
+        if (input.outcome === "saved")
+            state.counters.autosavesCompleted += 1;
+        if (input.outcome === "skipped")
+            state.counters.autosavesSkipped += 1;
+        if (input.outcome === "failed")
+            state.counters.autosavesFailed += 1;
+        state.lastAutosave = {
+            sessionId: input.sessionId,
+            timestamp: new Date().toISOString(),
+            outcome: input.outcome,
+            reason: input.reason,
+            wing: input.wing,
+            sourcePreview: previewText(input.sourcePreview),
+        };
+        updateSessionState(state, input.sessionId, (sessionState) => {
+            if (input.outcome === "saved")
+                sessionState.counters.autosavesCompleted += 1;
+            if (input.outcome === "skipped")
+                sessionState.counters.autosavesSkipped += 1;
+            if (input.outcome === "failed")
+                sessionState.counters.autosavesFailed += 1;
+            sessionState.lastAutosave = state.lastAutosave;
+        });
+    });
+};
+export const readStatusState = async () => {
+    await writeQueue;
+    return loadState();
+};
+export const resetStatusState = async () => {
+    writeQueue = Promise.resolve();
+    try {
+        await fs.unlink(getStatusFilePath());
+    }
+    catch {
+        // ignore missing file in tests
+    }
+};
+const isCurrentSession = (expectedSessionId, actualSessionId) => {
+    return Boolean(expectedSessionId && actualSessionId && 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}`);
+    }
+    if (sessionState.counters.manualWrites > 0) {
+        parts.push(`writes ${sessionState.counters.manualWrites}`);
+    }
+    if (sessionState.lastAutosave?.outcome === "failed") {
+        return `MEM FAILED · ${parts.join(" · ")}`;
+    }
+    if (sessionState.lastAutosave?.outcome === "skipped") {
+        return `MEM SKIPPED · ${parts.join(" · ")}`;
+    }
+    return `MEM ${parts.join(" · ")}`;
+};
+const pushRetrievalLines = (lines, retrieval, verbose) => {
+    if ("scope" in retrieval) {
+        const count = retrieval.resultCount;
+        if (count && count > 0) {
+            lines.push(`- Memory lookup: found ${count} relevant ${count === 1 ? "memory" : "memories"}.`);
+        }
+        else if (count === 0) {
+            lines.push("- Memory lookup: no relevant memory found.");
+        }
+        else {
+            lines.push("- Memory lookup: search completed; result count unavailable.");
+        }
+        lines.push(`- Query: ${retrieval.queryPreview}`);
+        if (verbose && retrieval.previews.length) {
+            lines.push("- Relevant memories:");
+            for (const preview of retrieval.previews) {
+                lines.push(`  - ${preview}`);
+            }
+        }
+        return;
+    }
+    lines.push("- Memory lookup: retrieval prompt was prepared but no visible search result is recorded yet.");
+    lines.push(`- Query: ${retrieval.queryPreview}`);
+};
+const pushAutosaveLines = (lines, autosave) => {
+    const outcome = autosave.outcome === "saved"
+        ? "saved session context"
+        : autosave.outcome === "skipped"
+            ? "skipped"
+            : "failed";
+    lines.push(`- Autosave: ${outcome} after ${autosave.reason}.`);
+    if (autosave.sourcePreview) {
+        lines.push(`- Source context: ${autosave.sourcePreview}`);
+    }
+};
+const compactRetrievalSummary = (retrieval) => {
+    if (!retrieval)
+        return "no memory lookup recorded";
+    if ("scope" in retrieval) {
+        const count = retrieval.resultCount;
+        if (count && count > 0)
+            return `${count} relevant ${count === 1 ? "memory" : "memories"} found`;
+        if (count === 0)
+            return "no relevant memory found";
+        return "memory lookup completed";
+    }
+    return "retrieval prompt prepared";
+};
+const compactAutosaveSummary = (autosave) => {
+    if (!autosave)
+        return "no autosave recorded";
+    if (autosave.outcome === "saved")
+        return `autosave saved after ${autosave.reason}`;
+    if (autosave.outcome === "skipped")
+        return `autosave skipped after ${autosave.reason}`;
+    return `autosave failed after ${autosave.reason}`;
+};
+export const formatStatusSummary = (state, sessionId, options = {}) => {
+    const verbose = options.verbose ?? false;
+    const compact = options.compact ?? false;
+    const lines = ["MemPalace status"];
+    if (!state.lastRetrieval && !state.lastAutosave && !state.lastWrite && !state.lastRetrievalPrompt) {
+        lines.push("- No visible retrieval or autosave activity recorded yet.");
+        return lines.join("\n");
+    }
+    const currentRetrieval = state.lastRetrieval && isCurrentSession(sessionId, state.lastRetrieval.sessionId)
+        ? state.lastRetrieval
+        : !state.lastRetrieval && state.lastRetrievalPrompt && isCurrentSession(sessionId, state.lastRetrievalPrompt.sessionId)
+            ? state.lastRetrievalPrompt
+            : undefined;
+    const lastRetrieval = state.lastRetrieval && !isCurrentSession(sessionId, state.lastRetrieval.sessionId)
+        ? state.lastRetrieval
+        : !state.lastRetrieval && state.lastRetrievalPrompt && !isCurrentSession(sessionId, state.lastRetrievalPrompt.sessionId)
+            ? state.lastRetrievalPrompt
+            : undefined;
+    const currentAutosave = state.lastAutosave && isCurrentSession(sessionId, state.lastAutosave.sessionId)
+        ? state.lastAutosave
+        : undefined;
+    const lastAutosave = state.lastAutosave && !isCurrentSession(sessionId, state.lastAutosave.sessionId)
+        ? state.lastAutosave
+        : undefined;
+    if (compact) {
+        lines.push(`- Current session: ${compactRetrievalSummary(currentRetrieval)}; ${compactAutosaveSummary(currentAutosave)}.`);
+        lines.push(`- Last activity: ${compactRetrievalSummary(lastRetrieval)}; ${compactAutosaveSummary(lastAutosave)}.`);
+        if (state.lastWrite) {
+            lines.push(`- Last write: ${state.lastWrite.mode} \`${state.lastWrite.preview}\`.`);
+        }
+        return lines.join("\n");
+    }
+    const currentLines = [];
+    const lastLines = [];
+    if (currentRetrieval)
+        pushRetrievalLines(currentLines, currentRetrieval, verbose);
+    if (lastRetrieval)
+        pushRetrievalLines(lastLines, lastRetrieval, verbose);
+    if (currentAutosave)
+        pushAutosaveLines(currentLines, currentAutosave);
+    if (lastAutosave)
+        pushAutosaveLines(lastLines, lastAutosave);
+    lines.push("Current session");
+    if (currentLines.length) {
+        lines.push(...currentLines);
+    }
+    else {
+        lines.push("- No retrieval or autosave recorded for this session yet.");
+    }
+    lines.push("Last activity");
+    if (lastLines.length) {
+        lines.push(...lastLines);
+    }
+    else {
+        lines.push("- No separate past retrieval or autosave activity recorded.");
+    }
+    if (state.lastWrite) {
+        lines.push(`- Last explicit memory write: ${state.lastWrite.mode} stored \`${state.lastWrite.preview}\`.`);
+    }
+    lines.push("- Totals:");
+    lines.push(`  retrieval prompts: ${state.counters.retrievalPrompts}`);
+    lines.push(`  retrieval searches: ${state.counters.retrievalSearches}`);
+    lines.push(`  retrieval hits: ${state.counters.retrievalHits}`);
+    lines.push(`  autosaves completed: ${state.counters.autosavesCompleted}`);
+    lines.push(`  autosaves skipped: ${state.counters.autosavesSkipped}`);
+    lines.push(`  autosaves failed: ${state.counters.autosavesFailed}`);
+    lines.push(`  manual writes: ${state.counters.manualWrites}`);
+    return lines.join("\n");
+};

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

@@ -1,7 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { Event, Message, Part } from "@opencode-ai/sdk";
-import { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, LOG_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT } from "./constants";
-export { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, LOG_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, };
+import { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, LOG_FILE_NAME, STATUS_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT } from "./constants";
+export { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, LOG_FILE_NAME, STATUS_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, };
 export declare const MEMORY_SCOPES: readonly ["user", "project"];
 export type MemoryScope = (typeof MEMORY_SCOPES)[number];
 export declare const USER_MEMORY_ROOMS: readonly ["preferences", "workflow", "communication"];

package/dist/plugin/lib/types.js

@@ -1,5 +1,5 @@
-import { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, LOG_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, } from "./constants";
-export { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, LOG_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, };
+import { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, LOG_FILE_NAME, STATUS_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, } from "./constants";
+export { DEFAULT_ROOM, DEFAULT_TOPIC, DEFAULT_AGENT_NAME, DEFAULT_EXTRACT_MODE, DEFAULT_INJECTED_ITEMS, DEFAULT_RETRIEVAL_LIMIT, DEFAULT_LIMIT, DEFAULT_ADAPTER_TIMEOUT_MS, DEFAULT_USER_WING_PREFIX, DEFAULT_PROJECT_WING_PREFIX, DEFAULT_KEYWORD_PATTERNS, CONFIG_PATH_SEGMENTS, ENV_KEYS, MAX_USER_MESSAGES_DIGEST, MAX_TRANSCRIPT_MESSAGES_DIGEST, DATE_ISO_SLICE, SERVICE_NAME, LOG_FILE_NAME, STATUS_FILE_NAME, DIRECT_MEMPALACE_MUTATION_TOOLS, TOOL_DESCRIPTIONS, TOOL_ERROR_MESSAGES, LOG_MESSAGES, INSTRUCTION_TEXT, COMPACTION_CONTEXT_MESSAGE, ERROR_MESSAGES, };
 export const MEMORY_SCOPES = ["user", "project"];
 export const USER_MEMORY_ROOMS = ["preferences", "workflow", "communication"];
 export const PROJECT_MEMORY_ROOMS = ["architecture", "workflow", "decisions", "bugs", "setup"];

package/dist/plugin/tools/mempalace-memory.js

@@ -2,10 +2,12 @@ import { tool } from "@opencode-ai/plugin";
 import { executeAdapter } from "../lib/adapter";
 import { loadConfig } from "../lib/config";
 import { sanitizeText } from "../lib/derive";
-import { DATE_ISO_SLICE, DEFAULT_AGENT_NAME, DEFAULT_LIMIT, DEFAULT_ROOM, DEFAULT_TOPIC, ERROR_MESSAGES, TOOL_DESCRIPTIONS } from "../lib/constants";
+import { DATE_ISO_SLICE, DEFAULT_AGENT_NAME, DEFAULT_LIMIT, DEFAULT_ROOM, DEFAULT_TOPIC, ERROR_MESSAGES, LOG_MESSAGES, TOOL_DESCRIPTIONS } from "../lib/constants";
 import { getProjectName } from "../lib/opencode";
 import { isFullyPrivate, redactSecrets } from "../lib/privacy";
 import { getProjectScope, getUserScope } from "../lib/scope";
+import { recordMemoryWrite, recordRetrievalSearch, summarizeSearchResult } from "../lib/status";
+import { writeLog } from "../lib/log";
 import { MEMORY_SCOPES, TOOL_MEMORY_MODES } from "../lib/types";
 const getProjectWing = (projectName, prefix) => {
     return getProjectScope(projectName, prefix).wing;
@@ -34,7 +36,7 @@ export const mempalaceMemoryTool = (ctx) => tool({
         agent_name: tool.schema.string().optional().default(DEFAULT_AGENT_NAME),
         limit: tool.schema.number().optional().default(DEFAULT_LIMIT),
     },
-    async execute(args) {
+    async execute(args, executionContext) {
         const config = await loadConfig();
         const scope = args.scope ?? "project";
         const wing = scope === "user"
@@ -54,6 +56,15 @@ export const mempalaceMemoryTool = (ctx) => tool({
                 content,
                 added_by: DEFAULT_AGENT_NAME,
             });
+            if (result?.success !== false) {
+                await recordMemoryWrite({
+                    sessionId: executionContext.sessionID,
+                    mode: "save",
+                    scope,
+                    room: args.room,
+                    preview: content,
+                });
+            }
             return JSON.stringify(result);
         }
         if (args.mode === "search") {
@@ -67,7 +78,31 @@ export const mempalaceMemoryTool = (ctx) => tool({
                 room: normalizeValue(args.room, false),
                 limit: args.limit,
             });
-            return JSON.stringify(result);
+            const summary = summarizeSearchResult(result);
+            if (result?.success !== false) {
+                await recordRetrievalSearch({
+                    sessionId: executionContext.sessionID,
+                    scope,
+                    room: args.room,
+                    query,
+                    result,
+                });
+                await writeLog("INFO", LOG_MESSAGES.retrievalSearchCompleted, {
+                    sessionId: executionContext.sessionID,
+                    scope,
+                    room: args.room,
+                    query: query.slice(0, 200),
+                    resultCount: summary.resultCount ?? 0,
+                    previews: summary.previews,
+                });
+            }
+            const retrievalNote = summary.resultCount
+                ? `Found ${summary.resultCount} relevant ${summary.resultCount === 1 ? "memory" : "memories"}:\n${summary.previews.map((p, i) => `${i + 1}. ${p}`).join("\n")}`
+                : "No relevant memories found.";
+            const enriched = typeof result === "object" && result !== null
+                ? { ...result, _retrieval_summary: retrievalNote }
+                : result;
+            return JSON.stringify(enriched);
         }
         if (args.mode === "kg_add") {
             if (!args.subject || !args.predicate || !args.object) {
@@ -84,6 +119,14 @@ export const mempalaceMemoryTool = (ctx) => tool({
                 valid_from: new Date().toISOString().slice(0, DATE_ISO_SLICE),
                 source_closet: "",
             });
+            if (result?.success !== false) {
+                await recordMemoryWrite({
+                    sessionId: executionContext.sessionID,
+                    mode: "kg_add",
+                    scope,
+                    preview: `${subject} ${predicate} ${object}`,
+                });
+            }
             return JSON.stringify(result);
         }
         const result = await executeAdapter(ctx.$, {
@@ -92,6 +135,14 @@ export const mempalaceMemoryTool = (ctx) => tool({
             entry: normalizeValue(args.content || "", config.privacyRedactionEnabled) ?? "",
             topic: normalizeValue(args.topic, false) ?? DEFAULT_TOPIC,
         });
+        if (result?.success !== false) {
+            await recordMemoryWrite({
+                sessionId: executionContext.sessionID,
+                mode: "diary_write",
+                scope,
+                preview: normalizeValue(args.content || "", config.privacyRedactionEnabled) ?? "",
+            });
+        }
         return JSON.stringify(result);
     },
 });

package/dist/plugin/tools/mempalace-status.d.ts

@@ -0,0 +1,11 @@
+export declare const mempalaceStatusTool: () => {
+    description: string;
+    args: {
+        verbose: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        compact: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    };
+    execute(args: {
+        verbose: boolean;
+        compact: boolean;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};