@unblocklabs/unblock-memory 0.3.3 → 0.3.4

package/dist/src/people-tools.js

@@ -0,0 +1,190 @@
+import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { renderPeopleWhisper } from "./people-hooks.js";
+import { openClawSlackDirectory, syncSlackDirectory, } from "./slack-directory.js";
+const nonEmpty = Type.String({ pattern: "\\S", maxLength: 1000 });
+const personSelector = Type.Union([
+    Type.Object({ view: Type.Literal("person"), personId: nonEmpty }, { additionalProperties: false }),
+    Type.Object({
+        view: Type.Literal("person"),
+        identity: Type.Object({
+            provider: Type.Literal("slack"),
+            accountScope: nonEmpty,
+            externalId: nonEmpty,
+        }, { additionalProperties: false }),
+    }, { additionalProperties: false }),
+]);
+const inspectParameters = Type.Union([
+    personSelector,
+    Type.Object({
+        view: Type.Literal("todos"),
+        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
+    }, { additionalProperties: false }),
+]);
+const updateParameters = Type.Union([
+    Type.Object({
+        action: Type.Literal("set_policy"),
+        personId: nonEmpty,
+        refinementEnabled: Type.Optional(Type.Boolean()),
+        injectionEnabled: Type.Optional(Type.Boolean()),
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("set_company"),
+        personId: nonEmpty,
+        companyName: Type.String({ pattern: "\\S", maxLength: 500 }),
+        primaryDomain: Type.Optional(Type.String({ pattern: "\\S", maxLength: 500 })),
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("resolve_todo"),
+        deduplicationKey: nonEmpty,
+        note: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("soft_delete_person"),
+        personId: nonEmpty,
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("restore_person"),
+        personId: nonEmpty,
+    }, { additionalProperties: false }),
+]);
+const syncParameters = Type.Object({
+    accountId: Type.String({ pattern: "\\S", maxLength: 200 }),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
+}, { additionalProperties: false });
+function context(ctx) {
+    const cfg = ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config;
+    return cfg && ctx.agentId ? { agentId: ctx.agentId } : undefined;
+}
+function personView(stores, agentId, selector, maxChars) {
+    const store = stores.get(agentId);
+    const person = "personId" in selector
+        ? store.getPerson(selector.personId)
+        : store.findPersonByIdentity(selector.identity.provider, selector.identity.accountScope, selector.identity.externalId);
+    if (!person)
+        return { status: "not_found" };
+    const dossier = store.getDossier(person.id);
+    const contribution = person.status === "active" && person.injectionEnabled && dossier
+        ? renderPeopleWhisper(dossier.dossier.blurb, maxChars)
+        : undefined;
+    return {
+        status: "ok",
+        person,
+        company: person.companyId ? store.getCompany(person.companyId) : undefined,
+        identities: store.listIdentities(person.id),
+        dossier,
+        injectionEligible: contribution !== undefined,
+        contribution,
+    };
+}
+function createInspectTool(stores, config, ctx) {
+    const active = context(ctx);
+    if (!active || ctx.senderIsOwner !== true)
+        return null;
+    return {
+        name: "memory_people_inspect",
+        label: "Inspect People Memory",
+        description: "Inspect one exact person or bounded actionable people todos.",
+        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));
+            }
+            return jsonResult({
+                status: "ok",
+                todos: stores.get(active.agentId).listTodos(input.limit ?? 20),
+            });
+        },
+    };
+}
+function createUpdateTool(stores, ctx) {
+    const active = context(ctx);
+    if (!active || ctx.senderIsOwner !== true)
+        return null;
+    return {
+        name: "memory_people_update",
+        label: "Update People Memory",
+        description: "Apply one validated people policy, company, todo, deletion, or restoration action.",
+        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) {
+                    return jsonResult({
+                        status: "invalid",
+                        error: "set_policy requires at least one policy value",
+                    });
+                }
+                const person = store.setPolicies(input.personId, input);
+                return jsonResult(person ? { status: "ok", person } : { status: "not_found" });
+            }
+            if (input.action === "set_company") {
+                const company = store.setCompany(input.personId, {
+                    name: input.companyName,
+                    primaryDomain: input.primaryDomain,
+                });
+                const person = store.getPerson(input.personId);
+                return jsonResult(company && person ? { status: "ok", company, person } : { status: "not_found" });
+            }
+            if (input.action === "resolve_todo") {
+                const todo = store.resolveTodoByKey(input.deduplicationKey, input.note);
+                return jsonResult(todo ? { status: "ok", todo } : { status: "not_found" });
+            }
+            if (input.action === "restore_person") {
+                const person = store.restorePerson(input.personId);
+                return jsonResult(person ? { status: "ok", person } : { status: "not_found" });
+            }
+            const person = store.softDeletePerson(input.personId);
+            return jsonResult(person ? { status: "ok", person } : { status: "not_found" });
+        },
+    };
+}
+function createSyncTool(stores, reader, ctx) {
+    const active = context(ctx);
+    if (!active || ctx.senderIsOwner !== true)
+        return null;
+    return {
+        name: "memory_people_sync",
+        label: "Sync Slack People",
+        description: "Manually enrich this agent's people store from one OpenClaw-authenticated Slack directory account.",
+        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),
+                    reader,
+                    accountId: input.accountId.trim(),
+                    limit: input.limit ?? 200,
+                }));
+            }
+            catch (error) {
+                return jsonResult({
+                    status: "unavailable",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    };
+}
+export function registerPeopleTools(api, stores, config, directoryReader = openClawSlackDirectory) {
+    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, ctx), {
+        names: ["memory_people_sync"],
+        optional: true,
+    });
+}

package/dist/src/plugin.js

@@ -2,6 +2,10 @@ 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";
 import { QmdMemoryRuntime } from "./runtime.js";
 import { registerSkillWhisperer } from "./skill-whisperer.js";
 function getContext(ctx) {
@@ -25,14 +29,14 @@ const searchParameters = Type.Object({
     query: Type.String({ pattern: "\\S" }),
     corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), { minItems: 1 })),
     sessionFilter: Type.Optional(Type.Object({
-        startedFrom: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$" })),
-        startedTo: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$" })),
+        startedFrom: Type.Optional(Type.String({
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$",
+        })),
+        startedTo: Type.Optional(Type.String({
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$",
+        })),
         provider: Type.Optional(Type.String({ pattern: "\\S" })),
-        chatType: Type.Optional(Type.Union([
-            Type.Literal("channel"),
-            Type.Literal("group"),
-            Type.Literal("direct"),
-        ])),
+        chatType: Type.Optional(Type.Union([Type.Literal("channel"), Type.Literal("group"), Type.Literal("direct")])),
         accountId: Type.Optional(Type.String({ pattern: "\\S" })),
         conversationId: Type.Optional(Type.String({ pattern: "\\S" })),
     }, { additionalProperties: false })),
@@ -58,7 +62,7 @@ function createSearchTool(runtime, ctx) {
         description: "Search configured memory corpora with semantic vector retrieval. The isolated skills corpus is never included.",
         parameters: searchParameters,
         async execute(_toolCallId, params, signal) {
-            const { query: untrimmedQuery, corpora, sessionFilter, maxResults, minScore } = Value.Parse(searchParameters, params);
+            const { query: untrimmedQuery, corpora, sessionFilter, maxResults, minScore, } = Value.Parse(searchParameters, params);
             const query = untrimmedQuery.trim();
             const { manager, error } = await runtime.getMemorySearchManager(active);
             if (!manager)
@@ -302,7 +306,9 @@ function createUpdateMaintenanceTool(runtime, ctx) {
                 id: taskId,
                 status: action === "resolve" ? "resolved" : action === "defer" ? "deferred" : "irrelevant",
                 note,
-                ...(annotation ? { annotation: { ...annotation, scope: annotation.scope ?? "chunk" } } : {}),
+                ...(annotation
+                    ? { annotation: { ...annotation, scope: annotation.scope ?? "chunk" } }
+                    : {}),
             });
             return jsonResult(updated ? { status: "ok", task: updated } : { status: "not_found" });
         },
@@ -380,6 +386,9 @@ 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, {
         analysisExecutable: config.analysis.executable,
         keepEmbeddingModelWarm: config.keepEmbeddingModelWarm,
@@ -388,20 +397,41 @@ export function registerUnblockMemory(api) {
         deterministicRecallToolName: "memory_search",
         supportsPrivateTranscriptRecall: false,
         promptBuilder: ({ availableTools }) => availableTools.has("memory_search")
-            ? ["Use memory_search for relevant past facts, then memory_get when more surrounding context is needed."]
+            ? [
+                "Use memory_search for relevant past facts, then memory_get when more surrounding context is needed.",
+            ]
             : [],
         flushPlanResolver: resolveFlushPlan,
         runtime,
     };
     api.registerMemoryCapability(capability);
+    if (config.people.enabled) {
+        const peopleStores = new PeopleStores({
+            maxOpenTodos: config.people.todos.maxOpen,
+            maxBlurbChars: config.people.whisperer.maxChars,
+        });
+        registerPeopleHooks(api, peopleStores, config.people);
+        registerPeopleTools(api, peopleStores, config.people);
+        api.on("gateway_stop", () => peopleStores.closeAll());
+    }
     registerSkillWhisperer(api, runtime, config.skillWhisperer);
     api.registerTool((ctx) => createSearchTool(runtime, ctx), { names: ["memory_search"] });
     api.registerTool((ctx) => createGetTool(runtime, ctx), { names: ["memory_get"] });
-    api.registerTool((ctx) => createSyncSessionsTool(runtime, ctx), { names: ["memory_sync_sessions"] });
+    api.registerTool((ctx) => createSyncSessionsTool(runtime, ctx), {
+        names: ["memory_sync_sessions"],
+    });
     api.registerTool((ctx) => createSyncStatusTool(runtime, ctx), { names: ["memory_sync_status"] });
     api.registerTool((ctx) => createReclusterTool(runtime, ctx), { names: ["memory_recluster"] });
-    api.registerTool((ctx) => createListClustersTool(runtime, ctx), { names: ["memory_list_clusters"] });
-    api.registerTool((ctx) => createFetchClusterTool(runtime, ctx), { names: ["memory_fetch_cluster"] });
-    api.registerTool((ctx) => createListMaintenanceTool(runtime, ctx), { names: ["memory_list_maintenance_tasks"] });
-    api.registerTool((ctx) => createUpdateMaintenanceTool(runtime, ctx), { names: ["memory_update_maintenance_task"] });
+    api.registerTool((ctx) => createListClustersTool(runtime, ctx), {
+        names: ["memory_list_clusters"],
+    });
+    api.registerTool((ctx) => createFetchClusterTool(runtime, ctx), {
+        names: ["memory_fetch_cluster"],
+    });
+    api.registerTool((ctx) => createListMaintenanceTool(runtime, ctx), {
+        names: ["memory_list_maintenance_tasks"],
+    });
+    api.registerTool((ctx) => createUpdateMaintenanceTool(runtime, ctx), {
+        names: ["memory_update_maintenance_task"],
+    });
 }

package/dist/src/skill-whisperer.js

@@ -59,17 +59,22 @@ export function registerSkillWhisperer(api, runtime, config) {
         state.lastRunId = context.runId;
         state.turn += 1;
         try {
-            const candidates = await runtime.searchSkills(active(context.agentId), buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), config.minScore, CANDIDATE_LIMIT);
-            const selected = candidates[0];
-            if (!selected || selected.score < config.minScore)
+            const runtimeParams = active(context.agentId);
+            const candidates = await runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), config.minScore, CANDIDATE_LIMIT);
+            const resolved = candidates.flatMap((candidate) => {
+                const canonicalPath = runtime.resolveSkillPath(runtimeParams, candidate.path);
+                return canonicalPath ? [{ candidate, canonicalPath }] : [];
+            })[0];
+            if (!resolved || resolved.candidate.score < config.minScore)
                 return;
-            const previous = state.skills.get(selected.path);
+            const { candidate: selected, canonicalPath } = resolved;
+            const previous = state.skills.get(canonicalPath);
             const lastSeen = Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity);
             if (state.turn - lastSeen <= config.cooldownTurns)
                 return;
-            const history = state.skills.get(selected.path) ?? {};
+            const history = state.skills.get(canonicalPath) ?? {};
             history.suggested = state.turn;
-            state.skills.set(selected.path, history);
+            state.skills.set(canonicalPath, history);
             return {
                 prependContext: `A potentially relevant skill is available: ${JSON.stringify(selected.name)} ` +
                     `at ${JSON.stringify(selected.path)}. Check it before proceeding if applicable.`,

package/dist/src/slack-directory.d.ts

@@ -0,0 +1,37 @@
+import type { PeopleStore } from "./people-store.js";
+type SlackDirectoryEntry = {
+    id: string;
+    name?: string;
+    handle?: string;
+    avatarUrl?: string;
+};
+export type SlackDirectoryReader = {
+    listUsers(params: {
+        accountId: string;
+        limit: number;
+    }): Promise<readonly SlackDirectoryEntry[]>;
+};
+type DirectoryCommand = (executable: string, args: readonly string[], options: {
+    maxBuffer: number;
+}) => Promise<{
+    stdout: string;
+}>;
+export declare function createOpenClawSlackDirectory(run?: DirectoryCommand): SlackDirectoryReader;
+export declare const openClawSlackDirectory: SlackDirectoryReader;
+export declare function syncSlackDirectory(params: {
+    store: PeopleStore;
+    reader: SlackDirectoryReader;
+    accountId: string;
+    limit: number;
+    syncedAt?: string;
+}): Promise<{
+    created: number;
+    updated: number;
+    unchanged: number;
+    skipped: number;
+    failed: number;
+    status: "ok";
+    accountId: string;
+    received: number;
+}>;
+export {};

package/dist/src/slack-directory.js

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function text(value, maxLength) {
+    return typeof value === "string" && value.trim() ? value.trim().slice(0, maxLength) : undefined;
+}
+export function createOpenClawSlackDirectory(run = async (executable, args, options) => {
+    const result = await execFileAsync(executable, args, options);
+    return { stdout: result.stdout };
+}) {
+    return {
+        async listUsers({ accountId, limit }) {
+            const { stdout } = await run("openclaw", [
+                "directory",
+                "peers",
+                "list",
+                "--channel",
+                "slack",
+                "--account",
+                accountId,
+                "--limit",
+                String(limit),
+                "--json",
+            ], { maxBuffer: 1024 * 1024 });
+            const parsed = JSON.parse(stdout);
+            if (!Array.isArray(parsed))
+                throw new Error("OpenClaw Slack directory returned an invalid response");
+            return parsed.flatMap((value) => {
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    return [];
+                const entry = value;
+                if (entry.kind !== "user")
+                    return [];
+                const prefixedId = text(entry.id, 200);
+                if (!prefixedId?.startsWith("user:"))
+                    return [];
+                const id = text(prefixedId.slice("user:".length), 200);
+                const handle = text(entry.handle, 200);
+                return id
+                    ? [
+                        {
+                            id,
+                            name: text(entry.name, 500),
+                            handle: text(handle?.startsWith("@") ? handle.slice(1) : handle, 200),
+                        },
+                    ]
+                    : [];
+            });
+        },
+    };
+}
+export const openClawSlackDirectory = createOpenClawSlackDirectory();
+export async function syncSlackDirectory(params) {
+    const entries = await params.reader.listUsers({
+        accountId: params.accountId,
+        limit: params.limit,
+    });
+    const counts = { created: 0, updated: 0, unchanged: 0, skipped: 0, failed: 0 };
+    const syncedAt = params.syncedAt ?? new Date().toISOString();
+    for (const entry of entries.slice(0, params.limit)) {
+        const externalId = text(entry.id, 200);
+        if (!externalId) {
+            counts.skipped += 1;
+            continue;
+        }
+        try {
+            const existing = params.store.findIdentity("slack", params.accountId, externalId);
+            if (existing && params.store.getPerson(existing.personId)?.status !== "active") {
+                counts.skipped += 1;
+                continue;
+            }
+            const changed = existing !== undefined &&
+                ((entry.name !== undefined && entry.name !== existing.displayName) ||
+                    (entry.handle !== undefined && entry.handle !== existing.handle) ||
+                    (entry.avatarUrl !== undefined && entry.avatarUrl !== existing.avatarUrl));
+            const result = params.store.upsertIdentity({
+                provider: "slack",
+                accountScope: params.accountId,
+                externalId,
+                displayName: entry.name,
+                handle: entry.handle,
+                avatarUrl: entry.avatarUrl,
+                syncedAt,
+            });
+            if (result.created)
+                counts.created += 1;
+            else if (changed)
+                counts.updated += 1;
+            else
+                counts.unchanged += 1;
+        }
+        catch {
+            counts.failed += 1;
+        }
+    }
+    return {
+        status: "ok",
+        accountId: params.accountId,
+        received: entries.length,
+        ...counts,
+    };
+}

package/dist/src/sources.d.ts

@@ -13,6 +13,7 @@ export declare function resolveSource(workspaceDir: string, configuredPath: stri
 export declare function resolveSessionSource(sessionsDir: string, chatTypes: readonly ChatType[]): ResolvedSource;
 export declare function resolveSources(workspaceDir: string, corpora: readonly (FileCorpusConfig | SkillCorpusConfig)[]): ResolvedSource[];
 export declare function resolveConfiguredSkillPath(workspaceDir: string, inputPath: string, sources: readonly ResolvedSource[]): string | undefined;
+export declare function sourceMatchesPath(source: ResolvedSource, inputPath: string): boolean;
 export declare function parseSafeVirtualPath(virtualPath: string, sources: ReadonlyMap<string, ResolvedSource>): {
     source: ResolvedSource;
     relativePath: string;

package/dist/src/sources.js

@@ -121,6 +121,13 @@ export function resolveConfiguredSkillPath(workspaceDir, inputPath, sources) {
     }
     return undefined;
 }
+export function sourceMatchesPath(source, inputPath) {
+    const target = resolve(inputPath);
+    const relativePath = relative(source.root, target);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath))
+        return false;
+    return picomatch.isMatch(relativePath.split(sep).join("/"), source.pattern, { dot: true });
+}
 export function parseSafeVirtualPath(virtualPath, sources) {
     const match = /^qmd:\/\/([^/]+)\/(.+)$/.exec(virtualPath.trim());
     if (!match)

package/openclaw.plugin.json

@@ -1,12 +1,34 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": false },
   "skills": ["./skills"],
-  "contracts": { "tools": ["memory_search", "memory_get", "memory_sync_sessions", "memory_sync_status", "memory_recluster", "memory_list_clusters", "memory_fetch_cluster", "memory_list_maintenance_tasks", "memory_update_maintenance_task"] },
+  "cliCommands": [
+    {
+      "name": "unblock-memory",
+      "description": "Unblock Memory administration",
+      "hasSubcommands": true
+    }
+  ],
+  "contracts": {
+    "tools": [
+      "memory_search",
+      "memory_get",
+      "memory_sync_sessions",
+      "memory_sync_status",
+      "memory_recluster",
+      "memory_list_clusters",
+      "memory_fetch_cluster",
+      "memory_list_maintenance_tasks",
+      "memory_update_maintenance_task",
+      "memory_people_inspect",
+      "memory_people_update",
+      "memory_people_sync"
+    ]
+  },
   "toolMetadata": {
     "memory_sync_sessions": { "sideEffecting": true },
     "memory_sync_status": { "replaySafe": true },
@@ -14,7 +36,10 @@
     "memory_list_clusters": { "replaySafe": true },
     "memory_fetch_cluster": { "replaySafe": true },
     "memory_list_maintenance_tasks": { "replaySafe": true },
-    "memory_update_maintenance_task": { "sideEffecting": true }
+    "memory_update_maintenance_task": { "sideEffecting": true },
+    "memory_people_inspect": { "replaySafe": true, "optional": true },
+    "memory_people_update": { "sideEffecting": true, "optional": true },
+    "memory_people_sync": { "sideEffecting": true, "optional": true }
   },
   "uiHints": {
     "keepEmbeddingModelWarm": {
@@ -29,6 +54,14 @@
       "label": "Skill Whisperer",
       "help": "Suggest at most one semantically relevant configured skill before a user turn. Requires hook conversation access."
     },
+    "people.enabled": {
+      "label": "PeopleSQL",
+      "help": "Maintain an agent-local people store. Disabled by default."
+    },
+    "people.whisperer.enabled": {
+      "label": "People Whisperer",
+      "help": "Inject an enabled person's bounded dossier blurb after exact identity matching. Requires hook conversation access."
+    },
     "analysis.executable": {
       "label": "Memory Analysis Worker",
       "help": "Optional absolute path to the locally installed unblock-memory-analysis executable."
@@ -107,6 +140,44 @@
           "executable": { "type": "string", "minLength": 1 }
         }
       },
+      "people": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean", "default": false },
+          "refinement": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "maxPeoplePerRun": { "type": "integer", "minimum": 1, "maximum": 50, "default": 10 }
+            },
+            "default": { "maxPeoplePerRun": 10 }
+          },
+          "whisperer": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": { "type": "boolean", "default": false },
+              "maxChars": { "type": "integer", "minimum": 1, "maximum": 4000, "default": 1200 }
+            },
+            "default": { "enabled": false, "maxChars": 1200 }
+          },
+          "todos": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "maxOpen": { "type": "integer", "minimum": 1, "maximum": 10000, "default": 1000 }
+            },
+            "default": { "maxOpen": 1000 }
+          }
+        },
+        "default": {
+          "enabled": false,
+          "refinement": { "maxPeoplePerRun": 10 },
+          "whisperer": { "enabled": false, "maxChars": 1200 },
+          "todos": { "maxOpen": 1000 }
+        }
+      },
       "skillWhisperer": {
         "type": "object",
         "additionalProperties": false,

package/package.json

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