@unblocklabs/unblock-memory 0.3.7 → 0.3.9

package/dist/src/people-store.js

@@ -1,3 +1,4 @@
+import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -40,12 +41,23 @@ const claimSchema = Type.Object({
 }, { additionalProperties: false });
 export const PERSON_DOSSIER_SCHEMA = Type.Object({
     schemaVersion: Type.Literal(1),
-    blurb: Type.String({ minLength: 1 }),
+    blurb: Type.String({ minLength: 1, pattern: "\\S" }),
     sections: Type.Array(Type.Object({
         category: Type.Union(BASELINE_DOSSIER_CATEGORIES.map((category) => Type.Literal(category))),
         claims: Type.Array(claimSchema, { minItems: 1, maxItems: 100 }),
     }, { additionalProperties: false }), { maxItems: BASELINE_DOSSIER_CATEGORIES.length }),
 }, { additionalProperties: false });
+const MAX_DOSSIER_JSON_BYTES = 64 * 1024;
+function serializeDossier(dossier) {
+    const json = JSON.stringify(dossier);
+    if (Buffer.byteLength(json, "utf8") > MAX_DOSSIER_JSON_BYTES) {
+        throw new Error(`dossier must serialize to at most ${MAX_DOSSIER_JSON_BYTES} bytes`);
+    }
+    return json;
+}
+function parseDossierJson(json) {
+    return Value.Parse(PERSON_DOSSIER_SCHEMA, JSON.parse(json));
+}
 const OVERFLOW_KEY = "__people_todo_overflow__";
 function required(value, label) {
     const normalized = value.trim();
@@ -56,6 +68,12 @@ function required(value, label) {
 function optional(value) {
     return value?.trim() || null;
 }
+function dossierReason(value) {
+    const reason = required(value, "reason");
+    if (reason.length > 1000)
+        throw new Error("reason must not exceed 1000 characters");
+    return reason;
+}
 function person(row) {
     return {
         id: row.id,
@@ -63,7 +81,6 @@ function person(row) {
         preferredName: row.preferred_name,
         status: row.status,
         companyId: row.company_id,
-        refinementEnabled: row.refinement_enabled === 1,
         injectionEnabled: row.injection_enabled === 1,
         lastSeenAt: row.last_seen_at,
         createdAt: row.created_at,
@@ -158,9 +175,8 @@ export class PeopleStore {
                 this.#db
                     .prepare(`
           INSERT INTO people
-            (id, display_name, status, refinement_enabled, injection_enabled,
-             last_seen_at, created_at, updated_at)
-          VALUES (?, ?, 'active', 0, 0, ?, ?, ?)
+            (id, display_name, status, injection_enabled, last_seen_at, created_at, updated_at)
+          VALUES (?, ?, 'active', 1, ?, ?, ?)
         `)
                     .run(personId, displayName, directorySync ? null : now, now, now);
                 this.#db
@@ -205,8 +221,8 @@ export class PeopleStore {
             if (input.isDeactivated === true) {
                 this.#db
                     .prepare(`
-          UPDATE people SET status = 'unavailable', refinement_enabled = 0,
-            injection_enabled = 0, updated_at = ? WHERE id = ?
+          UPDATE people SET status = 'unavailable', injection_enabled = 0,
+            updated_at = ? WHERE id = ?
         `)
                     .run(now, personId);
             }
@@ -292,71 +308,47 @@ export class PeopleStore {
             throw error;
         }
     }
-    listRefinementCandidates(limit) {
-        const bounded = Math.max(1, Math.min(100, Math.floor(limit)));
+    listActivePeople(limit = 50, offset = 0) {
         return this.#db
             .prepare(`
-      SELECT people.* FROM people
-      LEFT JOIN person_dossiers ON person_dossiers.person_id = people.id
-      WHERE people.status = 'active'
-        AND people.refinement_enabled = 1
-        AND people.last_seen_at IS NOT NULL
-        AND (person_dossiers.reviewed_at IS NULL OR people.last_seen_at > person_dossiers.reviewed_at)
-      ORDER BY people.last_seen_at DESC, people.id
-      LIMIT ?
+      SELECT * FROM people
+      WHERE status = 'active'
+      ORDER BY last_seen_at DESC, id
+      LIMIT ? OFFSET ?
     `)
-            .all(bounded)
+            .all(limit, offset)
             .map((row) => person(row));
     }
     findIdentity(provider, accountScope, externalId) {
         const row = this.#identityRow(provider, accountScope, externalId);
         return row ? identity(row) : undefined;
     }
-    setPolicies(personId, policies) {
+    setInjection(personId, enabled) {
         const now = new Date().toISOString();
         this.#db
-            .prepare(`
-      UPDATE people SET
-        refinement_enabled = COALESCE(?, refinement_enabled),
-        injection_enabled = COALESCE(?, injection_enabled),
-        updated_at = ?
-      WHERE id = ?
-    `)
-            .run(policies.refinementEnabled === undefined ? null : Number(policies.refinementEnabled), policies.injectionEnabled === undefined ? null : Number(policies.injectionEnabled), now, personId);
+            .prepare("UPDATE people SET injection_enabled = ?, updated_at = ? WHERE id = ?")
+            .run(Number(enabled), now, personId);
         const row = this.#db.prepare("SELECT * FROM people WHERE id = ?").get(personId);
         return row ? person(row) : undefined;
     }
-    replaceDossier(personId, input, reviewedAt = new Date().toISOString(), options = {}) {
+    replaceDossier(personId, reasonInput, input) {
         const dossier = Value.Parse(PERSON_DOSSIER_SCHEMA, input);
-        if (dossier.blurb.length > this.#maxBlurbChars) {
-            throw new Error(`dossier blurb must not exceed ${this.#maxBlurbChars} characters`);
-        }
-        const categories = dossier.sections.map((section) => section.category);
-        if (new Set(categories).size !== categories.length) {
-            throw new Error("dossier sections must have unique categories");
-        }
+        this.#validateDossier(dossier);
+        const dossierJson = serializeDossier(dossier);
+        const reason = dossierReason(reasonInput);
+        const reviewedAt = new Date().toISOString();
         this.#db.exec("BEGIN IMMEDIATE");
         try {
-            const target = this.#db
-                .prepare("SELECT refinement_enabled FROM people WHERE id = ?")
-                .get(personId);
+            const target = this.#db.prepare("SELECT id FROM people WHERE id = ?").get(personId);
             if (!target)
                 throw new Error(`person not found: ${personId}`);
-            if (options.requireRefinementEnabled && target.refinement_enabled !== 1) {
-                throw new Error("person is not enabled for refinement");
-            }
-            const dossierJson = JSON.stringify(dossier);
-            const current = this.#db
+            const existing = this.#db
                 .prepare("SELECT dossier_json FROM person_dossiers WHERE person_id = ?")
                 .get(personId);
-            if (current?.dossier_json === dossierJson) {
-                this.#db
-                    .prepare("UPDATE person_dossiers SET reviewed_at = ? WHERE person_id = ?")
-                    .run(reviewedAt, personId);
-            }
-            else {
-                this.#db
-                    .prepare(`
+            if (existing)
+                parseDossierJson(existing.dossier_json);
+            this.#db
+                .prepare(`
           INSERT INTO person_dossiers (person_id, dossier_json, blurb, reviewed_at)
           VALUES (?, ?, ?, ?)
           ON CONFLICT(person_id) DO UPDATE SET
@@ -364,8 +356,14 @@ export class PeopleStore {
             blurb = excluded.blurb,
             reviewed_at = excluded.reviewed_at
         `)
-                    .run(personId, dossierJson, dossier.blurb, reviewedAt);
-            }
+                .run(personId, dossierJson, dossier.blurb, reviewedAt);
+            this.#db
+                .prepare(`
+          INSERT INTO person_dossier_changes
+            (id, person_id, action, before_dossier_json, after_dossier_json, reason, changed_at)
+          VALUES (?, ?, 'replace', ?, ?, ?, ?)
+        `)
+                .run(randomUUID(), personId, existing?.dossier_json ?? null, dossierJson, reason, reviewedAt);
             this.#db.exec("COMMIT");
             return dossier;
         }
@@ -374,17 +372,124 @@ export class PeopleStore {
             throw error;
         }
     }
+    deleteDossier(personId, reasonInput) {
+        const reason = dossierReason(reasonInput);
+        const changedAt = new Date().toISOString();
+        this.#db.exec("BEGIN IMMEDIATE");
+        try {
+            const existing = this.#db
+                .prepare("SELECT dossier_json FROM person_dossiers WHERE person_id = ?")
+                .get(personId);
+            if (!existing) {
+                this.#db.exec("COMMIT");
+                return false;
+            }
+            parseDossierJson(existing.dossier_json);
+            this.#db.prepare("DELETE FROM person_dossiers WHERE person_id = ?").run(personId);
+            this.#db
+                .prepare(`
+          INSERT INTO person_dossier_changes
+            (id, person_id, action, before_dossier_json, after_dossier_json, reason, changed_at)
+          VALUES (?, ?, 'delete', ?, NULL, ?, ?)
+        `)
+                .run(randomUUID(), personId, existing.dossier_json, reason, changedAt);
+            this.#db.exec("COMMIT");
+            return true;
+        }
+        catch (error) {
+            this.#db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    getWhisperReceipt(threadKey, personId) {
+        const row = this.#db
+            .prepare(`
+      SELECT run_id, contribution, injected_at FROM person_whisper_receipts
+      WHERE thread_key = ? AND person_id = ?
+    `)
+            .get(threadKey, personId);
+        return row
+            ? { runId: row.run_id, contribution: row.contribution, injectedAt: row.injected_at }
+            : undefined;
+    }
+    recordWhisperReceipt(input) {
+        const threadKey = required(input.threadKey, "threadKey");
+        const runId = required(input.runId, "runId");
+        const contribution = required(input.contribution, "contribution");
+        const injectedAt = new Date().toISOString();
+        this.#db
+            .prepare(`
+      INSERT OR IGNORE INTO person_whisper_receipts
+        (thread_key, person_id, run_id, contribution, injected_at)
+      VALUES (?, ?, ?, ?, ?)
+    `)
+            .run(threadKey, input.personId, runId, contribution, injectedAt);
+        return this.getWhisperReceipt(threadKey, input.personId);
+    }
     getDossier(personId) {
         const row = this.#db
             .prepare("SELECT dossier_json, reviewed_at FROM person_dossiers WHERE person_id = ?")
             .get(personId);
         return row
             ? {
-                dossier: Value.Parse(PERSON_DOSSIER_SCHEMA, JSON.parse(row.dossier_json)),
+                dossier: parseDossierJson(row.dossier_json),
                 reviewedAt: row.reviewed_at,
             }
             : undefined;
     }
+    getDossierReviewedAt(personId) {
+        const row = this.#db
+            .prepare("SELECT reviewed_at FROM person_dossiers WHERE person_id = ?")
+            .get(personId);
+        return row?.reviewed_at;
+    }
+    listDossierChanges(personId, limit = 20, offset = 0) {
+        return this.#db
+            .prepare(`
+        SELECT id, person_id, action, reason, changed_at,
+          CASE WHEN before_dossier_json IS NULL THEN NULL
+            ELSE length(CAST(before_dossier_json AS BLOB)) END AS before_dossier_bytes,
+          CASE WHEN after_dossier_json IS NULL THEN NULL
+            ELSE length(CAST(after_dossier_json AS BLOB)) END AS after_dossier_bytes
+        FROM person_dossier_changes
+        WHERE person_id = ?
+        ORDER BY changed_at DESC, rowid DESC
+        LIMIT ? OFFSET ?
+      `)
+            .all(personId, limit, offset)
+            .map((value) => {
+            const row = value;
+            return {
+                id: row.id,
+                personId: row.person_id,
+                action: row.action,
+                beforeDossierBytes: row.before_dossier_bytes,
+                afterDossierBytes: row.after_dossier_bytes,
+                reason: row.reason,
+                changedAt: row.changed_at,
+            };
+        });
+    }
+    getDossierChange(personId, changeId) {
+        const row = this.#db
+            .prepare("SELECT * FROM person_dossier_changes WHERE person_id = ? AND id = ?")
+            .get(personId, changeId);
+        return row
+            ? {
+                id: row.id,
+                personId: row.person_id,
+                action: row.action,
+                beforeDossier: row.before_dossier_json === null
+                    ? null
+                    : parseDossierJson(row.before_dossier_json),
+                afterDossier: row.after_dossier_json === null
+                    ? null
+                    : parseDossierJson(row.after_dossier_json),
+                reason: row.reason,
+                changedAt: row.changed_at,
+            }
+            : undefined;
+    }
     getDossierBlurb(personId) {
         const row = this.#db
             .prepare("SELECT blurb FROM person_dossiers WHERE person_id = ?")
@@ -397,8 +502,8 @@ export class PeopleStore {
         try {
             const changed = this.#db
                 .prepare(`
-        UPDATE people SET status = 'unavailable', refinement_enabled = 0,
-          injection_enabled = 0, updated_at = ? WHERE id = ?
+        UPDATE people SET status = 'unavailable', injection_enabled = 0,
+          updated_at = ? WHERE id = ?
       `)
                 .run(now, personId);
             if (changed.changes === 0) {
@@ -425,8 +530,7 @@ export class PeopleStore {
         try {
             const changed = this.#db
                 .prepare(`
-        UPDATE people SET status = 'active', refinement_enabled = 0,
-          injection_enabled = 0, updated_at = ?
+        UPDATE people SET status = 'active', injection_enabled = 0, updated_at = ?
         WHERE id = ? AND status = 'unavailable'
       `)
                 .run(now, personId);
@@ -568,16 +672,50 @@ export class PeopleStore {
     `)
             .get(provider, accountScope, externalId);
     }
+    #validateDossier(dossier) {
+        if (dossier.blurb.length > this.#maxBlurbChars) {
+            throw new Error(`dossier blurb must not exceed ${this.#maxBlurbChars} characters`);
+        }
+        const categories = dossier.sections.map((section) => section.category);
+        if (new Set(categories).size !== categories.length) {
+            throw new Error("dossier sections must have unique categories");
+        }
+    }
     #migrate() {
         const current = this.#db.prepare("PRAGMA user_version").get();
-        if (current.user_version === 1)
+        if (current.user_version === 4)
             return;
-        if (current.user_version !== 0) {
+        if (current.user_version !== 0 &&
+            current.user_version !== 1 &&
+            current.user_version !== 2 &&
+            current.user_version !== 3) {
             throw new Error(`unsupported PeopleSQL schema version: ${current.user_version}`);
         }
         this.#db.exec("BEGIN IMMEDIATE");
         try {
-            this.#db.exec(`
+            if (current.user_version === 2) {
+                this.#db.exec(`
+          DROP TABLE person_evidence_receipts;
+        `);
+            }
+            else if (current.user_version === 1) {
+                this.#db.exec(`
+          DROP INDEX people_policy_seen;
+          ALTER TABLE people DROP COLUMN refinement_enabled;
+          UPDATE people SET injection_enabled = 1 WHERE status = 'active';
+
+          CREATE TABLE person_whisper_receipts (
+            thread_key TEXT NOT NULL,
+            person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
+            run_id TEXT NOT NULL,
+            contribution TEXT NOT NULL,
+            injected_at TEXT NOT NULL,
+            PRIMARY KEY (thread_key, person_id)
+          ) STRICT;
+        `);
+            }
+            else if (current.user_version === 0) {
+                this.#db.exec(`
         CREATE TABLE companies (
           id TEXT PRIMARY KEY,
           name TEXT NOT NULL,
@@ -593,8 +731,7 @@ export class PeopleStore {
           preferred_name TEXT,
           status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'unavailable', 'archived')),
           company_id TEXT REFERENCES companies(id),
-          refinement_enabled INTEGER NOT NULL DEFAULT 0 CHECK (refinement_enabled IN (0, 1)),
-          injection_enabled INTEGER NOT NULL DEFAULT 0 CHECK (injection_enabled IN (0, 1)),
+          injection_enabled INTEGER NOT NULL DEFAULT 1 CHECK (injection_enabled IN (0, 1)),
           last_seen_at TEXT,
           created_at TEXT NOT NULL,
           updated_at TEXT NOT NULL
@@ -638,10 +775,33 @@ export class PeopleStore {
           resolution_note TEXT
         ) STRICT;
 
+        CREATE TABLE person_whisper_receipts (
+          thread_key TEXT NOT NULL,
+          person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
+          run_id TEXT NOT NULL,
+          contribution TEXT NOT NULL,
+          injected_at TEXT NOT NULL,
+          PRIMARY KEY (thread_key, person_id)
+        ) STRICT;
+
         CREATE INDEX people_status_seen ON people(status, last_seen_at);
-        CREATE INDEX people_policy_seen ON people(refinement_enabled, last_seen_at);
         CREATE INDEX people_todos_status_seen ON people_todos(status, last_seen_at);
-        PRAGMA user_version = 1;
+        `);
+            }
+            this.#db.exec(`
+        CREATE TABLE person_dossier_changes (
+          id TEXT PRIMARY KEY,
+          person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
+          action TEXT NOT NULL CHECK (action IN ('replace', 'delete')),
+          before_dossier_json TEXT,
+          after_dossier_json TEXT,
+          reason TEXT NOT NULL,
+          changed_at TEXT NOT NULL
+        ) STRICT;
+
+        CREATE INDEX person_dossier_changes_person_changed
+          ON person_dossier_changes(person_id, changed_at DESC);
+        PRAGMA user_version = 4;
       `);
             this.#db.exec("COMMIT");
         }

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

@@ -1,5 +1,5 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
 import type { UnblockMemoryConfig } from "./config.js";
-import type { PeopleStores } from "./people-store.js";
+import { type PeopleStores } from "./people-store.js";
 import { type SlackDirectoryReader } from "./slack-directory.js";
 export declare function registerPeopleTools(api: OpenClawPluginApi, stores: PeopleStores, config: UnblockMemoryConfig["people"], directoryReader?: SlackDirectoryReader): void;

package/dist/src/people-tools.js

@@ -2,6 +2,7 @@ import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { renderPeopleWhisper } from "./people-hooks.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([
@@ -32,6 +33,30 @@ const inspectParameters = Type.Union([
             description: "Exact Slack identity for the person to inspect.",
         }),
     }, { additionalProperties: false }),
+    Type.Object({
+        view: Type.Literal("people"),
+        limit: Type.Optional(Type.Integer({
+            minimum: 1,
+            maximum: 100,
+            description: "Maximum active people to return.",
+        })),
+        offset: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: "People to skip." })),
+    }, { additionalProperties: false }),
+    Type.Object({
+        view: Type.Literal("dossier_changes"),
+        personId: nonEmpty,
+        limit: Type.Optional(Type.Integer({
+            minimum: 1,
+            maximum: 100,
+            description: "Maximum dossier change summaries to return, newest first.",
+        })),
+        offset: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: "Changes to skip." })),
+    }, { additionalProperties: false }),
+    Type.Object({
+        view: Type.Literal("dossier_change"),
+        personId: nonEmpty,
+        changeId: nonEmpty,
+    }, { additionalProperties: false }),
     Type.Object({
         view: Type.Literal("todos"),
         limit: Type.Optional(Type.Integer({
@@ -43,10 +68,20 @@ const inspectParameters = Type.Union([
 ]);
 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,
-        refinementEnabled: Type.Optional(Type.Boolean()),
-        injectionEnabled: Type.Optional(Type.Boolean()),
+        dossier: PERSON_DOSSIER_SCHEMA,
+        reason: nonEmpty,
+    }, { additionalProperties: false }),
+    Type.Object({
+        action: Type.Literal("delete_dossier"),
+        personId: nonEmpty,
+        reason: nonEmpty,
     }, { additionalProperties: false }),
     Type.Object({
         action: Type.Literal("set_company"),
@@ -99,49 +134,91 @@ 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: "List active people, inspect one person, read dossier change history, or list 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));
             }
+            const store = stores.get(active.agentId);
+            if (input.view === "people") {
+                const limit = input.limit ?? 50;
+                const offset = input.offset ?? 0;
+                const people = store.listActivePeople(limit, offset).map((person) => {
+                    const dossierReviewedAt = store.getDossierReviewedAt(person.id);
+                    return {
+                        person,
+                        identities: store.listIdentities(person.id),
+                        hasDossier: dossierReviewedAt !== undefined,
+                        dossierReviewedAt: dossierReviewedAt ?? null,
+                    };
+                });
+                return jsonResult({
+                    status: "ok",
+                    people,
+                    nextOffset: people.length === limit ? offset + people.length : null,
+                });
+            }
+            if (input.view === "dossier_changes") {
+                const limit = input.limit ?? 20;
+                const offset = input.offset ?? 0;
+                const changes = store.listDossierChanges(input.personId, limit, offset);
+                return jsonResult({
+                    status: "ok",
+                    changes,
+                    nextOffset: changes.length === limit ? offset + changes.length : null,
+                });
+            }
+            if (input.view === "dossier_change") {
+                const change = store.getDossierChange(input.personId, input.changeId);
+                return jsonResult(change ? { status: "ok", change } : { status: "not_found" });
+            }
             return jsonResult({
                 status: "ok",
-                todos: stores.get(active.agentId).listTodos(input.limit ?? 20),
+                todos: store.listTodos(input.limit ?? 20),
             });
         },
     };
 }
 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) {
-                    return jsonResult({
-                        status: "invalid",
-                        error: "set_policy requires at least one policy value",
-                    });
-                }
-                const person = store.setPolicies(input.personId, input);
+            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") {
+                try {
+                    const dossier = store.replaceDossier(input.personId, input.reason, input.dossier);
+                    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, input.reason)
+                    ? { status: "ok" }
+                    : { status: "not_found" });
+            }
             if (input.action === "set_company") {
                 const company = store.setCompany(input.personId, {
                     name: input.companyName,
@@ -165,7 +242,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 +251,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 +271,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, {