om-memory-system 5.9.0 → 5.10.1

package/dist/core/memorise-turn.js

@@ -0,0 +1,64 @@
+/**
+ * A memorisation reaches an agent only through `recall`. A turn in which the
+ * agent saved one must not also be captured as an ordinary memory, or the
+ * snapshot would come back through per-prompt recall. The host readers set
+ * `memorise` on each tool call from the raw arguments and the result; the
+ * detector reads only that field. No result text is kept.
+ */
+// The OMMS memory tool: bare on OpenCode and Pi, `mcp__<server>__memory` on Claude Code.
+const MEMORY_TOOL = /^(?:mcp__[\w-]*omms[\w-]*__)?memory$/;
+const MEMORISE_MODES = new Set(["memorise", "memorize"]);
+// `om-memory-system memory memorise`, with or without `npx`, flags before the mode word.
+const CLI_MEMORISE = /\bom-memory-system\b[^|;&\n]*?\bmemory\s+(?:memorise|memorize)\b/;
+function recordOf(args) {
+    let value = args;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** `unknown` for a memorise call (a result still has to answer it), otherwise undefined. */
+export function memoriseCallState(name, args) {
+    const record = recordOf(args);
+    if (!record)
+        return undefined;
+    if (MEMORY_TOOL.test(name)) {
+        const mode = typeof record.mode === "string" ? record.mode.trim().toLowerCase() : "";
+        return MEMORISE_MODES.has(mode) ? "unknown" : undefined;
+    }
+    if (name.toLowerCase() === "bash") {
+        const command = record.command;
+        return typeof command === "string" && CLI_MEMORISE.test(command) ? "unknown" : undefined;
+    }
+    return undefined;
+}
+/**
+ * The state a result gives a memorise call. A host error, or a JSON reply with
+ * `success: false`, is `failed`. The memory tool reports its own failures as a
+ * normal reply with `success: false`, so the host does not always mark them.
+ */
+export function memoriseResultState(isError, text) {
+    if (isError)
+        return "failed";
+    try {
+        const reply = JSON.parse(text.trim());
+        if (reply && typeof reply === "object" && reply.success === false) {
+            return "failed";
+        }
+    }
+    catch {
+        // Not JSON: the host reported no error, so the call counts as saved.
+    }
+    return "saved";
+}
+/** True when any call in the turn saved a memorisation. */
+export function turnSavedMemorisation(toolCalls) {
+    return toolCalls.some((call) => call.memorise === "saved");
+}

package/dist/core/memory-operations.d.ts

@@ -1,7 +1,7 @@
 import { type MemoryScope } from "../services/client.js";
 import { getTags } from "../services/tags.js";
 import type { MemoryHost, MemoryType } from "../types/index.js";
-export type MemoryOperationMode = "add" | "search" | "profile" | "list" | "forget" | "help" | "migrate" | "list-shards" | "export" | "import" | "space";
+export type MemoryOperationMode = "add" | "memorise" | "memorize" | "recall" | "search" | "profile" | "list" | "forget" | "help" | "migrate" | "list-shards" | "export" | "import" | "space";
 export interface MemoryOperationArgs {
     mode?: MemoryOperationMode;
     content?: string;
@@ -11,6 +11,11 @@ export interface MemoryOperationArgs {
     memoryId?: string;
     limit?: number;
     scope?: MemoryScope;
+    /** `memorise` mode: session snapshot fields, used instead of `content`. */
+    topic?: string;
+    done?: string;
+    doing?: string;
+    next?: string;
     fromPath?: string;
     fromHash?: string;
     outputPath?: string;

package/dist/core/memory-operations.js

@@ -1,5 +1,8 @@
 import { CONFIG, isConfigured, refreshConfigIfChanged } from "../config.js";
 import { memoryClient } from "../services/client.js";
+import { runMemorise, runRecall } from "./memorisation-operations.js";
+import { memorisationSettingsFrom } from "./memorisation-settings.js";
+import { linkedSettingsFrom } from "../services/linked-search.js";
 import { getLanguageName } from "../services/language-detector.js";
 import { stripPrivateContent, isFullyPrivate } from "../services/privacy.js";
 import { getTags } from "../services/tags.js";
@@ -29,6 +32,11 @@ export async function executeMemoryOperation(args, context) {
             error: "Memory system not configured properly.",
         };
     }
+    // Snapshot fields without a mode are a memorise call that lost its mode. Help
+    // text would read as success, so the model would never learn nothing was saved.
+    if (!args.mode && [args.topic, args.done, args.doing, args.next].some((v) => v !== undefined)) {
+        return { success: false, error: "mode is required: use memorise for snapshot fields" };
+    }
     const mode = args.mode || "help";
     if (mode === "space") {
         const { runSpaceMode } = await import("./space-tool.js");
@@ -70,6 +78,16 @@ export async function executeMemoryOperation(args, context) {
                             description: `Store new memory (MATCH USER LANGUAGE: ${langName})`,
                             args: ["content", "type?", "tags?"],
                         },
+                        {
+                            command: "memorise",
+                            description: `Save an exact memorisation with a short ms- ID: give content, or a session snapshot with topic, done, doing and next. Never reads session history (MATCH USER LANGUAGE: ${langName})`,
+                            args: ["content?", "topic?", "done?", "doing?", "next?", "tags?"],
+                        },
+                        {
+                            command: "recall",
+                            description: "Fetch memorisations only: pass an ms- ID for the exact text, or text for ranked matches with a confidence score. Pass tags (the labels) to keep only memorisations that carry all of them; tags with no query lists the newest ones",
+                            args: ["query?", "tags?", "limit?"],
+                        },
                         {
                             command: "search",
                             description: `Search memories via keywords (MATCH USER LANGUAGE: ${langName})`,
@@ -121,6 +139,12 @@ export async function executeMemoryOperation(args, context) {
             case "add": {
                 if (!args.content)
                     return { success: false, error: "content required" };
+                if (args.type === "memorisation") {
+                    return {
+                        success: false,
+                        error: 'type "memorisation" is reserved. Use memorise mode to save a memorisation.',
+                    };
+                }
                 const sanitizedContent = stripPrivateContent(args.content);
                 if (isFullyPrivate(args.content)) {
                     return { success: false, error: "Private content blocked" };
@@ -148,6 +172,11 @@ export async function executeMemoryOperation(args, context) {
                     tags: parsedTags,
                 };
             }
+            case "memorise":
+            case "memorize":
+                return await runMemorise(args, context, tags, memorisationSettingsFrom(CONFIG), linkedSettingsFrom(CONFIG));
+            case "recall":
+                return await runRecall(args, tags, args.scope ?? CONFIG.memory.defaultScope, linkedSettingsFrom(CONFIG));
             case "search": {
                 if (!args.query)
                     return { success: false, error: "query required" };

package/dist/core/memory-tool-text.js

@@ -2,5 +2,5 @@
 export const MEMORY_SEARCH_FIRST = "Search it before you debug or investigate a problem: earlier fixes and decisions are stored here.";
 /** The `memory` tool description, the same text for Pi and OpenCode. */
 export function memoryToolDescription(languageName) {
-    return `Manage and query project memory (MATCH USER LANGUAGE: ${languageName}). ${MEMORY_SEARCH_FIRST} Use 'search' with technical keywords/tags, 'add' to store knowledge, 'profile' for preferences. Use migrate/list-shards/export/import when a project directory moves. Search/list scope: project or all-projects.`;
+    return `Manage and query project memory (MATCH USER LANGUAGE: ${languageName}). ${MEMORY_SEARCH_FIRST} Use 'search' with technical keywords/tags, 'add' to store knowledge, 'profile' for preferences. Use 'memorise' to save an exact note or a session snapshot (topic, done, doing, next) with a short ms- ID, and 'recall' to fetch it by ID, by text or by its labels (tags, all of which must match); memorisations never appear in 'search' or automatic recall. When the user quotes an ms- ID or asks what was planned or memorised ("what were we going to do with X"), use 'recall', not 'search'. Use migrate/list-shards/export/import when a project directory moves. Search/list scope: project or all-projects.`;
 }

package/dist/core/retrieval.d.ts

@@ -12,8 +12,9 @@ export declare function searchSectionMemories(query: string, projectTag: string,
     queryVector?: ArrayLike<number>;
 } | null>;
 /**
- * The prompt text that may reach a search: `<private>` regions removed. Null when nothing is
- * left, so a fully private prompt runs no search and nothing of it reaches an embedding provider.
+ * The prompt text that may reach a search: skill blocks and `<private>` regions removed. Null when
+ * nothing is left, so a fully private prompt, or a skill run with no text of its own, runs no
+ * search and nothing of it reaches an embedding provider.
  */
 export declare function searchablePrompt(prompt: string): string | null;
 /**

package/dist/core/retrieval.js

@@ -29,13 +29,20 @@ export async function searchSectionMemories(query, projectTag, sessionId) {
     return { results, queryVector: search.queryVector };
 }
 /**
- * The prompt text that may reach a search: `<private>` regions removed. Null when nothing is
- * left, so a fully private prompt runs no search and nothing of it reaches an embedding provider.
+ * Pi expands `/skill:<name> text` into `<skill ...>skill body</skill>` followed by the user's text.
+ * The search uses the user's own words, so the whole block is cut out.
+ */
+const SKILL_BLOCK = /<skill\b[^>]*>[\s\S]*?<\/skill>/gi;
+/**
+ * The prompt text that may reach a search: skill blocks and `<private>` regions removed. Null when
+ * nothing is left, so a fully private prompt, or a skill run with no text of its own, runs no
+ * search and nothing of it reaches an embedding provider.
  */
 export function searchablePrompt(prompt) {
-    if (isFullyPrivate(prompt))
+    const text = prompt.replace(SKILL_BLOCK, "");
+    if (isFullyPrivate(text))
         return null;
-    return stripPrivateContent(prompt).trim() || null;
+    return stripPrivateContent(text).trim() || null;
 }
 /**
  * Prompt-aware semantic retrieval shared by every host (Pi `before_agent_start`,

package/dist/core/tool-outcome.d.ts

@@ -10,4 +10,10 @@ export declare function errorOutcome(text: unknown): ToolOutcomeFields;
  * the history import read the same part shape.
  */
 export declare function opencodeToolOutcome(state: unknown): ToolOutcomeFields;
+/**
+ * The `memorise` field for an OpenCode tool part, or nothing for any other
+ * call. A completed call is `saved` or `failed` by its reply, an errored call
+ * is `failed`, and a call still running is `unknown`.
+ */
+export declare function opencodeMemorise(name: string, args: unknown, state: unknown): Pick<CaptureToolCall, "memorise">;
 export {};

package/dist/core/tool-outcome.js

@@ -1,3 +1,4 @@
+import { memoriseCallState, memoriseResultState } from "./memorise-turn.js";
 export const MAX_TOOL_ERROR_LENGTH = 2000;
 /** Error text as the host reported it, cut to at most 2,000 characters. */
 export function boundToolError(text) {
@@ -20,3 +21,33 @@ export function opencodeToolOutcome(state) {
         return errorOutcome(error);
     return { outcome: "unknown" };
 }
+/**
+ * The text an OpenCode tool part returned: V1 keeps it in `state.output`, the
+ * V2 plugin API in `state.content` text items. Used only to read a memorise
+ * reply; it is never stored.
+ */
+function opencodeToolText(state) {
+    if (typeof state.output === "string")
+        return state.output;
+    if (!Array.isArray(state.content))
+        return "";
+    return state.content
+        .map((item) => (item && typeof item === "object" ? item.text : null))
+        .filter((text) => typeof text === "string")
+        .join("\n");
+}
+/**
+ * The `memorise` field for an OpenCode tool part, or nothing for any other
+ * call. A completed call is `saved` or `failed` by its reply, an errored call
+ * is `failed`, and a call still running is `unknown`.
+ */
+export function opencodeMemorise(name, args, state) {
+    if (!memoriseCallState(name, args))
+        return {};
+    const fields = (state && typeof state === "object" ? state : {});
+    if (fields.status === "error")
+        return { memorise: "failed" };
+    if (fields.status !== "completed")
+        return { memorise: "unknown" };
+    return { memorise: memoriseResultState(false, opencodeToolText(fields)) };
+}

package/dist/importer/claude-conversation.js

@@ -1,4 +1,5 @@
 import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { memoriseCallState, memoriseResultState } from "../core/memorise-turn.js";
 import { errorOutcome } from "../core/tool-outcome.js";
 /**
  * Entry types seen in real transcripts. A line with any other type is skipped
@@ -158,6 +159,9 @@ function addAssistantWork(open, entry) {
         const path = readToolPath(name, block.input);
         if (path !== undefined)
             call.path = path;
+        const memorise = memoriseCallState(name, block.input);
+        if (memorise)
+            call.memorise = memorise;
         open.toolCalls.push(call);
         if (typeof block.id === "string")
             open.callsById.set(block.id, call);
@@ -183,10 +187,13 @@ function addToolResults(open, entry) {
         const call = open.callsById.get(block.tool_use_id ?? "");
         if (!call)
             continue;
+        const text = toolResultText(block.content);
         if (block.is_error === true)
-            Object.assign(call, errorOutcome(toolResultText(block.content)));
+            Object.assign(call, errorOutcome(text));
         else
             call.outcome = "ok";
+        if (call.memorise)
+            call.memorise = memoriseResultState(block.is_error === true, text);
     }
 }
 function windowsWithIndex(entries) {

package/dist/importer/claude-turn-units.js

@@ -51,6 +51,7 @@ export function workUnitOf(sessionId, window, directory) {
         toolCalls: window.toolCalls.map((call) => ({
             name: call.name,
             input: stripPrivateContent(call.input),
+            ...(call.memorise ? { memorise: call.memorise } : {}),
         })),
         sourceEntryIds: window.sourceEntryIds,
         ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),

package/dist/importer/importer.js

@@ -214,11 +214,11 @@ export async function importHistorySource(source, host, deps, filters, report) {
         try {
             const result = await handleFinishedTurn(workUnit, { memories: true, skills: false }, { provider: deps.provider });
             if (result.status === "skipped") {
-                await ledger.skip(key, `extractor-skip:${result.type ?? "unknown"}`);
+                const reason = result.reason ?? `extractor-skip:${result.type ?? "unknown"}`;
+                await ledger.skip(key, reason);
                 unit.status = "skipped";
-                unit.reason = `extractor-skip:${result.type ?? "unknown"}`;
+                unit.reason = reason;
                 report.unitsSkipped++;
-                const reason = unit.reason;
                 report.skipReasons[reason] = (report.skipReasons[reason] ?? 0) + 1;
             }
             else {

package/dist/importer/opencode-reader.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DatabaseSync } from "node:sqlite";
 import { boundToolInput, readToolPath } from "../core/tool-input.js";
-import { opencodeToolOutcome } from "../core/tool-outcome.js";
+import { opencodeMemorise, opencodeToolOutcome } from "../core/tool-outcome.js";
 import { INTERNAL_CAPTURE_SESSION_TITLES } from "./opencode-internal-sessions.js";
 import { acquirePrivateSnapshot, opencodeSnapshots, OpencodeSnapshotError, } from "./opencode-snapshot.js";
 export const DEFAULT_OPENCODE_DB = join(homedir(), ".local/share/opencode/opencode.db");
@@ -106,6 +106,7 @@ function buildWindows(db, sessionId, filters) {
                     name,
                     input: boundToolInput(formatInput(args)),
                     ...opencodeToolOutcome(state),
+                    ...opencodeMemorise(name, args, state),
                     ...(path === undefined ? {} : { path }),
                 });
             }

package/dist/importer/pi-conversation.js

@@ -1,4 +1,5 @@
 import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { memoriseCallState, memoriseResultState } from "../core/memorise-turn.js";
 import { errorOutcome } from "../core/tool-outcome.js";
 function entryText(content) {
     if (typeof content === "string")
@@ -28,12 +29,14 @@ function applyToolResult(entry, callsById) {
     const call = callsById.get(entry.message?.toolCallId ?? "");
     if (!call)
         return;
-    if (entry.message?.isError === true) {
-        Object.assign(call, errorOutcome(entryText(entry.message.content)));
-    }
-    else {
+    const text = entryText(entry.message?.content);
+    const isError = entry.message?.isError === true;
+    if (isError)
+        Object.assign(call, errorOutcome(text));
+    else
         call.outcome = "ok";
-    }
+    if (call.memorise)
+        call.memorise = memoriseResultState(isError, text);
 }
 function formatToolInput(args) {
     if (!args)
@@ -94,6 +97,9 @@ function buildWindow(entries, userIndex) {
             const path = readToolPath(name, block.arguments);
             if (path !== undefined)
                 call.path = path;
+            const memorise = memoriseCallState(name, block.arguments);
+            if (memorise)
+                call.memorise = memorise;
             toolCalls.push(call);
             if (typeof block.id === "string")
                 callsById.set(block.id, call);

package/dist/index.js

@@ -1,10 +1,8 @@
-import { tool } from "@opencode-ai/plugin";
 import { memoryClient } from "./services/client.js";
 import { getTags } from "./services/tags.js";
 import { performAutoCapture } from "./services/auto-capture.js";
 import { createOpenCodeAutoCaptureHost } from "./adapters/opencode/auto-capture-host.js";
 import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, } from "./adapters/opencode/user-prompt.js";
-import { executeMemoryOperation } from "./core/memory-operations.js";
 import { memoryToolDescription } from "./core/memory-tool-text.js";
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
 import { buildRecentMemoriesSection, formatMemoriesForCompaction } from "./core/retrieval.js";
@@ -22,6 +20,7 @@ import { getHostClientConfig } from "./adapters/opencode/opencode-host-config.js
 import { applySkillsPathConfig } from "./adapters/opencode/package-skills.js";
 import { loadOpencodeProvider } from "./adapters/opencode/opencode-provider-loader.js";
 import { opencodeSkillsTool } from "./adapters/opencode/skills-tool.js";
+import { opencodeMemoryTool } from "./adapters/opencode/memory-tool.js";
 import { STRUCTURED_OUTPUT_AGENT, STRUCTURED_OUTPUT_TOOLS, } from "./adapters/opencode/opencode-provider.js";
 import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle, isTrackedInternalCaptureSession, } from "./adapters/opencode/internal-capture-sessions.js";
 import { registerOpencodeProfileModel } from "./adapters/opencode/profile-model.js";
@@ -505,46 +504,7 @@ export const OmmsPlugin = async (ctx) => {
             }
         },
         tool: {
-            memory: tool({
-                description: memoryToolDescription(getLanguageName(CONFIG.autoCaptureLanguage || "en")),
-                args: {
-                    mode: tool.schema
-                        .enum([
-                        "add",
-                        "search",
-                        "profile",
-                        "list",
-                        "forget",
-                        "help",
-                        "migrate",
-                        "list-shards",
-                        "export",
-                        "import",
-                    ])
-                        .optional(),
-                    content: tool.schema.string().optional(),
-                    query: tool.schema.string().optional(),
-                    tags: tool.schema.string().optional(),
-                    type: tool.schema.string().optional(),
-                    memoryId: tool.schema.string().optional(),
-                    limit: tool.schema.number().optional(),
-                    scope: tool.schema.enum(["project", "all-projects"]).optional(),
-                    fromPath: tool.schema.string().optional(),
-                    fromHash: tool.schema.string().optional(),
-                    outputPath: tool.schema.string().optional(),
-                    inputPath: tool.schema.string().optional(),
-                    dryRun: tool.schema.boolean().optional(),
-                    allowLinkedSource: tool.schema.boolean().optional(),
-                },
-                async execute(args) {
-                    const result = await executeMemoryOperation(args, {
-                        directory,
-                        tags,
-                        host: "opencode",
-                    });
-                    return JSON.stringify(result);
-                },
-            }),
+            memory: opencodeMemoryTool(memoryToolDescription(getLanguageName(CONFIG.autoCaptureLanguage || "en")), { directory, tags }),
             skills: opencodeSkillsTool(directory),
         },
         event: async (input) => {

package/dist/services/api-handlers.js

@@ -12,6 +12,8 @@ import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
 import { saveProfile } from "./user-profile/merge-and-save.js";
 import { sortProfileItems, stripProfileVectors } from "../utils/profile.js";
 import { resolveWebProfileUserId } from "./profile-identity.js";
+import { UNTAGGED_NORMAL_PREDICATE } from "./memory-kind.js";
+import { loadMemoryRows, memorisationIdsAmong, MEMORISATION_EDIT_REFUSAL, MEMORISATION_TYPE_REFUSAL, webUpdateRefusal, } from "./web-memory-rows.js";
 async function getAllMemoryShards() {
     await ensureTursoReady();
     const projectShards = await tursoShardManager.getAllShards("project", "");
@@ -101,37 +103,6 @@ export async function handleListTags() {
         return { success: false, error: String(error) };
     }
 }
-/** Reads stored memory rows for one project tag, or for every project and user shard. */
-async function loadMemoryRows(tag) {
-    const allMemories = [];
-    if (tag) {
-        const { scope: tagScope, hash } = extractScopeFromTag(tag);
-        const shards = await tursoShardManager.getAllShards(tagScope, hash);
-        for (const shard of shards) {
-            const db = await tursoConnectionManager.getConnection(shard.dbPath);
-            const memories = await tursoVectorSearch.listMemories(db, tag, 10000);
-            allMemories.push(...memories);
-        }
-    }
-    else {
-        // Iterate both project- and user-scoped shards. Previously this only
-        // walked project shards, which silently hid user-scope memories from the
-        // listing endpoint (Web UI navigation, /api/memories without a tag
-        // filter, …). User-scope memories still showed up in /api/search and
-        // /api/stats `byType`, but were invisible in /api/stats `byScope` and
-        // unbrowseable in the UI — a confusing UX gap. The filter keeps the
-        // defense-in-depth check on container_tag, just widens it to both
-        // canonical scope markers.
-        const projectShards = await tursoShardManager.getAllShards("project", "");
-        const userShards = await tursoShardManager.getAllShards("user", "");
-        for (const shard of [...projectShards, ...userShards]) {
-            const db = await tursoConnectionManager.getConnection(shard.dbPath);
-            const memories = await tursoVectorSearch.getAllMemories(db);
-            allMemories.push(...memories.filter((m) => m.container_tag?.includes("_project_") || m.container_tag?.includes("_user_")));
-        }
-    }
-    return allMemories;
-}
 /** Labels (comma-separated memory tags) with how many memories carry each one. */
 export async function handleListKeywords(tag) {
     try {
@@ -288,6 +259,8 @@ export async function handleAddMemory(data) {
         if (!data.content || !data.containerTag) {
             return { success: false, error: "content and containerTag are required" };
         }
+        if (data.type === "memorisation")
+            return { success: false, error: MEMORISATION_TYPE_REFUSAL };
         await ensureTursoReady();
         await embeddingService.warmup();
         const tags = (data.tags || []).map((t) => t.trim().toLowerCase());
@@ -367,6 +340,9 @@ export async function handleBulkDelete(ids, cascade = false) {
     try {
         if (!ids || ids.length === 0)
             return { success: false, error: "ids array is required" };
+        if ((await memorisationIdsAmong(ids)).length > 0) {
+            return { success: false, error: MEMORISATION_EDIT_REFUSAL };
+        }
         let deleted = 0;
         for (const id of ids) {
             const result = await handleDeleteMemory(id, cascade);
@@ -384,6 +360,9 @@ export async function handleUpdateMemory(id, data) {
     try {
         if (!id)
             return { success: false, error: "id is required" };
+        const refusal = await webUpdateRefusal(id, data);
+        if (refusal)
+            return { success: false, error: refusal };
         await embeddingService.warmup();
         // Find the existing memory first (read-only — no data modified yet)
         const shards = await getAllMemoryShards();
@@ -1020,11 +999,10 @@ export async function handleUpdateProfileItem(body) {
 export async function handleDetectTagMigration() {
     try {
         await ensureTursoReady();
-        const projectShards = await tursoShardManager.getAllShards("project", "");
         let untaggedCount = 0;
-        for (const shard of projectShards) {
+        for (const shard of await tursoShardManager.getAllShards("project", "")) {
             const db = await tursoConnectionManager.getConnection(shard.dbPath);
-            const row = await db.get("SELECT COUNT(*) as count FROM memories WHERE tags IS NULL OR tags = ''");
+            const row = await db.get(`SELECT COUNT(*) as count FROM memories WHERE ${UNTAGGED_NORMAL_PREDICATE}`);
             untaggedCount += Number(row?.count ?? 0);
         }
         return { success: true, data: { needsMigration: untaggedCount > 0, count: untaggedCount } };
@@ -1066,7 +1044,7 @@ export async function handleRunTagMigrationBatch(batchSize = 5) {
             migrationQueue = [];
             for (const shard of await tursoShardManager.getAllShards("project", "")) {
                 const db = await tursoConnectionManager.getConnection(shard.dbPath);
-                const rows = await db.all("SELECT id FROM memories WHERE tags IS NULL OR tags = '' ORDER BY id");
+                const rows = await db.all(`SELECT id FROM memories WHERE ${UNTAGGED_NORMAL_PREDICATE} ORDER BY id`);
                 for (const row of rows)
                     migrationQueue.push({ id: String(row.id), dbPath: shard.dbPath });
             }

package/dist/services/capture-diagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { CaptureAttemptDiagnostics, CaptureAttemptOutcome, CaptureExtractionPath, CaptureFailureReason } from "../core/host.js";
+import type { CaptureAttemptDiagnostics, CaptureAttemptOutcome, CaptureExtractionPath, CaptureFailureReason, CaptureSkipReason } from "../core/host.js";
 import type { MemoryHost, MemorySourceType } from "../types/index.js";
 import { restrictToCurrentUser } from "./private-path.js";
 /**
@@ -36,7 +36,8 @@ export interface CaptureAttemptRecord {
     replyChars: number | null;
     durationMs: number;
     outcome: CaptureAttemptOutcome;
-    reason: CaptureFailureReason | null;
+    /** The failure code of a failed attempt, or the skip code of a turn skipped before the model ran. */
+    reason: CaptureFailureReason | CaptureSkipReason | null;
 }
 export declare const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
 export declare function buildCaptureAttemptRecord(context: CaptureAttemptContext, diagnostics: CaptureAttemptDiagnostics, outcome: CaptureAttemptOutcome, durationMs: number): CaptureAttemptRecord;

package/dist/services/capture-diagnostics.js

@@ -25,7 +25,11 @@ export function buildCaptureAttemptRecord(context, diagnostics, outcome, duratio
         replyChars: diagnostics.rawReply?.length ?? null,
         durationMs,
         outcome,
-        reason: outcome === "failed" ? (diagnostics.failureReason ?? "call-error") : null,
+        reason: outcome === "failed"
+            ? (diagnostics.failureReason ?? "call-error")
+            : outcome === "skipped"
+                ? (diagnostics.skipReason ?? null)
+                : null,
     };
 }
 // Common key and token formats. Each match is replaced whole, except the

package/dist/services/cleanup-service.js

@@ -5,6 +5,7 @@ import { ensureTursoReady } from "./turso/ready.js";
 import { CONFIG } from "../config.js";
 import { log } from "./logger.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+import { memoryKindPredicate } from "./memory-kind.js";
 export class CleanupService {
     lastCleanupTime = 0;
     isRunning = false;
@@ -50,7 +51,7 @@ export class CleanupService {
                 const db = await tursoConnectionManager.getConnection(shard.dbPath);
                 const oldMemories = await db.all(`
           SELECT id, container_tag, is_pinned FROM memories
-          WHERE updated_at < ?
+          WHERE updated_at < ? AND ${memoryKindPredicate()}
         `, [cutoffTime]);
                 for (const memory of oldMemories) {
                     try {

package/dist/services/client-session-read.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryKind } from "./memory-kind.js";
+export declare function searchMemoriesBySessionID(sessionID: string, containerTag: string, limit: number, kind: MemoryKind): Promise<{
+    id: any;
+    memory: any;
+    similarity: number;
+    tags: any;
+    metadata: any;
+    containerTag: any;
+    displayName: any;
+    userName: any;
+    userEmail: any;
+    projectPath: any;
+    projectName: any;
+    gitRepoUrl: any;
+    createdAt: any;
+}[]>;

package/dist/services/client-session-read.js

@@ -0,0 +1,32 @@
+import { extractScopeFromContainerTag } from "./memory-scope.js";
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+export async function searchMemoriesBySessionID(sessionID, containerTag, limit, kind) {
+    const { scope, hash } = extractScopeFromContainerTag(containerTag);
+    const shards = await tursoShardManager.getAllShards(scope, hash);
+    if (shards.length === 0)
+        return [];
+    const allMemories = [];
+    for (const shard of shards) {
+        const db = await tursoConnectionManager.getConnection(shard.dbPath);
+        const memories = await tursoVectorSearch.getMemoriesBySessionID(db, sessionID, kind);
+        allMemories.push(...memories);
+    }
+    allMemories.sort((a, b) => Number(b.created_at) - Number(a.created_at));
+    return allMemories.slice(0, limit).map((row) => ({
+        id: row.id,
+        memory: row.content,
+        similarity: 1.0,
+        tags: row.tags || [],
+        metadata: row.metadata || {},
+        containerTag: row.container_tag,
+        displayName: row.display_name,
+        userName: row.user_name,
+        userEmail: row.user_email,
+        projectPath: row.project_path,
+        projectName: row.project_name,
+        gitRepoUrl: row.git_repo_url,
+        createdAt: row.created_at,
+    }));
+}