@unblocklabs/unblock-memory 0.3.11 → 0.3.12

package/README.md

@@ -254,9 +254,20 @@ role-labeled, timestamped speaker messages; filtering metadata remains in the
 session manifest. The projected file modification time matches the session
 start time for meaningful chronological cluster reads. Session results include
 provider, chat type, conversation identity, and start time as an ISO 8601 timestamp. They
-participate in the same search and clustering index as file memory. This phase
-does not sync sessions at startup or on a schedule; refreshes are manual through
-`memory_sync_sessions`.
+participate in the same search and clustering index as file memory. The plugin
+automatically refreshes each configured agent's sessions every 15 minutes while
+the Gateway runs. Set `syncIntervalMinutes` on the `sessions` corpus to an integer
+from `1` to `1440`, or `0` for manual-only syncing. For example:
+
+```json
+{ "name": "sessions", "kind": "sessions", "syncIntervalMinutes": 15 }
+```
+
+The first refresh runs after one interval, not during startup. Restart the
+Gateway after changing the interval. Refreshes are incremental; an already-running
+sync is skipped, and failures are visible through `memory_sync_status` and retried
+at the next interval. `memory_sync_sessions` still provides an immediate manual
+refresh. Syncing and embedding run inside the Gateway process, without an LLM turn.
 
 Indexes live at `~/.openclaw/agents/<agentId>/unblock-memory/index.sqlite` (or the
 equivalent configured OpenClaw state directory). Durable agent-supplied event

package/dist/src/config.d.ts

@@ -15,6 +15,7 @@ type SessionCorpusConfig = {
     kind: "sessions";
     chatTypes: readonly ChatType[];
     maxExpandedTokens: number;
+    syncIntervalMinutes: number;
 };
 export type CorpusConfig = FileCorpusConfig | SkillCorpusConfig | SessionCorpusConfig;
 export declare const DEFAULT_CORPORA: readonly FileCorpusConfig[];

package/dist/src/config.js

@@ -61,7 +61,7 @@ function resolveCorpora(value) {
             return { name: "skills", kind: "skills", paths: corpus.paths.map((path) => path.trim()) };
         }
         if (corpus.kind === "sessions") {
-            assertOnlyKeys(corpus, ["name", "kind", "chatTypes", "maxExpandedTokens"], `corpora[${index}]`);
+            assertOnlyKeys(corpus, ["name", "kind", "chatTypes", "maxExpandedTokens", "syncIntervalMinutes"], `corpora[${index}]`);
             if (name !== "sessions") {
                 throw new Error('unblock-memory session corpus must be named "sessions"');
             }
@@ -71,8 +71,14 @@ function resolveCorpora(value) {
                 !chatTypes.every((chatType) => CHAT_TYPES.includes(chatType))) {
                 throw new Error(`unblock-memory corpus sessions chatTypes must contain channel, group, or direct`);
             }
+            const syncIntervalMinutes = corpus.syncIntervalMinutes ?? 15;
+            if (typeof syncIntervalMinutes !== "number" || !Number.isInteger(syncIntervalMinutes) ||
+                syncIntervalMinutes < 0 || syncIntervalMinutes > 1440) {
+                throw new Error("unblock-memory corpus sessions syncIntervalMinutes must be an integer between 0 and 1440");
+            }
             return {
                 name: "sessions",
+                syncIntervalMinutes,
                 kind: "sessions",
                 chatTypes: [...new Set(chatTypes)],
                 maxExpandedTokens: positiveInteger(corpus.maxExpandedTokens, DEFAULT_SESSION_MAX_EXPANDED_TOKENS, "corpus sessions maxExpandedTokens", MAX_SESSION_MAX_EXPANDED_TOKENS),

package/dist/src/plugin.js

@@ -403,6 +403,12 @@ export function registerUnblockMemory(api) {
         runtime,
     };
     api.registerMemoryCapability(capability);
+    if (config.corpora.some((corpus) => corpus.kind === "sessions" && corpus.syncIntervalMinutes > 0)) {
+        api.on("gateway_start", () => runtime.startSessionSyncSchedule(api.config, (error) => {
+            api.logger.warn(`unblock-memory scheduled session sync could not start: ${String(error)}`);
+        }));
+        api.on("gateway_stop", () => runtime.stopSessionSyncSchedule());
+    }
     if (config.people.enabled) {
         const peopleStores = new PeopleStores({
             maxOpenTodos: config.people.todos.maxOpen,

package/dist/src/runtime.d.ts

@@ -40,6 +40,8 @@ type StoredRunningSessionSync = Extract<StoredSessionSyncStatus, {
 export declare function recoverInterruptedSessionSync(directory: string, statusPath: string, stale: StoredRunningSessionSync): Promise<SessionSyncStatus>;
 export declare class QmdMemoryRuntime implements MemoryPluginRuntimeContract {
     #private;
+    startSessionSyncSchedule(cfg: OpenClawConfig, onError: (error: unknown) => void): void;
+    stopSessionSyncSchedule(): void;
     constructor(corpora: readonly CorpusConfig[], options?: {
         analysisExecutable?: string;
         keepEmbeddingModelWarm?: boolean;

package/dist/src/runtime.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { resolveAgentDir, resolveAgentWorkspaceDir, resolveStateDir, } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
-import { resolveAgentIdentity } from "openclaw/plugin-sdk/agent-runtime";
+import { listAgentIds, resolveAgentIdentity } from "openclaw/plugin-sdk/agent-runtime";
 import { QmdMemoryManager } from "./manager.js";
 import { resolveTimezone } from "./session-projector.js";
 import { resolveConfiguredSkillPath, resolveSessionSource, resolveSources } from "./sources.js";
@@ -68,6 +68,24 @@ export class QmdMemoryRuntime {
     #keepEmbeddingModelWarm;
     #stateRoot;
     #managers = new Map();
+    #sessionSyncTimer;
+    startSessionSyncSchedule(cfg, onError) {
+        this.stopSessionSyncSchedule();
+        const sessions = this.#corpora.find((corpus) => corpus.kind === "sessions");
+        if (!sessions?.syncIntervalMinutes)
+            return;
+        this.#sessionSyncTimer = setInterval(() => {
+            for (const agentId of listAgentIds(cfg)) {
+                void this.startSessionSync({ cfg, agentId }).catch(onError);
+            }
+        }, sessions.syncIntervalMinutes * 60_000);
+        this.#sessionSyncTimer.unref();
+    }
+    stopSessionSyncSchedule() {
+        if (this.#sessionSyncTimer)
+            clearInterval(this.#sessionSyncTimer);
+        this.#sessionSyncTimer = undefined;
+    }
     constructor(corpora, options = {}) {
         this.#corpora = corpora;
         this.#analysisExecutable = options.analysisExecutable;
@@ -186,6 +204,7 @@ export class QmdMemoryRuntime {
         await (await pending)?.close();
     }
     async closeAllMemorySearchManagers() {
+        this.stopSessionSyncSchedule();
         const managers = [...this.#managers.values()];
         this.#managers.clear();
         await Promise.all(managers.map(async (pending) => (await pending).close()));

package/openclaw.plugin.json

@@ -1,10 +1,10 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
-  "activation": { "onStartup": false },
+  "activation": { "onStartup": true },
   "skills": ["./skills"],
   "contracts": {
     "tools": [
@@ -94,6 +94,13 @@
               "properties": {
                 "name": { "const": "sessions" },
                 "kind": { "const": "sessions" },
+                "syncIntervalMinutes": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 1440,
+                  "default": 15,
+                  "description": "Refresh sessions every N minutes while the Gateway runs; 0 disables automatic sync. First refresh is after one interval."
+                },
                 "chatTypes": {
                   "type": "array",
                   "minItems": 1,

package/package.json

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