pi-mega-compact 0.4.28 → 0.5.0

package/src/store/sqlite.ts

@@ -57,7 +57,17 @@ const cache = new Map<string, DatabaseSync>();
 /** Open (or reuse) the SQLite store for a state dir. */
 export function openStore(stateDir: string = getStateDir()): DatabaseSync {
   const existing = cache.get(stateDir);
-  if (existing) return existing;
+  if (existing) {
+    // A closed handle in the cache (e.g. a test calling db.close() directly
+    // instead of closeStore) would surface as "database is not open" on the
+    // next reuse. Detect and evict so callers never see a dead handle.
+    try {
+      existing.prepare("SELECT 1");
+      return existing;
+    } catch {
+      cache.delete(stateDir);
+    }
+  }
 
   if (!existsSync(stateDir)) mkdirSync(stateDir, { recursive: true });
   const db = new DatabaseSync(join(stateDir, "sqlite.db"));
@@ -121,6 +131,19 @@ export function openIndexStore(indexDir: string = getIndexDir()): DatabaseSync {
       model_captured_at         INTEGER
     );
     CREATE INDEX IF NOT EXISTS idx_registry_last_seen ON repo_registry(last_seen DESC);
+    -- S18: machine-wide injected-set. A foreign checkpoint injected in repo A is
+    -- recorded here so repo B's recall never re-injects it. Keyed by checkpoint
+    -- + session (a checkpoint may be injected once per session); repo_id is the
+    -- source repo (the foreign repo's stateDir) for tracking/source labels.
+    -- PRAMETERIZED queries (PREVENT-002); local node:sqlite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS injected_global (
+      checkpoint_id TEXT NOT NULL,
+      repo_id       TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      injected_at   INTEGER NOT NULL,
+      PRIMARY KEY (checkpoint_id, session_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_injected_global_cid ON injected_global(checkpoint_id);
   `);
   indexCache = iddb;
   indexCacheDir = indexDir;
@@ -160,6 +183,19 @@ export function upsertRepoRegistry(
     tokensSaved: number;
     compressedOriginalBytes: number;
     lastCompactedAt?: number | null;
+    // The fields below are optional passthroughs so test fixtures and the
+    // /api/repos active-window filter can seed them directly. They're also
+    // written by other paths (recordRepoModel, registry refresh) — passing
+    // them here is harmless because the ON CONFLICT clause keeps first_seen
+    // and the model columns from being clobbered.
+    firstSeen?: number;
+    lastSeen?: number;
+    provider?: string | null;
+    providerName?: string | null;
+    modelName?: string | null;
+    inputRate?: number | null;
+    outputRate?: number | null;
+    modelCapturedAt?: number | null;
   },
   indexDir: string = getIndexDir(),
 ): void {
@@ -168,26 +204,42 @@ export function upsertRepoRegistry(
   db.prepare(
     `INSERT INTO repo_registry
        (repo_root, display_name, state_dir, first_seen, last_seen, last_compacted_at,
-        checkpoint_count, tokens_saved, compressed_original_bytes)
-     VALUES (@repo_root, @display_name, @state_dir, @now, @now, @last_compacted_at,
-             @checkpoint_count, @tokens_saved, @compressed_original_bytes)
+        checkpoint_count, tokens_saved, compressed_original_bytes,
+        provider, provider_name, model_name, input_rate, output_rate, model_captured_at)
+     VALUES (@repo_root, @display_name, @state_dir, @first_seen, @last_seen, @last_compacted_at,
+             @checkpoint_count, @tokens_saved, @compressed_original_bytes,
+             @provider, @provider_name, @model_name, @input_rate, @output_rate, @model_captured_at)
      ON CONFLICT(repo_root) DO UPDATE SET
        display_name = excluded.display_name,
        state_dir = excluded.state_dir,
-       last_seen = excluded.last_seen,
+       last_seen = COALESCE(excluded.last_seen, @now),
        last_compacted_at = COALESCE(excluded.last_compacted_at, repo_registry.last_compacted_at),
        checkpoint_count = excluded.checkpoint_count,
        tokens_saved = excluded.tokens_saved,
-       compressed_original_bytes = excluded.compressed_original_bytes`,
+       compressed_original_bytes = excluded.compressed_original_bytes,
+       provider = COALESCE(excluded.provider, repo_registry.provider),
+       provider_name = COALESCE(excluded.provider_name, repo_registry.provider_name),
+       model_name = COALESCE(excluded.model_name, repo_registry.model_name),
+       input_rate = COALESCE(excluded.input_rate, repo_registry.input_rate),
+       output_rate = COALESCE(excluded.output_rate, repo_registry.output_rate),
+       model_captured_at = COALESCE(excluded.model_captured_at, repo_registry.model_captured_at)`,
   ).run({
     repo_root: row.repoRoot,
     display_name: row.displayName,
     state_dir: row.stateDir,
     now,
+    first_seen: row.firstSeen ?? null,
+    last_seen: row.lastSeen ?? null,
     last_compacted_at: row.lastCompactedAt ?? null,
     checkpoint_count: row.checkpointCount,
     tokens_saved: row.tokensSaved,
     compressed_original_bytes: row.compressedOriginalBytes,
+    provider: row.provider ?? null,
+    provider_name: row.providerName ?? null,
+    model_name: row.modelName ?? null,
+    input_rate: row.inputRate ?? null,
+    output_rate: row.outputRate ?? null,
+    model_captured_at: row.modelCapturedAt ?? null,
   });
 }
 
@@ -281,6 +333,51 @@ export function closeIndexStore(): void {
   }
 }
 
+// ---------------------------------------------------------------------------
+// S18: machine-wide injected-set (cross-repo dedup markers)
+//
+// A foreign checkpoint injected in repo A is recorded here so repo B's recall
+// never re-injects it (a stronger, machine-wide version of the per-session
+// injected-set in the local store). Keyed by (checkpoint_id, session_id); the
+// session_id here is the RECEIVING session, so the same foreign checkpoint can
+// be injected into different sessions but never twice into the same one.
+// PRAMETERIZED queries (PREVENT-002); local node:sqlite + WAL (PREVENT-PI-004),
+// multi-process safe.
+// ---------------------------------------------------------------------------
+
+/** Record that a (foreign) checkpoint was injected into `sessionId`. Idempotent. */
+export function markInjectedGlobal(
+  checkpointId: string,
+  repoId: string,
+  sessionId: string,
+  indexDir: string = getIndexDir(),
+): void {
+  const db = openIndexStore(indexDir);
+  db.prepare(
+    "INSERT OR IGNORE INTO injected_global (checkpoint_id, repo_id, session_id, injected_at) VALUES ($cid, $rid, $sid, $ts)",
+  ).run({ $cid: checkpointId, $rid: repoId, $sid: sessionId, $ts: Date.now() });
+}
+
+/** True when a checkpoint was already injected into `sessionId` (machine-wide). */
+export function wasInjectedGlobal(
+  checkpointId: string,
+  sessionId: string,
+  indexDir: string = getIndexDir(),
+): boolean {
+  const db = openIndexStore(indexDir);
+  const row = db.prepare(
+    "SELECT 1 FROM injected_global WHERE checkpoint_id = $cid AND session_id = $sid LIMIT 1",
+  ).get({ $cid: checkpointId, $sid: sessionId }) as { "1": number } | undefined;
+  return row !== undefined;
+}
+
+/** Count of cross-repo injections recorded (for /mega-status stats). */
+export function countInjectedGlobal(indexDir: string = getIndexDir()): number {
+  const db = openIndexStore(indexDir);
+  const row = db.prepare("SELECT COUNT(*) AS n FROM injected_global").get() as { n: number } | undefined;
+  return row?.n ?? 0;
+}
+
 function initSchema(db: DatabaseSync): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS context_chunks (
@@ -430,7 +527,12 @@ function initSchema(db: DatabaseSync): void {
       content           TEXT NOT NULL,
       tags              TEXT,                   -- JSON array of strings
       created_at        INTEGER,
-      last_recalled_at  INTEGER
+      last_recalled_at  INTEGER,
+      -- S20 memory-RAG extension (auto-review add/replace/remove ops).
+      category          TEXT,                   -- typed bucket, e.g. decision | fact | preference
+      target            TEXT,                   -- optional subject/scope this memory targets
+      last_referenced   INTEGER,               -- last time memory was referenced by recall (epoch s)
+      source_turn       INTEGER                -- conversation turn that produced this memory
     );
     CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo);
 
@@ -447,6 +549,12 @@ function initSchema(db: DatabaseSync): void {
   // databases created by an older version — otherwise repoStats()/upsert crash
   // with "no such column" and the extension fails to load. Additive only.
   ensureColumn(db, "context_chunks", "original_token_estimate", "INTEGER");
+  // S20 memory-RAG extension: additive columns for auto-review ops. Idempotent —
+  // only alters DBs created by an older version that lack these columns.
+  ensureColumn(db, "memories", "category", "TEXT");
+  ensureColumn(db, "memories", "target", "TEXT");
+  ensureColumn(db, "memories", "last_referenced", "INTEGER");
+  ensureColumn(db, "memories", "source_turn", "INTEGER");
   const v = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get() as
     | { value: string }
     | undefined;
@@ -613,11 +721,15 @@ export interface MemoryRecord {
   tags: string[];
   createdAt: number;
   lastRecalledAt: number | null;
+  category: string | null;
+  target: string | null;
+  lastReferenced: number | null;
+  sourceTurn: number | null;
 }
 
 /** Save a memory to the current repo's store. Returns the new row id. */
 export function addMemory(
-  memory: { kind?: string; content: string; tags?: string[] },
+  memory: { kind?: string; content: string; tags?: string[]; category?: string; target?: string; sourceTurn?: number },
   repo: string | null,
   stateDir: string = getStateDir(),
 ): number {
@@ -625,10 +737,19 @@ export function addMemory(
   const now = Math.floor(Date.now() / 1000);
   const res = db
     .prepare(
-      `INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at)
-       VALUES(?, ?, ?, ?, ?, NULL)`,
+      `INSERT INTO memories(repo, kind, content, tags, created_at, last_recalled_at, category, target, source_turn)
+       VALUES(?, ?, ?, ?, ?, NULL, ?, ?, ?)`,
     )
-    .run(repo ?? null, memory.kind ?? "note", memory.content, JSON.stringify(memory.tags ?? []), now);
+    .run(
+      repo ?? null,
+      memory.kind ?? "note",
+      memory.content,
+      JSON.stringify(memory.tags ?? []),
+      now,
+      memory.category ?? null,
+      memory.target ?? null,
+      memory.sourceTurn ?? null,
+    );
   return Number(res.lastInsertRowid);
 }
 
@@ -659,6 +780,58 @@ export function recallMemory(id: number, stateDir: string = getStateDir()): bool
   return res.changes > 0;
 }
 
+/** Mark a memory as referenced (updates last_referenced). Returns true if found. */
+export function referenceMemory(id: number, stateDir: string = getStateDir()): boolean {
+  const db = openStore(stateDir);
+  const now = Math.floor(Date.now() / 1000);
+  const res = db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(now, id);
+  return res.changes > 0;
+}
+
+/** Replace a memory's mutable fields by id. Returns true if a row was updated. */
+export function replaceMemory(
+  id: number,
+  patch: { kind?: string; content?: string; tags?: string[]; category?: string; target?: string; sourceTurn?: number },
+  stateDir: string = getStateDir(),
+): boolean {
+  const db = openStore(stateDir);
+  const res = db
+    .prepare(
+      `UPDATE memories
+       SET kind = COALESCE(?, kind),
+           content = COALESCE(?, content),
+           tags = COALESCE(?, tags),
+           category = COALESCE(?, category),
+           target = COALESCE(?, target),
+           source_turn = COALESCE(?, source_turn)
+       WHERE id = ?`,
+    )
+    .run(
+      patch.kind ?? null,
+      patch.content ?? null,
+      patch.tags ? JSON.stringify(patch.tags) : null,
+      "category" in patch ? (patch.category ?? null) : null,
+      "target" in patch ? (patch.target ?? null) : null,
+      "sourceTurn" in patch ? (patch.sourceTurn ?? null) : null,
+      id,
+    );
+  return res.changes > 0;
+}
+
+/** Remove a memory by id. Returns true if a row was deleted. */
+export function removeMemory(id: number, stateDir: string = getStateDir()): boolean {
+  const db = openStore(stateDir);
+  const res = db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+  return res.changes > 0;
+}
+
+/** Look up a single memory by id (or undefined). */
+export function getMemory(id: number, stateDir: string = getStateDir()): MemoryRecord | undefined {
+  const db = openStore(stateDir);
+  const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+  return row ? mapMemoryRow(row) : undefined;
+}
+
 function mapMemoryRow(row: any): MemoryRecord {
   return {
     id: row.id,
@@ -668,6 +841,10 @@ function mapMemoryRow(row: any): MemoryRecord {
     tags: row.tags ? JSON.parse(row.tags) : [],
     createdAt: row.created_at ?? 0,
     lastRecalledAt: row.last_recalled_at ?? null,
+    category: row.category ?? null,
+    target: row.target ?? null,
+    lastReferenced: row.last_referenced ?? null,
+    sourceTurn: row.source_turn ?? null,
   };
 }
 

package/src/store.ts

@@ -49,6 +49,9 @@ export function normalizeSessionId(sessionId: string | undefined | null): string
 export interface StoredCheckpoint {
   checkpointId: string;
   sessionId: string;
+  /** Source repo id (foreign stateDir) when this checkpoint came from a global
+   *  cross-repo index entry. Undefined for same-repo checkpoints. Spec S17.1. */
+  repoId?: string;
   summary: string;
   /** Compressed topic summary (extractive, ~2K tokens vs ~70K raw). */
   topicSummary?: string;

package/src/vectorStore.ts

@@ -51,6 +51,10 @@ import { migrateJsonToSqlite } from "./store/migrate.js";
 export interface SearchHit {
   checkpoint: StoredCheckpoint;
   score: number;
+  /** Source repo id (the foreign repo's stateDir) for cross-repo hits, set by
+   *  `searchAsync` so the recall block can label foreign checkpoints. Undefined
+   *  for same-repo hits (the default path). */
+  repoId?: string;
 }
 
 export interface AddInput {
@@ -326,6 +330,7 @@ export class VectorStore {
     const checkpoint: StoredCheckpoint = {
       checkpointId,
       sessionId,
+      repoId: this.repoId,
       summary: input.summary,
       topicSummary: input.topicSummary,
       summaryHash,
@@ -525,11 +530,15 @@ export class VectorStore {
     }
     // Hydrate each index hit from the authoritative node:sqlite store. repoId is
     // that repo's stateDir, so cross-repo hits resolve against their own store.
+    // Tag cross-repo hits with their source repoId so the recall block can label
+    // them ("from repo <name>"); same-repo hits stay unlabeled.
+    const selfRepo = this.repoId;
     const hydrated: SearchHit[] = [];
     for (const h of indexHits) {
       const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
       if (cp && cp.dedupStatus !== "removed") {
-        hydrated.push({ checkpoint: cp, score: h.score });
+        const crossRepo = opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;
+        hydrated.push({ checkpoint: cp, score: h.score, repoId: crossRepo ? h.repoId : undefined });
       }
     }
     if (hydrated.length === 0) return this.search(sid, query, k);

package/dist/extensions/openclaw-mega-compact.js

@@ -1,291 +0,0 @@
-/**
- * openclaw-mega-compact — OpenClaw plugin adapter for the pi-mega-compact engine.
- *
- * Wires the pi-agnostic Trident engine (src/) into OpenClaw's plugin lifecycle:
- *  - Registers a CompactionProvider that replaces the built-in summarizeInStages.
- *  - Exposes `mega_status` and `mega_recall` tools for on-demand inspection.
- *  - Hooks into `before_compaction` / `after_compaction` for diagnostics.
- *
- * Design constraints:
- *  - NO imports from `@earendil-works/pi-coding-agent` or pi-agent-core.
- *  - The engine core (src/) is pi-agnostic; this file is the sole OpenClaw boundary.
- *  - No network at runtime — everything is local (stores + extractive summarizer).
- */
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { compactSession, setDefaultStore, } from "../src/engine.js";
-import { recallAndInline } from "../src/recall.js";
-import { VectorStore } from "../src/vectorStore.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const PLUGIN_ID = "mega-compact";
-const PLUGIN_LABEL = "Mega Compact (Trident)";
-/** Default state directory for vector store persistence. */
-const STATE_DIR = process.env.MEGA_COMPACT_STATE_DIR ?? undefined;
-/** Minimum messages before we bother compacting. */
-const MIN_MESSAGES_FOR_COMPACT = 6;
-// ---------------------------------------------------------------------------
-// Message conversion — OpenClaw unknown[] → EngineMessage[]
-// ---------------------------------------------------------------------------
-/**
- * Best-effort conversion from OpenClaw's opaque message array to our
- * EngineMessage shape. OpenClaw messages are typed as `unknown[]` so we
- * handle whatever shape comes through gracefully.
- */
-function toEngineMessages(messages) {
-    return messages.map((msg) => {
-        if (!msg || typeof msg !== "object") {
-            // Primitive fallback — treat as custom text.
-            return {
-                role: "custom",
-                text: String(msg ?? ""),
-            };
-        }
-        const m = msg;
-        const role = typeof m.role === "string" ? m.role : "custom";
-        // Normalize role to one of our four engine roles.
-        let engineRole;
-        switch (role) {
-            case "user":
-                engineRole = "user";
-                break;
-            case "assistant":
-                engineRole = "assistant";
-                break;
-            case "tool":
-            case "function":
-                engineRole = "tool";
-                break;
-            default:
-                engineRole = "custom";
-                break;
-        }
-        // Extract text content from common message shapes.
-        const text = typeof m.content === "string"
-            ? m.content
-            : typeof m.text === "string"
-                ? m.text
-                : Array.isArray(m.content)
-                    ? m.content
-                        .filter((part) => part.type === "text" && typeof part.text === "string")
-                        .map((part) => part.text)
-                        .join("\n")
-                    : "";
-        // Preserve tool metadata when present.
-        const toolName = typeof m.name === "string"
-            ? m.name
-            : typeof m.toolName === "string"
-                ? m.toolName
-                : undefined;
-        const input = typeof m.input === "string"
-            ? m.input
-            : typeof m.arguments === "string"
-                ? m.arguments
-                : m.arguments !== undefined
-                    ? JSON.stringify(m.arguments)
-                    : undefined;
-        const output = typeof m.output === "string"
-            ? m.output
-            : engineRole === "tool" && typeof m.content === "string"
-                ? m.content
-                : undefined;
-        return { role: engineRole, text, toolName, input, output };
-    });
-}
-// ---------------------------------------------------------------------------
-// Compaction provider
-// ---------------------------------------------------------------------------
-function createCompactionProvider(store) {
-    return {
-        id: PLUGIN_ID,
-        label: PLUGIN_LABEL,
-        async summarize({ messages, signal, compressionRatio, }) {
-            // Abort check — bail early if the caller cancelled.
-            if (signal?.aborted) {
-                throw new DOMException("Aborted", "AbortError");
-            }
-            const engineMessages = toEngineMessages(messages);
-            // Nothing meaningful to compact.
-            if (engineMessages.length < MIN_MESSAGES_FOR_COMPACT) {
-                return "";
-            }
-            // Map compression ratio → keepFrom boundary.
-            // compressionRatio=0.5 means "compact the oldest 50%".
-            // Default to compacting the oldest half if not specified.
-            const ratio = compressionRatio ?? 0.5;
-            const keepFrom = Math.max(MIN_MESSAGES_FOR_COMPACT, Math.floor(engineMessages.length * (1 - ratio)));
-            // Abort check after conversion (conversion is cheap but check anyway).
-            if (signal?.aborted) {
-                throw new DOMException("Aborted", "AbortError");
-            }
-            const sessionId = `openclaw-${Date.now()}`;
-            const input = {
-                sessionId,
-                messages: engineMessages,
-                keepFrom,
-            };
-            const result = compactSession(input, store);
-            if (result.skipped) {
-                return "";
-            }
-            return result.summary;
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Plugin entry
-// ---------------------------------------------------------------------------
-export default definePluginEntry({
-    id: PLUGIN_ID,
-    name: "Mega Compact",
-    description: "Layered, local, vector-backed context compressor (Trident engine) for OpenClaw compaction.",
-    register(api) {
-        const logger = api.logger;
-        // Resolve state directory — prefer plugin config override.
-        const pluginCfg = (api.pluginConfig ?? {});
-        const stateDir = typeof pluginCfg.stateDir === "string" && pluginCfg.stateDir.length > 0
-            ? pluginCfg.stateDir
-            : STATE_DIR;
-        // Initialize vector store.
-        let store;
-        try {
-            store = new VectorStore({ stateDir });
-            setDefaultStore(store);
-            logger.info?.(`${PLUGIN_ID}: vector store initialized (stateDir=${stateDir ?? "default"})`);
-        }
-        catch (err) {
-            logger.error?.(`${PLUGIN_ID}: failed to init vector store:`, err);
-            return; // Hard bail — no point registering if store is broken.
-        }
-        // -----------------------------------------------------------------------
-        // Register compaction provider
-        // -----------------------------------------------------------------------
-        const provider = createCompactionProvider(store);
-        api.registerCompactionProvider(provider);
-        logger.info?.(`${PLUGIN_ID}: registered compaction provider "${provider.id}"`);
-        // -----------------------------------------------------------------------
-        // Hooks — before / after compaction diagnostics
-        // -----------------------------------------------------------------------
-        api.registerHook({
-            event: "before_compaction",
-            handler: async (ctx) => {
-                const msgCount = Array.isArray(ctx?.messages) ? ctx.messages.length : 0;
-                logger.info?.(`${PLUGIN_ID}: before_compaction — ${msgCount} messages in scope`);
-            },
-        });
-        api.registerHook({
-            event: "after_compaction",
-            handler: async (ctx) => {
-                const summaryLen = typeof ctx?.summary === "string" ? ctx.summary.length : 0;
-                logger.info?.(`${PLUGIN_ID}: after_compaction — summary ${summaryLen} chars`);
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Tool: mega_status
-        // -----------------------------------------------------------------------
-        api.registerTool({
-            name: "mega_status",
-            description: "Show the current status of the mega-compact engine: vector store stats, checkpoint count, and recent compaction activity.",
-            parameters: {
-                type: "object",
-                properties: {
-                    sessionId: {
-                        type: "string",
-                        description: "Optional session ID to scope stats to.",
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const sessionId = args?.sessionId ?? "global";
-                try {
-                    const stats = store.stats(sessionId);
-                    const parts = [
-                        `**Mega Compact Status**`,
-                        `Session: ${sessionId}`,
-                        `Checkpoints: ${stats.checkpointCount}`,
-                        `Total tokens saved: ${stats.totalTokenEstimate}`,
-                        `Last checkpoint: ${stats.lastCheckpointId ?? "—"}`,
-                        `Injected count: ${stats.injectedCount}`,
-                        `Dedup hit rate: ${(stats.dedupHitRate * 100).toFixed(0)}%`,
-                    ];
-                    if (stats.lastSummary) {
-                        parts.push(`\nLast summary (truncated):\n  ${stats.lastSummary.slice(0, 120).replace(/\n/g, " ")}…`);
-                    }
-                    return { content: [{ type: "text", text: parts.join("\n") }] };
-                }
-                catch (err) {
-                    return {
-                        content: [{ type: "text", text: `Error reading mega-compact status: ${err}` }],
-                        isError: true,
-                    };
-                }
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Tool: mega_recall
-        // -----------------------------------------------------------------------
-        api.registerTool({
-            name: "mega_recall",
-            description: "Recall and inline relevant context from the mega-compact vector store for the current session.",
-            parameters: {
-                type: "object",
-                properties: {
-                    sessionId: {
-                        type: "string",
-                        description: "Session ID to recall context for.",
-                    },
-                    query: {
-                        type: "string",
-                        description: "Natural language query for relevant context.",
-                    },
-                    limit: {
-                        type: "number",
-                        description: "Max checkpoints to recall (default 3).",
-                    },
-                },
-                required: ["sessionId", "query"],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const { sessionId, query, limit } = args;
-                if (!sessionId || !query) {
-                    return {
-                        content: [{ type: "text", text: "Both `sessionId` and `query` are required." }],
-                        isError: true,
-                    };
-                }
-                try {
-                    const result = recallAndInline({ sessionId, query, limit: limit ?? 3, source: "command", skipInjected: false }, store);
-                    if (result.toInject.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No relevant context found in the mega-compact store." }],
-                        };
-                    }
-                    const parts = [
-                        `**Recalled ${result.toInject.length} checkpoint(s):**`,
-                        ...result.report,
-                        "",
-                        "---",
-                        result.block,
-                    ];
-                    return { content: [{ type: "text", text: parts.join("\n") }] };
-                }
-                catch (err) {
-                    return {
-                        content: [{ type: "text", text: `Error during mega-recall: ${err}` }],
-                        isError: true,
-                    };
-                }
-            },
-        });
-        // -----------------------------------------------------------------------
-        // Cleanup on shutdown
-        // -----------------------------------------------------------------------
-        api.on("shutdown", () => {
-            logger.info?.(`${PLUGIN_ID}: shutting down — clearing default store`);
-            setDefaultStore(undefined);
-        });
-        logger.info?.(`${PLUGIN_ID}: plugin registered (tools: mega_status, mega_recall)`);
-    },
-});