@unblocklabs/unblock-memory 0.3.28 → 0.3.29

package/dist/src/agent-transcript.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseSync } from "node:sqlite";
+/** The OpenClaw agent database versions whose transcript layout we read. */
+export declare function agentTranscriptSchemaVersion(db: DatabaseSync, errorMessage?: string): number;
+export declare function assertAgentTranscriptIdentity(db: DatabaseSync, agentId: string, version: number, errorMessage?: string): void;
+export declare function assertAgentTranscriptSchema(db: DatabaseSync, agentId: string, errorMessage?: string): void;
+export declare const ACTIVE_EVENTS_FROM = "FROM session_transcript_active_events a\n  JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq";
+export declare const ACTIVE_EVENT_COUNT_SQL = "SELECT COUNT(*) n,COALESCE(SUM(length(e.event_json)),0) bytes\n  FROM session_transcript_active_events a\n  JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq WHERE a.session_id=?";
+export declare const ACTIVE_EVENT_ROWS_SQL = "SELECT e.seq,e.event_json eventJson,e.created_at createdAt\n  FROM session_transcript_active_events a\n  JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq WHERE a.session_id=? ORDER BY a.active_position";

package/dist/src/agent-transcript.js

@@ -0,0 +1,29 @@
+/** The OpenClaw agent database versions whose transcript layout we read. */
+export function agentTranscriptSchemaVersion(db, errorMessage) {
+    const version = db.prepare("PRAGMA user_version").get()?.user_version;
+    if (typeof version !== "number" || ![17, 18, 19].includes(version)) {
+        throw new Error(errorMessage ?? "unsupported OpenClaw agent database schema: expected one of 17, 18, 19, " +
+            `found ${String(version ?? "unknown")}`);
+    }
+    return version;
+}
+export function assertAgentTranscriptIdentity(db, agentId, version, errorMessage) {
+    const fail = (message) => { throw new Error(errorMessage ?? message); };
+    const meta = db.prepare("SELECT role, schema_version AS schemaVersion, agent_id AS agentId " +
+        "FROM schema_meta WHERE meta_key = 'primary' LIMIT 1").get();
+    if (meta?.role !== "agent" || meta.schemaVersion !== version) {
+        fail("unsupported OpenClaw agent database primary schema metadata");
+    }
+    if (meta?.agentId !== agentId) {
+        fail(`OpenClaw agent database belongs to ${String(meta?.agentId)}, not ${agentId}`);
+    }
+}
+export function assertAgentTranscriptSchema(db, agentId, errorMessage) {
+    assertAgentTranscriptIdentity(db, agentId, agentTranscriptSchemaVersion(db, errorMessage), errorMessage);
+}
+export const ACTIVE_EVENTS_FROM = `FROM session_transcript_active_events a
+  JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq`;
+export const ACTIVE_EVENT_COUNT_SQL = `SELECT COUNT(*) n,COALESCE(SUM(length(e.event_json)),0) bytes
+  ${ACTIVE_EVENTS_FROM} WHERE a.session_id=?`;
+export const ACTIVE_EVENT_ROWS_SQL = `SELECT e.seq,e.event_json eventJson,e.created_at createdAt
+  ${ACTIVE_EVENTS_FROM} WHERE a.session_id=? ORDER BY a.active_position`;

package/dist/src/date-option.d.ts

@@ -0,0 +1 @@
+export declare function dateOption(value: string | undefined, fallback: number): number;

package/dist/src/date-option.js

@@ -0,0 +1,8 @@
+export function dateOption(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
+        throw new Error("Dates must be valid YYYY-MM-DD UTC dates");
+    }
+    return Date.parse(value);
+}

package/dist/src/manager.js

@@ -487,50 +487,43 @@ export class QmdMemoryManager {
             .filter((source) => selected.has(source.corpus))
             .map((source) => source.collection);
     }
+    async #updateAndEmbed(store, collection, force) {
+        const update = await store.update({ collections: collection ? [collection] : [] });
+        this.#cleanupRemovedDocuments?.(update.updated + update.removed);
+        const analysisStore = store;
+        const changed = update.indexed + update.updated + update.removed > 0 || update.needsEmbedding > 0;
+        if ((changed || force) && analysisStore.internal)
+            markMemoryAnalysisStale(analysisStore.internal.db);
+        const embed = await store.embed({
+            ...(collection ? { collection } : {}),
+            force,
+            chunkStrategy: "semantic",
+        });
+        this.#recordEmbedding(embed);
+        const chunksEmbedded = completedEmbeddingCount(embed);
+        if (!changed && !force && chunksEmbedded > 0 && analysisStore.internal) {
+            markMemoryAnalysisStale(analysisStore.internal.db);
+        }
+        return chunksEmbedded;
+    }
+    async #refreshIndexStatus(store) {
+        const status = await store.getStatus();
+        const collections = await store.listCollections();
+        this.#files = collections.reduce((total, collection) => total + collection.active_count, 0);
+        this.#dirty = status.needsEmbedding > 0;
+    }
     sync(params) {
         const run = async () => {
             const store = await this.#getStore();
             this.#dirty = true;
-            const analysisStore = store;
             const collections = this.#qmdSources().filter((source) => source.kind !== "sessions");
-            let analysisMarkedStale = false;
-            const markAnalysisStale = () => {
-                if (analysisMarkedStale || !analysisStore.internal)
-                    return;
-                markMemoryAnalysisStale(analysisStore.internal.db);
-                analysisMarkedStale = true;
-            };
             if (collections.length === 0) {
-                const update = await store.update({ collections: [] });
-                this.#cleanupRemovedDocuments?.(update.updated + update.removed);
-                if (update.indexed + update.updated + update.removed > 0 ||
-                    update.needsEmbedding > 0 || params?.force === true) {
-                    markAnalysisStale();
-                }
-                const embed = await store.embed({ force: params?.force, chunkStrategy: "semantic" });
-                this.#recordEmbedding(embed);
-                if (completedEmbeddingCount(embed) > 0)
-                    markAnalysisStale();
+                await this.#updateAndEmbed(store, undefined, params?.force);
             }
             for (const source of collections) {
-                const update = await store.update({ collections: [source.collection] });
-                this.#cleanupRemovedDocuments?.(update.updated + update.removed);
-                const changed = update.indexed + update.updated + update.removed > 0 || update.needsEmbedding > 0;
-                if (changed || params?.force === true)
-                    markAnalysisStale();
-                const embed = await store.embed({
-                    collection: source.collection,
-                    force: params?.force,
-                    chunkStrategy: "semantic",
-                });
-                this.#recordEmbedding(embed);
-                if (completedEmbeddingCount(embed) > 0)
-                    markAnalysisStale();
+                await this.#updateAndEmbed(store, source.collection, params?.force);
             }
-            const status = await store.getStatus();
-            const indexedCollections = await store.listCollections();
-            this.#files = indexedCollections.reduce((total, collection) => total + collection.active_count, 0);
-            this.#dirty = status.needsEmbedding > 0;
+            await this.#refreshIndexStatus(store);
         };
         return this.#enqueue(run);
     }
@@ -548,24 +541,7 @@ export class QmdMemoryManager {
                 index: async () => {
                     onPhase?.("indexing");
                     const store = await this.#getStore();
-                    const update = await store.update({ collections: [sessions.collection] });
-                    this.#cleanupRemovedDocuments?.(update.updated + update.removed);
-                    const analysisStore = store;
-                    const invalidatesAnalysis = update.indexed + update.updated + update.removed > 0 ||
-                        update.needsEmbedding > 0;
-                    if (invalidatesAnalysis && analysisStore.internal) {
-                        markMemoryAnalysisStale(analysisStore.internal.db);
-                    }
-                    const embed = await store.embed({
-                        collection: sessions.collection,
-                        chunkStrategy: "semantic",
-                    });
-                    const chunksEmbedded = completedEmbeddingCount(embed);
-                    this.#recordEmbedding(embed);
-                    if (!invalidatesAnalysis && chunksEmbedded > 0 && analysisStore.internal) {
-                        markMemoryAnalysisStale(analysisStore.internal.db);
-                    }
-                    return chunksEmbedded;
+                    return this.#updateAndEmbed(store, sessions.collection);
                 },
             });
             this.#sessionMetadata = sessionMetadataByPath(synced.manifest);
@@ -573,10 +549,7 @@ export class QmdMemoryManager {
             if (synced.result.skipReason)
                 return synced.result;
             const store = await this.#getStore();
-            const status = await store.getStatus();
-            const collections = await store.listCollections();
-            this.#files = collections.reduce((total, collection) => total + collection.active_count, 0);
-            this.#dirty = status.needsEmbedding > 0;
+            await this.#refreshIndexStatus(store);
             return synced.result;
         });
     }

package/dist/src/memory-whisperer.js

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
-import { buildSkillWhispererQuery } from "./skill-whisperer.js";
 import { judgeTypeSafeMemories } from "./typesafe.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
-import { memoryConversation } from "./whisperer-context.js";
+import { buildSkillWhispererQuery, memoryConversation } from "./whisperer-context.js";
 import { complementaryIndices, reviewMemoryRedundancy } from "./typesafe-review.js";
 import { MlxQueryGenerator, queryConversation } from "./mlx-query.js";
 import { judgeTrainingInput, TRAINING_GATE_THRESHOLD } from "./training-gate.js";

package/dist/src/response-episodes.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
+import { ACTIVE_EVENT_COUNT_SQL, ACTIVE_EVENT_ROWS_SQL, assertAgentTranscriptSchema } from "./agent-transcript.js";
 import { messageText } from "./whisperer-context.js";
 import { responseUserText } from "./response-text.js";
 export const RESPONSE_EXTRACTOR_VERSION = 5;
@@ -182,11 +183,7 @@ export class ResponseTranscriptReader {
         this.#db = new DatabaseSync(path, { readOnly: true });
         try {
             this.#db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000");
-            const version = this.#db.prepare("PRAGMA user_version").get()?.user_version;
-            const meta = this.#db.prepare("SELECT role,agent_id,schema_version FROM schema_meta WHERE meta_key='primary'").get();
-            if (![17, 18, 19].includes(Number(version)) || meta?.role !== "agent" || meta.agent_id !== agentId || meta.schema_version !== version) {
-                throw new Error("Unsupported response-audit transcript schema or agent");
-            }
+            assertAgentTranscriptSchema(this.#db, agentId, "Unsupported response-audit transcript schema or agent");
         }
         catch (error) {
             this.#db.close();
@@ -219,14 +216,10 @@ export class ResponseTranscriptReader {
                 return null;
             const session = { sessionId, accountId: String(window.accountId),
                 conversationId: String(window.conversationId), chatType: String(window.chatType) };
-            const count = this.#db.prepare(`SELECT COUNT(*) n,COALESCE(SUM(length(e.event_json)),0) bytes
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=?`).get(session.sessionId);
+            const count = this.#db.prepare(ACTIVE_EVENT_COUNT_SQL).get(session.sessionId);
             if (Number(count.n) > MAX_EVENTS || Number(count.bytes) > MAX_SESSION_BYTES)
                 return undefined;
-            const rows = this.#db.prepare(`SELECT e.seq,e.event_json eventJson,e.created_at createdAt
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=? ORDER BY a.active_position`).all(session.sessionId);
+            const rows = this.#db.prepare(ACTIVE_EVENT_ROWS_SQL).all(session.sessionId);
             // Exact active content catches in-place edits and branch changes even when writer
             // watermarks are absent. Raw text is never retained in the checkpoint database.
             const revision = hash([RESPONSE_EXTRACTOR_VERSION, session, config.historyMessages, [...config.senderIds].sort(), rows]);

package/dist/src/response-runtime.js

@@ -6,14 +6,7 @@ import { normalizeAgentIdStrict } from "openclaw/plugin-sdk/routing";
 import { resolveSources } from "./sources.js";
 import { auditResponses, responseCohort } from "./response-audit.js";
 import { ResponseAuditStore } from "./response-store.js";
-function dateOption(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
-        throw new Error("Dates must be valid YYYY-MM-DD UTC dates");
-    }
-    return Date.parse(value);
-}
+import { dateOption } from "./date-option.js";
 export function registerResponseAudit(api, config) {
     const options = (cfg, id) => {
         const normalized = normalizeAgentIdStrict(id);

package/dist/src/session-sync.js

@@ -3,10 +3,10 @@ import { existsSync, lstatSync, readFileSync, statSync } from "node:fs";
 import { chmod, mkdir, readFile, rename, unlink, utimes, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { ACTIVE_EVENTS_FROM, agentTranscriptSchemaVersion, assertAgentTranscriptIdentity } from "./agent-transcript.js";
 import { projectSessionDocument, sessionDocumentPath, } from "./session-projector.js";
 const MANIFEST_VERSION = 1;
 export const PROJECTOR_VERSION = 7;
-const SUPPORTED_SCHEMA_VERSIONS = new Set([17, 18, 19]);
 // Source lives in src/, published code in dist/src/. Read our own pinned dependency
 // metadata, not QMD internals (which may also be substituted by runtime inspectors).
 const sourcePackage = new URL("../package.json", import.meta.url);
@@ -76,12 +76,7 @@ function projectionPath(outputDir, documentPath) {
     return target;
 }
 function assertSchema(db, expectedAgentId) {
-    const pragma = db.prepare("PRAGMA user_version").get();
-    const schemaVersion = pragma?.user_version;
-    if (typeof schemaVersion !== "number" || !SUPPORTED_SCHEMA_VERSIONS.has(schemaVersion)) {
-        throw new Error("unsupported OpenClaw agent database schema: expected one of 17, 18, 19, " +
-            `found ${String(schemaVersion ?? "unknown")}`);
-    }
+    const version = agentTranscriptSchemaVersion(db);
     for (const [table, required] of Object.entries(REQUIRED_COLUMNS)) {
         const columns = new Set(db.prepare(`PRAGMA table_info(${table})`).all()
             .map((column) => column.name));
@@ -89,14 +84,7 @@ function assertSchema(db, expectedAgentId) {
         if (missing)
             throw new Error(`unsupported OpenClaw agent database: missing ${table}.${missing}`);
     }
-    const meta = db.prepare("SELECT role, schema_version AS schemaVersion, agent_id AS agentId " +
-        "FROM schema_meta WHERE meta_key = 'primary' LIMIT 1").get();
-    if (meta?.role !== "agent" || meta.schemaVersion !== schemaVersion) {
-        throw new Error("unsupported OpenClaw agent database primary schema metadata");
-    }
-    if (meta.agentId !== expectedAgentId) {
-        throw new Error(`OpenClaw agent database belongs to ${String(meta.agentId)}, not ${expectedAgentId}`);
-    }
+    assertAgentTranscriptIdentity(db, expectedAgentId, version);
 }
 function readSnapshot(params) {
     const db = new DatabaseSync(params.databasePath, { readOnly: true });
@@ -129,13 +117,11 @@ function readSnapshot(params) {
       ORDER BY window.created_at, window.session_id
     `).all(...params.chatTypes);
         const readEvents = db.prepare(`
-      SELECT active.session_id AS sessionId, event.event_json AS eventJson,
-             event.created_at AS createdAt
-      FROM session_transcript_active_events AS active
-      JOIN transcript_events AS event
-        ON event.session_id = active.session_id AND event.seq = active.event_seq
-      WHERE active.session_id = ?
-      ORDER BY active.active_position
+      SELECT a.session_id AS sessionId, e.event_json AS eventJson,
+             e.created_at AS createdAt
+      ${ACTIVE_EVENTS_FROM}
+      WHERE a.session_id = ?
+      ORDER BY a.active_position
     `);
         const events = new Map();
         const changed = new Set();

package/dist/src/skill-whisperer.d.ts

@@ -12,6 +12,5 @@ type SkillWhispererRuntime = {
         agentId: string;
     }, path: string): string | undefined;
 };
-export declare function buildSkillWhispererQuery(prompt: string, messages: readonly unknown[], historyMessages: number): string;
 export declare function registerSkillWhisperer(api: OpenClawPluginApi, runtime: SkillWhispererRuntime, config: UnblockMemoryConfig["skillWhisperer"], typesafe: UnblockMemoryConfig["typesafe"], diagnostics?: WhispererDiagnostics): Parameters<typeof api.on<"before_prompt_build">>[1] | undefined;
 export {};

package/dist/src/skill-whisperer.js

@@ -1,21 +1,13 @@
 import { basename } from "node:path";
 import { selectTypeSafeSkill } from "./typesafe.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
-import { messageText } from "./whisperer-context.js";
+import { buildSkillWhispererQuery, messageText } from "./whisperer-context.js";
 const CANDIDATE_LIMIT = 10;
 const MAX_QUERY_CHARS = 12_000;
 const TYPESAFE_CANDIDATE_LIMIT = 3;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-export function buildSkillWhispererQuery(prompt, messages, historyMessages) {
-    const availableHistory = messages.flatMap((message) => {
-        const parsed = messageText(message);
-        return parsed ? [`${parsed.role}: ${parsed.text}`] : [];
-    });
-    const history = historyMessages === 0 ? [] : availableHistory.slice(-historyMessages);
-    return [...history, `user: ${prompt.trim()}`].join("\n\n").slice(-MAX_QUERY_CHARS);
-}
 function typeSafeConversation(prompt, messages, historyMessages) {
     const currentRequest = prompt.trim().slice(-MAX_QUERY_CHARS);
     let remaining = MAX_QUERY_CHARS - currentRequest.length;

package/dist/src/training-input.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
+import { ACTIVE_EVENT_COUNT_SQL, ACTIVE_EVENT_ROWS_SQL, assertAgentTranscriptSchema } from "./agent-transcript.js";
 import { messageText } from "./whisperer-context.js";
 import { conversationUserText } from "./response-text.js";
 // Identical serialized inputs keep their checkpoints when eligibility broadens.
@@ -133,11 +134,7 @@ export class TrainingTranscriptReader {
         this.#db = new DatabaseSync(path, { readOnly: true });
         try {
             this.#db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000");
-            const version = this.#db.prepare("PRAGMA user_version").get()?.user_version;
-            const meta = this.#db.prepare("SELECT role,agent_id,schema_version FROM schema_meta WHERE meta_key='primary'").get();
-            if (![17, 18, 19].includes(Number(version)) || meta?.role !== "agent" || meta.agent_id !== agentId || meta.schema_version !== version) {
-                throw new Error("Unsupported training transcript schema or agent");
-            }
+            assertAgentTranscriptSchema(this.#db, agentId, "Unsupported training transcript schema or agent");
             const columns = this.#db.prepare("PRAGMA table_info(session_windows)").all().map(c => c.name);
             this.#lineage = ["parent_session_key", "spawned_by", "plugin_owner_id", "hook_external_content_source"].every(c => columns.includes(c));
         }
@@ -160,14 +157,10 @@ export class TrainingTranscriptReader {
                 /:(?:cron|subagent|heartbeat|hook)(?::|$)/i.test(String(session.session_key)) ||
                 session.parent_session_key || session.spawned_by || session.plugin_owner_id || session.hook_external_content_source)
                 return null;
-            const size = this.#db.prepare(`SELECT COUNT(*) n,COALESCE(SUM(length(e.event_json)),0) bytes
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=?`).get(sessionId);
+            const size = this.#db.prepare(ACTIVE_EVENT_COUNT_SQL).get(sessionId);
             if (Number(size.n) > 50_000 || Number(size.bytes) > 32_000_000)
                 return { oversized: true };
-            const rows = this.#db.prepare(`SELECT e.seq,e.event_json eventJson,e.created_at createdAt
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=? ORDER BY a.active_position`).iterate(sessionId);
+            const rows = this.#db.prepare(ACTIVE_EVENT_ROWS_SQL).iterate(sessionId);
             return trainingExamples(rows);
         }
         finally {

package/dist/src/training-runtime.js

@@ -7,14 +7,7 @@ import { TrainingStore } from "./training-store.js";
 import { TRAINING_GATE_THRESHOLD } from "./training-gate.js";
 import { collectTraining, runTraining } from "./training.js";
 import { generateTrainingQueries, evaluateTrainingQueries, exportQueryTraining, TRAINING_EVALUATION_CONCURRENCY } from "./training-queries.js";
-function dateOption(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
-        throw new Error("Dates must be valid YYYY-MM-DD UTC dates");
-    }
-    return Date.parse(value);
-}
+import { dateOption } from "./date-option.js";
 function thresholdOption(value) {
     const result = Number(value);
     if (!value.trim() || !Number.isFinite(result) || result < 0 || result > 1)

package/dist/src/whisperer-context.d.ts

@@ -3,6 +3,7 @@ export declare function messageText(message: unknown): {
     role: "user" | "assistant";
     text: string;
 } | undefined;
+export declare function buildSkillWhispererQuery(prompt: string, messages: readonly unknown[], historyMessages: number): string;
 export declare function memoryConversation(prompt: string, messages: readonly unknown[]): {
     currentRequest: string;
     history: {

package/dist/src/whisperer-context.js

@@ -1,3 +1,4 @@
+const MAX_SKILL_QUERY_CHARS = 12_000;
 /** Only visible user/assistant text; never system, tool, image, or thinking blocks. */
 export function messageText(message) {
     if (!message || typeof message !== "object" || !("role" in message) || !("content" in message) ||
@@ -10,6 +11,14 @@ export function messageText(message) {
         }).join("\n").trim() : "";
     return text ? { role: message.role, text } : undefined;
 }
+export function buildSkillWhispererQuery(prompt, messages, historyMessages) {
+    const availableHistory = messages.flatMap(message => {
+        const parsed = messageText(message);
+        return parsed ? [`${parsed.role}: ${parsed.text}`] : [];
+    });
+    const history = historyMessages === 0 ? [] : availableHistory.slice(-historyMessages);
+    return [...history, `user: ${prompt.trim()}`].join("\n\n").slice(-MAX_SKILL_QUERY_CHARS);
+}
 export function memoryConversation(prompt, messages) {
     const currentRequest = prompt.trim().slice(-16_000);
     let remaining = 16_000 - currentRequest.length;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",