@unblocklabs/unblock-memory 0.3.6 → 0.3.8

package/dist/src/people-tools.js

@@ -1,7 +1,10 @@
 import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveAgentDir } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { renderPeopleWhisper } from "./people-hooks.js";
+import { nextPeopleRefinement } from "./people-refinement.js";
+import { PERSON_DOSSIER_SCHEMA } from "./people-store.js";
 import { createOpenClawSlackDirectory, syncSlackDirectory, } from "./slack-directory.js";
 const nonEmpty = Type.String({ pattern: "\\S", maxLength: 1000 });
 const inspectParameters = Type.Union([
@@ -40,13 +43,30 @@ const inspectParameters = Type.Union([
             description: "Maximum actionable todos to return.",
         })),
     }, { additionalProperties: false }),
+    Type.Object({
+        view: Type.Literal("refinement_next"),
+        evidenceLimit: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+    }, { additionalProperties: false }),
 ]);
 const updateParameters = Type.Union([
     Type.Object({
-        action: Type.Literal("set_policy"),
+        action: Type.Literal("set_injection"),
+        personId: nonEmpty,
+        enabled: Type.Boolean(),
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("replace_dossier"),
+        personId: nonEmpty,
+        dossier: Type.Optional(PERSON_DOSSIER_SCHEMA),
+        consumedEvidenceLocators: Type.Optional(Type.Array(Type.String({ pattern: "^session:.+:event:\\d+$", maxLength: 1000 }), {
+            minItems: 1,
+            maxItems: 50,
+            uniqueItems: true,
+        })),
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("delete_dossier"),
         personId: nonEmpty,
-        refinementEnabled: Type.Optional(Type.Boolean()),
-        injectionEnabled: Type.Optional(Type.Boolean()),
     }, { additionalProperties: false }),
     Type.Object({
         action: Type.Literal("set_company"),
@@ -74,7 +94,7 @@ const syncParameters = Type.Object({
 }, { additionalProperties: false });
 function context(ctx) {
     const cfg = ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config;
-    return cfg && ctx.agentId ? { agentId: ctx.agentId } : undefined;
+    return cfg && ctx.agentId ? { agentId: ctx.agentId, cfg } : undefined;
 }
 function personView(stores, agentId, selector, maxChars) {
     const store = stores.get(agentId);
@@ -99,18 +119,35 @@ function personView(stores, agentId, selector, maxChars) {
 }
 function createInspectTool(stores, config, ctx) {
     const active = context(ctx);
-    if (!active || ctx.senderIsOwner !== true)
+    if (!active)
         return null;
     return {
         name: "memory_people_inspect",
         label: "Inspect People Memory",
-        description: "Inspect one person by PeopleSQL personId or exact Slack identity, or list bounded actionable people todos.",
+        description: "Inspect a person, list actionable people todos, or read the next person's unseen interaction evidence for dossier refinement.",
         parameters: inspectParameters,
         async execute(_toolCallId, raw) {
             const input = Value.Parse(inspectParameters, raw);
             if (input.view === "person") {
                 return jsonResult(personView(stores, active.agentId, input, config.whisperer.maxChars));
             }
+            if (input.view === "refinement_next") {
+                try {
+                    const refinement = nextPeopleRefinement({
+                        store: stores.get(active.agentId),
+                        agentId: active.agentId,
+                        agentDatabasePath: `${resolveAgentDir(active.cfg, active.agentId)}/openclaw-agent.sqlite`,
+                        evidenceLimit: input.evidenceLimit,
+                    });
+                    return jsonResult(refinement ? { status: "ok", refinement } : { status: "empty" });
+                }
+                catch (error) {
+                    return jsonResult({
+                        status: "unavailable",
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             return jsonResult({
                 status: "ok",
                 todos: stores.get(active.agentId).listTodos(input.limit ?? 20),
@@ -120,27 +157,40 @@ function createInspectTool(stores, config, ctx) {
 }
 function createUpdateTool(stores, ctx) {
     const active = context(ctx);
-    if (!active || ctx.senderIsOwner !== true)
+    if (!active)
         return null;
     return {
         name: "memory_people_update",
         label: "Update People Memory",
-        description: "Apply one validated people policy, company, todo, deletion, or restoration action.",
+        description: "Update a dossier, one person's injection preference, company, todo, or person status.",
         parameters: updateParameters,
         async execute(_toolCallId, raw) {
-            if (ctx.senderIsOwner !== true)
-                return jsonResult({ status: "forbidden", error: "owner authorization required" });
             const input = Value.Parse(updateParameters, raw);
             const store = stores.get(active.agentId);
-            if (input.action === "set_policy") {
-                if (input.refinementEnabled === undefined && input.injectionEnabled === undefined) {
+            if (input.action === "set_injection") {
+                const person = store.setInjection(input.personId, input.enabled);
+                return jsonResult(person ? { status: "ok", person } : { status: "not_found" });
+            }
+            if (input.action === "replace_dossier") {
+                if (input.dossier === undefined && input.consumedEvidenceLocators === undefined) {
                     return jsonResult({
                         status: "invalid",
-                        error: "set_policy requires at least one policy value",
+                        error: "replace_dossier requires a dossier or consumed evidence locators",
                     });
                 }
-                const person = store.setPolicies(input.personId, input);
-                return jsonResult(person ? { status: "ok", person } : { status: "not_found" });
+                try {
+                    const dossier = store.replaceDossier(input.personId, input.dossier, input.consumedEvidenceLocators);
+                    return jsonResult({ status: "ok", dossier });
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message.startsWith("person not found:")) {
+                        return jsonResult({ status: "not_found" });
+                    }
+                    throw error;
+                }
+            }
+            if (input.action === "delete_dossier") {
+                return jsonResult(store.deleteDossier(input.personId) ? { status: "ok" } : { status: "not_found" });
             }
             if (input.action === "set_company") {
                 const company = store.setCompany(input.personId, {
@@ -165,7 +215,7 @@ function createUpdateTool(stores, ctx) {
 }
 function createSyncTool(stores, reader, ctx) {
     const active = context(ctx);
-    if (!active || ctx.senderIsOwner !== true)
+    if (!active)
         return null;
     return {
         name: "memory_people_sync",
@@ -174,8 +224,6 @@ function createSyncTool(stores, reader, ctx) {
         parameters: syncParameters,
         async execute(_toolCallId, raw) {
             const input = Value.Parse(syncParameters, raw);
-            if (ctx.senderIsOwner !== true)
-                return jsonResult({ status: "forbidden", error: "owner authorization required" });
             try {
                 return jsonResult(await syncSlackDirectory({
                     store: stores.get(active.agentId),
@@ -196,11 +244,9 @@ function createSyncTool(stores, reader, ctx) {
 export function registerPeopleTools(api, stores, config, directoryReader) {
     api.registerTool((ctx) => createInspectTool(stores, config, ctx), {
         names: ["memory_people_inspect"],
-        optional: true,
     });
     api.registerTool((ctx) => createUpdateTool(stores, ctx), {
         names: ["memory_people_update"],
-        optional: true,
     });
     api.registerTool((ctx) => createSyncTool(stores, directoryReader ??
         createOpenClawSlackDirectory({

package/dist/src/plugin.js

@@ -2,7 +2,6 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveConfig } from "./config.js";
-import { registerPeopleCli } from "./people-cli.js";
 import { registerPeopleHooks } from "./people-hooks.js";
 import { PeopleStores } from "./people-store.js";
 import { registerPeopleTools } from "./people-tools.js";
@@ -386,7 +385,6 @@ export function resolveFlushPlan(params = {}) {
 }
 export function registerUnblockMemory(api) {
     const config = resolveConfig(api.pluginConfig);
-    registerPeopleCli(api, config.people);
     if (api.registrationMode === "cli-metadata")
         return;
     const runtime = new QmdMemoryRuntime(config.corpora, {

package/openclaw.plugin.json

@@ -1,18 +1,11 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": false },
   "skills": ["./skills"],
-  "cliCommands": [
-    {
-      "name": "unblock-memory",
-      "description": "Unblock Memory administration",
-      "hasSubcommands": true
-    }
-  ],
   "contracts": {
     "tools": [
       "memory_search",
@@ -37,8 +30,8 @@
     "memory_fetch_cluster": { "replaySafe": true },
     "memory_list_maintenance_tasks": { "replaySafe": true },
     "memory_update_maintenance_task": { "sideEffecting": true },
-    "memory_people_inspect": { "replaySafe": true, "optional": true },
-    "memory_people_update": { "sideEffecting": true, "optional": true },
+    "memory_people_inspect": { "replaySafe": true },
+    "memory_people_update": { "sideEffecting": true },
     "memory_people_sync": { "sideEffecting": true, "optional": true }
   },
   "uiHints": {
@@ -147,11 +140,11 @@
           "enabled": { "type": "boolean", "default": false },
           "refinement": {
             "type": "object",
+            "description": "Deprecated compatibility field; accepted but ignored.",
             "additionalProperties": false,
             "properties": {
-              "maxPeoplePerRun": { "type": "integer", "minimum": 1, "maximum": 50, "default": 10 }
-            },
-            "default": { "maxPeoplePerRun": 10 }
+              "maxPeoplePerRun": { "type": "integer", "minimum": 1, "maximum": 50 }
+            }
           },
           "whisperer": {
             "type": "object",
@@ -173,7 +166,6 @@
         },
         "default": {
           "enabled": false,
-          "refinement": { "maxPeoplePerRun": 10 },
           "whisperer": { "enabled": false, "maxChars": 1200 },
           "todos": { "maxOpen": 1000 }
         }

package/package.json

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

package/dist/src/people-cli.d.ts

@@ -1,4 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
-import type { UnblockMemoryConfig } from "./config.js";
-import { type PeopleRefinementRunner } from "./people-refinement.js";
-export declare function registerPeopleCli(api: OpenClawPluginApi, config: UnblockMemoryConfig["people"], runner?: PeopleRefinementRunner): void;

package/dist/src/people-cli.js

@@ -1,47 +0,0 @@
-import { join } from "node:path";
-import { resolveAgentDir } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
-import { PeopleStores } from "./people-store.js";
-import { codexPeopleRefinementRunner, refinePeople, } from "./people-refinement.js";
-export function registerPeopleCli(api, config, runner = codexPeopleRefinementRunner) {
-    api.registerCli(({ program, config: openClawConfig }) => {
-        const root = program.command("unblock-memory").description("Unblock Memory administration");
-        const people = root.command("people").description("Maintain the agent-local people store");
-        people
-            .command("refine")
-            .description("Refine stale enabled people with Codex")
-            .requiredOption("--agent <id>", "Agent id")
-            .action(async (options) => {
-            const agentId = options.agent.trim();
-            if (!agentId)
-                throw new Error("--agent must be a non-empty string");
-            if (!config.enabled)
-                throw new Error("PeopleSQL is disabled");
-            const stores = new PeopleStores({
-                maxOpenTodos: config.todos.maxOpen,
-                maxBlurbChars: config.whisperer.maxChars,
-            });
-            try {
-                const summary = await refinePeople({
-                    store: stores.get(agentId),
-                    agentId,
-                    agentDatabasePath: join(resolveAgentDir(openClawConfig, agentId), "openclaw-agent.sqlite"),
-                    candidateLimit: config.refinement.maxPeoplePerRun,
-                    maxBlurbChars: config.whisperer.maxChars,
-                    runner,
-                });
-                process.stdout.write(`${JSON.stringify(summary)}\n`);
-            }
-            finally {
-                stores.closeAll();
-            }
-        });
-    }, {
-        descriptors: [
-            {
-                name: "unblock-memory",
-                description: "Unblock Memory administration",
-                hasSubcommands: true,
-            },
-        ],
-    });
-}