@unblocklabs/unblock-memory 0.3.21 → 0.3.23

package/dist/src/config.d.ts

@@ -42,11 +42,6 @@ export type UnblockMemoryConfig = {
         enabled: boolean;
         corpora: readonly string[];
     };
-    xsearch: {
-        enabled: boolean;
-        corpora: readonly string[];
-        timeoutMs: number;
-    };
     responseAudit: ResponseAuditConfig;
     peoplePrimer: PeoplePrimerConfig;
     people: {

package/dist/src/config.js

@@ -264,7 +264,6 @@ export function resolveConfig(value) {
             typesafe: { ...DEFAULT_TYPESAFE_CONFIG },
             qualityAudit: { ...DEFAULT_QUALITY_AUDIT },
             evidenceReview: { enabled: false, corpora: [] },
-            xsearch: { enabled: false, corpora: [], timeoutMs: 10000 },
             responseAudit: resolveResponseAudit(undefined, DEFAULT_CORPORA),
             peoplePrimer: resolvePeoplePrimer(undefined, DEFAULT_CORPORA, false),
             people: DEFAULT_PEOPLE_CONFIG,
@@ -276,28 +275,10 @@ export function resolveConfig(value) {
         throw new Error("unblock-memory config must be an object");
     }
     const config = value;
-    assertOnlyKeys(config, ["corpora", "keepEmbeddingModelWarm", "analysis", "people", "peoplePrimer", "skillWhisperer", "memoryWhisperer", "typesafe", "qualityAudit", "evidenceReview", "responseAudit", "xsearch"], "config");
+    assertOnlyKeys(config, ["corpora", "keepEmbeddingModelWarm", "analysis", "people", "peoplePrimer", "skillWhisperer", "memoryWhisperer", "typesafe", "qualityAudit", "evidenceReview", "responseAudit"], "config");
     const corpora = resolveCorpora(config.corpora);
     const people = resolvePeople(config.people);
     const peoplePrimer = resolvePeoplePrimer(config.peoplePrimer, corpora, people.enabled);
-    let xsearch = { enabled: false, corpora: [], timeoutMs: 10000 };
-    if (config.xsearch !== undefined) {
-        const value = config.xsearch;
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            throw new Error("xsearch must be an object");
-        const options = value;
-        assertOnlyKeys(options, ["enabled", "corpora", "timeoutMs"], "xsearch");
-        try {
-            const approved = resolveQualityAudit({ enabled: options.enabled, corpora: options.corpora }, corpora);
-            xsearch = { enabled: approved.enabled, corpora: approved.corpora,
-                timeoutMs: positiveInteger(options.timeoutMs, 10000, "xsearch.timeoutMs", 30000) };
-        }
-        catch (error) {
-            if (error instanceof Error)
-                throw new Error(error.message.replaceAll("qualityAudit", "xsearch"));
-            throw error;
-        }
-    }
     let evidenceReview = { enabled: false, corpora: [] };
     if (config.evidenceReview !== undefined) {
         const value = config.evidenceReview;
@@ -368,7 +349,7 @@ export function resolveConfig(value) {
     if (skillWhisperer.enabled && !corpora.some((corpus) => corpus.kind === "skills")) {
         throw new Error('unblock-memory enabled skillWhisperer requires a corpus named "skills" with kind "skills"');
     }
-    return { corpora, keepEmbeddingModelWarm, analysis: analysisConfig, people, peoplePrimer, skillWhisperer, xsearch,
+    return { corpora, keepEmbeddingModelWarm, analysis: analysisConfig, people, peoplePrimer, skillWhisperer,
         qualityAudit: resolveQualityAudit(config.qualityAudit, corpora),
         evidenceReview,
         responseAudit: resolveResponseAudit(config.responseAudit, corpora),

package/dist/src/contracts.d.ts

@@ -24,7 +24,7 @@ export type SessionSearchFilter = {
 export type MemoryRequestContext = Pick<OpenClawPluginToolContext, "sessionKey" | "sessionId" | "messageChannel" | "agentAccountId" | "nativeChannelId" | "deliveryContext">;
 export type CorpusSearchOptions = NonNullable<Parameters<MemorySearchManagerContract["search"]>[1]> & {
     corpora?: readonly string[];
-    /** Internal hint/reranking budget; oversized matched chunks are omitted, never sliced. */
+    /** Internal vector-hint budget; oversized matched chunks are omitted, never sliced. */
     maxSnippetChars?: number;
     sessionFilter?: SessionSearchFilter;
     requestContext?: MemoryRequestContext;

package/dist/src/manager.d.ts

@@ -194,7 +194,6 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
         };
     }): MaintenanceTask | undefined;
     search(query: string, opts?: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
-    searchBm25(query: string, opts: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
     searchSkills(query: string, minScore: number, limit: number): Promise<SkillSearchCandidate[]>;
     readFile(params: {
         relPath: string;

package/dist/src/manager.js

@@ -14,7 +14,6 @@ import { qualityTaskPresence } from "./quality-triage.js";
 import { reviewIndexedClaim } from "./evidence-review.js";
 import { reviewClusterIngestion } from "./cluster-review.js";
 import { abortable } from "./abortable.js";
-import { xsearchBm25 } from "./xsearch-bm25.js";
 const DEFAULT_READ_LINES = 120;
 const MAX_READ_CHARS = 12_000;
 const WATCH_DEBOUNCE_MS = 250;
@@ -835,13 +834,10 @@ export class QmdMemoryManager {
             expand: false,
         });
         opts?.signal?.throwIfAborted();
-        return this.#searchResults(hits, store, opts);
-    }
-    async #searchResults(hits, store, opts, method = "vector") {
         const tokenizer = store.internal?.llm;
         const results = [];
         for (const hit of hits) {
-            // Hints and reranking must retain the entire matched chunk, even when expanded
+            // Proactive hints must retain the entire matched chunk, even when expanded
             // turn/message context exceeds their budget. Ordinary search is unchanged.
             if (hit.bestChunk.length > (opts?.maxSnippetChars ?? Infinity))
                 continue;
@@ -865,7 +861,7 @@ export class QmdMemoryManager {
                 path: hit.file,
                 ...span,
                 score: hit.score,
-                ...(method === "vector" ? { vectorScore: hit.score } : { textScore: hit.score }),
+                vectorScore: hit.score,
                 snippet: selected.text,
                 source: "memory",
                 corpus,
@@ -875,22 +871,6 @@ export class QmdMemoryManager {
         }
         return results;
     }
-    async searchBm25(query, opts) {
-        if (opts.sources && !opts.sources.includes("memory"))
-            return [];
-        const collections = this.#collectionNames(opts.corpora);
-        opts.signal?.throwIfAborted();
-        await abortable(this.#operationChain ?? Promise.resolve(), opts.signal);
-        const sessions = this.#sessions;
-        if (opts.sessionFilter && sessions && collections.includes(sessions.collection))
-            await this.#refreshSessionMetadata();
-        const allowedPaths = opts.sessionFilter && sessions && collections.includes(sessions.collection)
-            ? sessionAllowedPaths(this.#sessionMetadata, sessions.collection, opts.sessionFilter) : undefined;
-        const store = await this.#getAnalysisStore();
-        opts.signal?.throwIfAborted();
-        const hits = xsearchBm25(store.internal.db, query, collections, opts.maxResults ?? 5, allowedPaths);
-        return this.#searchResults(hits, store, opts, "bm25");
-    }
     async searchSkills(query, minScore, limit) {
         const collections = this.#skillCollectionNames();
         if (collections.length === 0)

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

@@ -1,9 +1,9 @@
 import { Type, type Static } from "typebox";
-export declare const PERSON_DOSSIER_SCHEMA: Type.TObject<{
+declare const PERSON_DOSSIER_SCHEMA: Type.TObject<{
     schemaVersion: Type.TLiteral<1>;
     blurb: Type.TString;
     sections: Type.TArray<Type.TObject<{
-        category: Type.TUnion<Type.TLiteral<"role" | "priorities" | "preferences" | "successCriteria" | "workingStyle" | "relationship" | "openLoops">[]>;
+        category: Type.TEnum<["role", "priorities", "preferences", "successCriteria", "workingStyle", "relationship", "openLoops"]>;
         claims: Type.TArray<Type.TObject<{
             statement: Type.TString;
             evidence: Type.TArray<Type.TObject<{
@@ -16,6 +16,23 @@ export declare const PERSON_DOSSIER_SCHEMA: Type.TObject<{
         }>>;
     }>>;
 }>;
+export declare const PERSON_DOSSIER_WRITE_SCHEMA: Type.TObject<{
+    sections: Type.TArray<Type.TObject<{
+        category: Type.TEnum<["role", "relationship"]>;
+        claims: Type.TArray<Type.TObject<{
+            epistemicType: Type.TEnum<["observed", "reported"]>;
+            statement: Type.TString;
+            evidence: Type.TArray<Type.TObject<{
+                source: Type.TUnion<[Type.TLiteral<"session">, Type.TLiteral<"memory">, Type.TLiteral<"directory">, Type.TLiteral<"manual">]>;
+                locator: Type.TString;
+                observedAt: Type.TOptional<Type.TString>;
+            }>>;
+            confidence: Type.TOptional<Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>>;
+        }>>;
+    }>>;
+    schemaVersion: Type.TLiteral<1>;
+    blurb: Type.TString;
+}>;
 export type PersonDossier = Static<typeof PERSON_DOSSIER_SCHEMA>;
 export declare class DossierConflictError extends Error {
     constructor();
@@ -118,7 +135,23 @@ export declare class PeopleStore {
     listActivePeople(limit?: number, offset?: number): Person[];
     findIdentity(provider: string, accountScope: string, externalId: string): PersonIdentity | undefined;
     setInjection(personId: string, enabled: boolean): Person | undefined;
-    validateDossier(input: unknown): PersonDossier;
+    validateDossier(input: unknown): {
+        schemaVersion: 1;
+        blurb: string;
+        sections: {
+            category: "role" | "relationship";
+            claims: {
+                confidence?: "low" | "medium" | "high" | undefined;
+                statement: string;
+                evidence: {
+                    observedAt?: string | undefined;
+                    source: "memory" | "manual" | "session" | "directory";
+                    locator: string;
+                }[];
+                epistemicType: "observed" | "reported";
+            }[];
+        }[];
+    };
     getDossierRevision(personId: string): string | null;
     replaceDossier(personId: string, reasonInput: string, input: unknown, expectedRevision?: string | null): PersonDossier;
     deleteDossier(personId: string, reasonInput: string): boolean;
@@ -165,3 +198,4 @@ export declare class PeopleStores {
     get(agentId: string): PeopleStore;
     closeAll(): void;
 }
+export {};

package/dist/src/people-store.js

@@ -39,14 +39,25 @@ const claimSchema = Type.Object({
     ]),
     confidence: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high")])),
 }, { additionalProperties: false });
-export const PERSON_DOSSIER_SCHEMA = Type.Object({
+// Keep the broad schema for legacy dossier and history reads only.
+const PERSON_DOSSIER_SCHEMA = Type.Object({
     schemaVersion: Type.Literal(1),
     blurb: Type.String({ minLength: 1, pattern: "\\S" }),
     sections: Type.Array(Type.Object({
-        category: Type.Union(BASELINE_DOSSIER_CATEGORIES.map((category) => Type.Literal(category))),
+        category: Type.Enum(BASELINE_DOSSIER_CATEGORIES),
         claims: Type.Array(claimSchema, { minItems: 1, maxItems: 100 }),
     }, { additionalProperties: false }), { maxItems: BASELINE_DOSSIER_CATEGORIES.length }),
 }, { additionalProperties: false });
+export const PERSON_DOSSIER_WRITE_SCHEMA = Type.Object({
+    ...PERSON_DOSSIER_SCHEMA.properties,
+    sections: Type.Array(Type.Object({
+        category: Type.Enum(["role", "relationship"]),
+        claims: Type.Array(Type.Object({
+            ...claimSchema.properties,
+            epistemicType: Type.Enum(["observed", "reported"]),
+        }, { additionalProperties: false }), { minItems: 1, maxItems: 100 }),
+    }, { additionalProperties: false }), { maxItems: 2 }),
+}, { additionalProperties: false });
 export class DossierConflictError extends Error {
     constructor() { super("Dossier or person changed during review; inspect again before retrying"); }
 }
@@ -243,6 +254,15 @@ export class PeopleStore {
           WHERE provider = ? AND account_scope = ? AND external_id = ?
         `)
                     .run(optional(input.displayName), optional(input.realName), optional(input.handle), optional(input.avatarUrl), optional(input.title), input.isBot === undefined ? null : Number(input.isBot), input.isDeactivated === undefined ? null : Number(input.isDeactivated), now, input.syncedAt ?? null, provider, accountScope, externalId);
+                const displayName = [optional(input.displayName), optional(input.realName)]
+                    .find(name => name !== null && name !== externalId);
+                if (displayName) {
+                    // Repair generated ID placeholders without renaming an established person.
+                    this.#db.prepare(`
+            UPDATE people SET display_name = ?, updated_at = ?
+            WHERE id = ? AND display_name = ? AND preferred_name IS NULL
+          `).run(displayName, now, personId, externalId);
+                }
                 if (!directorySync) {
                     this.#db
                         .prepare("UPDATE people SET last_seen_at = ?, updated_at = ? WHERE id = ?")
@@ -363,7 +383,7 @@ export class PeopleStore {
         return row ? person(row) : undefined;
     }
     validateDossier(input) {
-        const dossier = Value.Parse(PERSON_DOSSIER_SCHEMA, input);
+        const dossier = Value.Parse(PERSON_DOSSIER_WRITE_SCHEMA, input);
         this.#validateDossier(dossier);
         serializeDossier(dossier);
         return dossier;
@@ -728,12 +748,6 @@ export class PeopleStore {
         if (backgroundWordCount(dossier.blurb) > PEOPLE_BACKGROUND_MAX_WORDS) {
             throw new Error(`dossier blurb must not exceed ${PEOPLE_BACKGROUND_MAX_WORDS} words`);
         }
-        if (categories.some(category => category !== "role" && category !== "relationship")) {
-            throw new Error("New dossiers support only role and relationship background; rewrite legacy behavioral profiles");
-        }
-        if (dossier.sections.some(section => section.claims.some(claim => claim.epistemicType === "inferred" || claim.epistemicType === "agent_assessment"))) {
-            throw new Error("Background claims must be explicit observed or reported facts, not inferred profiles");
-        }
     }
     #migrate() {
         this.#db.exec("BEGIN IMMEDIATE");

package/dist/src/people-tools.js

@@ -2,7 +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 { DossierConflictError, PERSON_DOSSIER_SCHEMA } from "./people-store.js";
+import { DossierConflictError, PERSON_DOSSIER_WRITE_SCHEMA } from "./people-store.js";
 import { getContext } from "./tool-context.js";
 import { reviewPersonDossier } from "./people-dossier-review.js";
 import { createOpenClawSlackDirectory, syncSlackDirectory, } from "./slack-directory.js";
@@ -77,7 +77,7 @@ const updateParameters = Type.Union([
     Type.Object({
         action: Type.Literal("replace_dossier"),
         personId: nonEmpty,
-        dossier: PERSON_DOSSIER_SCHEMA,
+        dossier: PERSON_DOSSIER_WRITE_SCHEMA,
         reason: Type.String({ pattern: "\\S", maxLength: 500 }),
         agentName: Type.Optional(Type.String({ pattern: "\\S", maxLength: 100 })),
         manualVerification: Type.Optional(Type.String({ pattern: "\\S", maxLength: 400,
@@ -144,7 +144,7 @@ function createInspectTool(stores, config, ctx) {
     return {
         name: "memory_people_inspect",
         label: "Inspect People Memory",
-        description: "List active people, inspect one person, read dossier change history, or list actionable people todos.",
+        description: "List active people, inspect one person, read dossier change history, or list actionable people todos. injectionEligible is a record-level preview, not proof that global hooks or an already-served thread will inject.",
         parameters: inspectParameters,
         async execute(_toolCallId, raw) {
             const input = Value.Parse(inspectParameters, raw);
@@ -198,7 +198,7 @@ function createUpdateTool(stores, config, runtime, ctx) {
     return {
         name: "memory_people_update",
         label: "Update People Memory",
-        description: "Replace a background-only dossier (blurb <=70 words, role/relationship sections, observed/reported facts). Automatically reviews the blurb against claim evidence qmd://path#Lstart-Lend before saving; blocked/unavailable reviews leave it unchanged. Use explicit manualVerification only after verifying original sources yourself. Also deletes dossiers or updates injection, company, todo and person status.",
+        description: "Replace a background-only dossier (blurb <=70 words, role/relationship sections, observed/reported facts). Uses peoplePrimer approval to review the blurb against claim evidence qmd://path#Lstart-Lend before saving; blocked/unavailable reviews leave it unchanged. Use explicit manualVerification only after verifying original sources yourself. Also deletes dossiers or updates injection, company, todo and person status. Restoring a person leaves injection off; dossier changes do not reset thread receipts.",
         parameters: updateParameters,
         async execute(_toolCallId, raw, signal) {
             const input = Value.Parse(updateParameters, raw);
@@ -271,7 +271,7 @@ function createSyncTool(stores, reader, ctx) {
     return {
         name: "memory_people_sync",
         label: "Sync Slack People",
-        description: "Manually enrich this agent's people store from one OpenClaw-authenticated Slack directory account.",
+        description: "Manually enrich this agent's people store from one OpenClaw-authenticated Slack directory account (users:read). At most 200 entries from the directory start, without a continuation cursor. Skips unavailable people; deactivation disables the linked person and injection.",
         parameters: syncParameters,
         async execute(_toolCallId, raw) {
             const input = Value.Parse(syncParameters, raw);

package/dist/src/plugin.js

@@ -14,30 +14,32 @@ import { getContext } from "./tool-context.js";
 import { WhispererDiagnostics } from "./diagnostics.js";
 import { registerReviewTools } from "./review-tools.js";
 import { registerResponseAudit } from "./response-runtime.js";
-import { rerankXsearch, XSEARCH_MAX_EXCERPT_CHARS } from "./xsearch.js";
-import { abortable } from "./abortable.js";
 const searchParameters = Type.Object({
     query: Type.String({ pattern: "\\S" }),
-    corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), { minItems: 1 })),
+    corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), {
+        minItems: 1, description: 'Configured corpus names; default is all non-skill corpora. Use ["all"] alone for explicit all-corpora recall.',
+    })),
     sessionFilter: Type.Optional(Type.Object({
         startedFrom: Type.Optional(Type.String({
+            description: "Inclusive lower bound on session start time, not message or claim dates (ISO 8601).",
             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({
+            description: "Inclusive upper bound on session start time, not message or claim dates (ISO 8601).",
             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")])),
         accountId: Type.Optional(Type.String({ pattern: "\\S" })),
         conversationId: Type.Optional(Type.String({ pattern: "\\S" })),
-    }, { additionalProperties: false })),
-    maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20 })),
-    minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+    }, { additionalProperties: false, description: "Restricts session documents only; selected file corpora remain eligible. Not an audience access control." })),
+    maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Maximum hits; default 5." })),
+    minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1, description: "Minimum vector similarity; default 0.3. Not confidence in factual truth." })),
 }, { additionalProperties: false });
 const getParameters = Type.Object({
     path: Type.String({ pattern: "\\S" }),
-    from: Type.Optional(Type.Integer({ minimum: 1 })),
-    lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000 })),
+    from: Type.Optional(Type.Integer({ minimum: 1, description: "First source line, 1-based; default 1. Use nextFrom from a truncated read to continue." })),
+    lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000, description: "Requested lines; default 120, also bounded by 12,000 content characters." })),
 }, { additionalProperties: false });
 const syncSessionsParameters = Type.Object({
     force: Type.Optional(Type.Boolean()),
@@ -50,7 +52,7 @@ function createSearchTool(runtime, ctx) {
     return {
         name: "memory_search",
         label: "Memory Search",
-        description: "Search configured memory corpora with semantic vector retrieval. The isolated skills corpus is never included.",
+        description: "Search this agent's configured memory corpora with local vector retrieval, not QMD's hybrid query. Skills are excluded. Results are evidence leads; inspect source context with memory_get. Empty results or errors do not prove absence of a fact.",
         parameters: searchParameters,
         async execute(_toolCallId, params, signal) {
             const { query: untrimmedQuery, corpora, sessionFilter, maxResults, minScore, } = Value.Parse(searchParameters, params);
@@ -81,57 +83,6 @@ function createSearchTool(runtime, ctx) {
         },
     };
 }
-function createXsearchTool(runtime, ctx, config) {
-    const active = getContext(ctx);
-    if (!active)
-        return null;
-    return {
-        name: "memory_xsearch", label: "Hybrid Memory Search",
-        description: "Search approved memory corpora with vector + BM25 retrieval, deduplicate excerpts, then independently rerank with TypeSafe usefulness scores. Slower than memory_search; use for higher-precision recall. Same session filters; minScore filters final usefulness (0–1), not vector similarity. Requires xsearch opt-in and a TypeSafe key; sends query and approved excerpts to TypeSafe. Skills excluded.",
-        parameters: searchParameters,
-        async execute(_id, params, signal) {
-            const parsed = Value.Parse(searchParameters, params);
-            const query = parsed.query.trim();
-            if (!config.xsearch.enabled || !config.typesafe.enabled)
-                return jsonResult({ status: "disabled", results: [], reason: "Use memory_search instead" });
-            const requested = parsed.corpora?.map(corpus => corpus.trim());
-            const corpora = !requested || (requested.length === 1 && requested[0] === "all")
-                ? [...config.xsearch.corpora] : requested;
-            if (corpora.some(corpus => !config.xsearch.corpora.includes(corpus))) {
-                return jsonResult({ status: "unavailable", results: [], reason: "Requested corpus is not approved in xsearch.corpora" });
-            }
-            if (query.length > XSEARCH_MAX_EXCERPT_CHARS)
-                return jsonResult({ status: "unavailable", results: [], reason: "Query exceeds 12000 characters" });
-            const start = performance.now();
-            const deadline = AbortSignal.timeout(60_000);
-            const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
-            try {
-                combined.throwIfAborted();
-                const apiKey = await abortable(resolveTypeSafeApiKey(config.typesafe), combined);
-                if (!apiKey)
-                    return jsonResult({ status: "unavailable", results: [], reason: "TypeSafe API key not configured; use memory_search" });
-                const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
-                if (!manager)
-                    return jsonResult({ status: "unavailable", results: [], reason: "Memory unavailable" });
-                const maxResults = parsed.maxResults ?? 5;
-                const options = { corpora, sessionFilter: parsed.sessionFilter, maxResults: Math.ceil(maxResults * 1.5),
-                    minScore: 0, maxSnippetChars: XSEARCH_MAX_EXCERPT_CHARS, signal: combined, requestContext: active.requestContext };
-                const [vector, lexical] = await abortable(Promise.all([
-                    manager.search(query, options), manager.searchBm25(query, options),
-                ]), combined);
-                const retrievalMs = Math.round(performance.now() - start);
-                const ranked = await rerankXsearch({ query, sessionFilter: parsed.sessionFilter, vector, lexical, maxResults, minScore: parsed.minScore ?? 0,
-                    apiKey, timeoutMs: config.xsearch.timeoutMs, signal: combined });
-                return jsonResult({ ...ranked, provider: "unblock-memory", retrievalMs, totalMs: Math.round(performance.now() - start),
-                    results: ranked.results.map(result => result.session ? { ...result,
-                        session: { ...result.session, startedAt: new Date(result.session.startedAt).toISOString() } } : result) });
-            }
-            catch {
-                return jsonResult({ status: "unavailable", results: [], reason: "Hybrid search failed or was cancelled; use memory_search" });
-            }
-        },
-    };
-}
 function createGetTool(runtime, ctx) {
     const active = getContext(ctx);
     if (!active)
@@ -139,7 +90,7 @@ function createGetTool(runtime, ctx) {
     return {
         name: "memory_get",
         label: "Memory Get",
-        description: "Read an exact qmd:// path returned by memory_search or memory_xsearch.",
+        description: "Read an exact indexed qmd:// source path returned by memory tools. Defaults to 120 lines, bounded to 12,000 content characters. Check truncated/nextFrom and continue when present; not_found or unavailable is not a successful empty read.",
         parameters: getParameters,
         async execute(_toolCallId, params) {
             const { path: untrimmedPath, from, lines } = Value.Parse(getParameters, params);
@@ -480,7 +431,7 @@ export function registerUnblockMemory(api) {
         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 to verify source context, attribution and dates. Follow read continuation when present. Empty search is not proof of absence; historical memory is not current authorization.",
             ]
             : [],
         flushPlanResolver: resolveFlushPlan,
@@ -507,7 +458,6 @@ export function registerUnblockMemory(api) {
     registerSkillWhisperer(api, runtime, config.skillWhisperer, config.typesafe, diagnostics);
     registerMemoryWhisperer(api, runtime, config.memoryWhisperer, config.typesafe, diagnostics);
     api.registerTool((ctx) => createSearchTool(runtime, ctx), { names: ["memory_search"] });
-    api.registerTool((ctx) => createXsearchTool(runtime, ctx, config), { names: ["memory_xsearch"] });
     api.registerTool((ctx) => createGetTool(runtime, ctx), { names: ["memory_get"] });
     api.registerTool((ctx) => createSyncSessionsTool(runtime, ctx), {
         names: ["memory_sync_sessions"],

package/dist/src/slack-directory.js

@@ -95,7 +95,8 @@ export async function syncSlackDirectory(params) {
         }
         try {
             const existing = params.store.findIdentity("slack", params.accountId, externalId);
-            if (existing && params.store.getPerson(existing.personId)?.status !== "active") {
+            const existingPerson = existing ? params.store.getPerson(existing.personId) : undefined;
+            if (existing && existingPerson?.status !== "active") {
                 counts.skipped += 1;
                 continue;
             }
@@ -118,7 +119,7 @@ export async function syncSlackDirectory(params) {
             });
             if (result.created)
                 counts.created += 1;
-            else if (changed)
+            else if (changed || result.person.displayName !== existingPerson?.displayName)
                 counts.updated += 1;
             else
                 counts.unchanged += 1;