@unblocklabs/unblock-memory 0.3.26 → 0.3.28

package/dist/src/mlx-query.d.ts

@@ -0,0 +1,22 @@
+import type { UnblockMemoryConfig } from "./config.js";
+type Conversation = {
+    history: {
+        role: "user" | "assistant";
+        content: string;
+    }[];
+    currentRequest: string;
+};
+/** Preserve whole visible messages and the complete current request, never tool/thinking text. */
+export declare function queryConversation(prompt: string, messages: readonly unknown[], historyMessages: number): Conversation;
+export declare class MlxQueryGenerator {
+    #private;
+    private readonly config;
+    /** Gateway hook and tool registries can evaluate/register this plugin separately. */
+    static shared(config: NonNullable<UnblockMemoryConfig["memoryWhisperer"]["mlx"]>): MlxQueryGenerator;
+    constructor(config: NonNullable<UnblockMemoryConfig["memoryWhisperer"]["mlx"]>);
+    get closed(): boolean;
+    start(): Promise<void>;
+    generate(conversation: Conversation, signal: AbortSignal): Promise<string[]>;
+    close(): void;
+}
+export {};

package/dist/src/mlx-query.js

@@ -0,0 +1,155 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+import { abortable } from "./abortable.js";
+import { messageText } from "./whisperer-context.js";
+import { conversationUserText } from "./response-text.js";
+/** Preserve whole visible messages and the complete current request, never tool/thinking text. */
+export function queryConversation(prompt, messages, historyMessages) {
+    const currentRequest = conversationUserText(prompt)?.text ?? "";
+    const visible = messages.flatMap(message => {
+        const text = messageText(message);
+        const content = text?.role === "user" ? conversationUserText(text.text)?.text : text?.text;
+        return text && content ? [{ role: text.role, content }] : [];
+    });
+    if (visible.at(-1)?.role === "user" && visible.at(-1)?.content === currentRequest)
+        visible.pop();
+    const history = historyMessages ? visible.slice(-historyMessages) : [];
+    while (history.length && Buffer.byteLength(JSON.stringify({ history, currentRequest })) > 24_000)
+        history.shift();
+    if (!currentRequest)
+        throw new Error("Missing or unparseable current request");
+    if (Buffer.byteLength(JSON.stringify({ history, currentRequest })) > 24_000) {
+        throw new Error("Query input exceeds context budget");
+    }
+    return { history, currentRequest };
+}
+export class MlxQueryGenerator {
+    config;
+    /** Gateway hook and tool registries can evaluate/register this plugin separately. */
+    static shared(config) {
+        const scope = globalThis;
+        const symbol = Symbol.for("unblock-memory.mlx-workers.v1");
+        const workers = (scope[symbol] ??= new Map());
+        const key = JSON.stringify([config.pythonPath, config.modelPath]);
+        let worker = workers.get(key);
+        if (!worker || worker.closed) {
+            worker = new MlxQueryGenerator(config);
+            workers.set(key, worker);
+        }
+        return worker;
+    }
+    #child;
+    #ready;
+    #closed = false;
+    #retryAfter = 0;
+    #pending = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    get closed() { return this.#closed; }
+    start() {
+        if (this.#closed)
+            return Promise.reject(new Error("Query worker stopped"));
+        if (this.#ready)
+            return this.#ready;
+        if (Date.now() < this.#retryAfter)
+            return Promise.reject(new Error("Query worker restarting"));
+        const adjacent = new URL("./mlx-query-worker.py", import.meta.url);
+        const script = existsSync(adjacent) ? adjacent : new URL("../../src/mlx-query-worker.py", import.meta.url);
+        const child = spawn(this.config.pythonPath, ["-u", fileURLToPath(script), this.config.modelPath], {
+            stdio: "pipe", env: { ...process.env, HF_HUB_OFFLINE: "1", TRANSFORMERS_OFFLINE: "1", TOKENIZERS_PARALLELISM: "false" },
+        });
+        this.#child = child;
+        // No source text from Python warnings/exceptions enters Gateway logs.
+        child.stderr.resume();
+        const lines = createInterface({ input: child.stdout });
+        this.#ready = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => child.kill(), 60_000);
+            const fail = () => {
+                clearTimeout(timer);
+                lines.close();
+                reject(new Error("Query worker unavailable"));
+                if (this.#child !== child)
+                    return;
+                this.#child = undefined;
+                this.#ready = undefined;
+                this.#retryAfter = Date.now() + 2000;
+                for (const request of this.#pending.values())
+                    request.reject(new Error("Query worker unavailable"));
+                this.#pending.clear();
+            };
+            child.once("error", fail);
+            child.once("close", fail);
+            child.stdin.on("error", () => child.kill());
+            lines.on("line", line => {
+                try {
+                    const value = JSON.parse(line);
+                    if (!value || typeof value !== "object")
+                        throw new Error("Invalid worker response");
+                    if ("ready" in value && value.ready === true) {
+                        clearTimeout(timer);
+                        resolve();
+                        return;
+                    }
+                    if (!("id" in value) || typeof value.id !== "string")
+                        throw new Error("Missing worker request ID");
+                    const request = this.#pending.get(value.id);
+                    if (!request)
+                        return; // Cancelled request; never surface late results.
+                    this.#pending.delete(value.id);
+                    if (!("text" in value) || typeof value.text !== "string") {
+                        request.reject(new Error("Query generation failed"));
+                        return;
+                    }
+                    let queries;
+                    try {
+                        queries = JSON.parse(value.text).queries;
+                    }
+                    catch { /* reject below */ }
+                    const usable = Array.isArray(queries) ? [...new Set(queries
+                            .filter((query) => typeof query === "string")
+                            .map(query => query.trim()).filter(Boolean))] : [];
+                    if (!usable.length) {
+                        request.reject(new Error("No usable generated queries"));
+                        return;
+                    }
+                    request.resolve(usable);
+                }
+                catch {
+                    child.kill();
+                }
+            });
+        });
+        return this.#ready;
+    }
+    async generate(conversation, signal) {
+        await abortable(this.start(), signal);
+        signal.throwIfAborted();
+        if (this.#pending.size >= 8)
+            throw new Error("Query worker busy");
+        const id = randomUUID();
+        const child = this.#child;
+        const result = new Promise((resolve, reject) => this.#pending.set(id, { resolve, reject }));
+        const cancel = () => {
+            this.#pending.get(id)?.reject(new Error("Query generation cancelled"));
+            this.#pending.delete(id);
+            if (child.stdin.writable)
+                child.stdin.write(JSON.stringify({ id, cancel: true }) + "\n");
+        };
+        signal.addEventListener("abort", cancel, { once: true });
+        child.stdin.write(JSON.stringify({ id, conversation }) + "\n");
+        try {
+            return await result;
+        }
+        finally {
+            signal.removeEventListener("abort", cancel);
+        }
+    }
+    close() {
+        this.#closed = true;
+        this.#child?.kill();
+    }
+}

package/dist/src/people-dossier-review.js

@@ -1,6 +1,6 @@
 import { resolveAgentIdentity } from "openclaw/plugin-sdk/agent-runtime";
 import { abortable } from "./abortable.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 /** Review the injected blurb using only exact indexed references already on its claims. */
 export async function reviewPersonDossier(params) {
     const unavailable = (reason) => ({ status: "unavailable", needsReview: true, reason });

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

@@ -2,4 +2,4 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
 import type { UnblockMemoryConfig } from "./config.js";
 import type { PeopleStores } from "./people-store.js";
 export declare function renderPeopleWhisper(blurb: string, maxChars: number): string | undefined;
-export declare function registerPeopleHooks(api: OpenClawPluginApi, stores: PeopleStores, config: UnblockMemoryConfig["people"]): void;
+export declare function registerPeopleHooks(api: OpenClawPluginApi, stores: PeopleStores, config: UnblockMemoryConfig["people"]): Parameters<typeof api.on<"before_prompt_build">>[1] | undefined;

package/dist/src/people-hooks.js

@@ -20,6 +20,11 @@ export function renderPeopleWhisper(blurb, maxChars) {
     const normalized = blurb.trim();
     return normalized ? normalized.slice(0, maxChars) : undefined;
 }
+function peopleContext(contribution) {
+    // Escape only at output: durable receipts retain the original dossier text.
+    const text = contribution.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+    return { appendContext: `<people>${text}</people>` };
+}
 export function registerPeopleHooks(api, stores, config) {
     const threadByRun = new Map();
     const pendingThreadByIdentity = new Map();
@@ -83,7 +88,7 @@ export function registerPeopleHooks(api, stores, config) {
     });
     if (!config.whisperer.enabled)
         return;
-    api.on("before_prompt_build", (_event, context) => {
+    const beforePrompt = (_event, context) => {
         if (context.trigger !== "user" || context.messageProvider !== "slack")
             return;
         const sessionKey = nonBlank(context.sessionKey);
@@ -112,30 +117,31 @@ export function registerPeopleHooks(api, stores, config) {
                 return;
             const previous = store.getWhisperReceipt(threadKey, person.id);
             if (previous) {
-                return previous.runId === runId ? { prependContext: previous.contribution } : undefined;
+                return previous.runId === runId ? peopleContext(previous.contribution) : undefined;
             }
             const blurb = store.getDossierBlurb(person.id);
-            const prependContext = blurb
+            const contribution = blurb
                 ? renderPeopleWhisper(blurb, config.whisperer.maxChars)
                 : undefined;
-            if (!prependContext)
+            if (!contribution)
                 return;
             const receipt = store.recordWhisperReceipt({
                 threadKey,
                 personId: person.id,
                 runId,
-                contribution: prependContext,
+                contribution,
             });
-            return receipt.runId === runId ? { prependContext: receipt.contribution } : undefined;
+            return receipt.runId === runId ? peopleContext(receipt.contribution) : undefined;
         }
         catch (error) {
             api.logger.warn(`unblock-memory people whisperer lookup failed: ${String(error)}`);
             return;
         }
-    });
+    };
     api.on("agent_end", (event, context) => {
         const runId = nonBlank(event.runId) ?? nonBlank(context.runId);
         if (runId)
             threadByRun.delete(runId);
     });
+    return beforePrompt;
 }

package/dist/src/people-primer-tool.js

@@ -2,7 +2,7 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { jsonResult, resolveAgentIdentity } from "openclaw/plugin-sdk/agent-runtime";
 import { getContext } from "./tool-context.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { primePersonDossier } from "./people-primer.js";
 import { abortable } from "./abortable.js";
 import { backgroundWordCount, PEOPLE_BACKGROUND_MAX_WORDS } from "./people-background.js";

package/dist/src/people-primer.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { askTypeSafeReview, TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
+import { requestTypeSafe } from "./typesafe-client.js";
+import { TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
 import { abortable } from "./abortable.js";
 const VERSION = "people-primer-background-v4";
 const MAX_EXCERPT_CHARS = 6000;
@@ -112,7 +113,7 @@ export async function primePersonDossier(params) {
                     cached++;
                 else {
                     requests++;
-                    payload = await askTypeSafeReview({ apiKey: params.apiKey, timeoutMs: config.timeoutMs, signal }, state, questions);
+                    payload = await requestTypeSafe({ apiKey: params.apiKey, timeoutMs: config.timeoutMs, signal }, state, questions);
                     signal.throwIfAborted();
                     if (!valid(payload) || !Value.Check(answerSchema, payload))
                         throw new Error("Invalid primer judgments");

package/dist/src/plugin.js

@@ -2,7 +2,7 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveConfig } from "./config.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { registerPeopleHooks } from "./people-hooks.js";
 import { PeopleStores } from "./people-store.js";
 import { registerPeopleTools } from "./people-tools.js";
@@ -10,6 +10,7 @@ import { registerPeoplePrimerTool } from "./people-primer-tool.js";
 import { QmdMemoryRuntime } from "./runtime.js";
 import { registerSkillWhisperer } from "./skill-whisperer.js";
 import { registerMemoryWhisperer } from "./memory-whisperer.js";
+import { registerWhispererPrompt } from "./whisperer-prompt.js";
 import { getContext } from "./tool-context.js";
 import { WhispererDiagnostics } from "./diagnostics.js";
 import { registerReviewTools } from "./review-tools.js";
@@ -438,19 +439,23 @@ export function registerUnblockMemory(api) {
         }));
         api.on("gateway_stop", () => runtime.stopSessionSyncSchedule());
     }
+    let peopleWhisperer;
     if (config.people.enabled) {
         const peopleStores = new PeopleStores({
             maxOpenTodos: config.people.todos.maxOpen,
             maxBlurbChars: config.people.whisperer.maxChars,
         });
-        registerPeopleHooks(api, peopleStores, config.people);
+        peopleWhisperer = registerPeopleHooks(api, peopleStores, config.people);
         registerPeopleTools(api, peopleStores, config, runtime);
         registerPeoplePrimerTool(api, runtime, peopleStores, config);
         api.on("gateway_stop", () => peopleStores.closeAll());
     }
-    const diagnostics = new WhispererDiagnostics();
-    registerSkillWhisperer(api, runtime, config.skillWhisperer, config.typesafe, diagnostics);
-    registerMemoryWhisperer(api, runtime, config.memoryWhisperer, config.typesafe, diagnostics);
+    const diagnostics = WhispererDiagnostics.shared();
+    registerWhispererPrompt(api, {
+        memory: registerMemoryWhisperer(api, runtime, config.memoryWhisperer, config.typesafe, diagnostics),
+        skill: registerSkillWhisperer(api, runtime, config.skillWhisperer, config.typesafe, diagnostics),
+        people: peopleWhisperer,
+    });
     api.registerTool((ctx) => createSearchTool(runtime, ctx), { names: ["memory_search"] });
     api.registerTool((ctx) => createGetTool(runtime, ctx), { names: ["memory_get"] });
     api.registerTool((ctx) => createSyncSessionsTool(runtime, ctx), {

package/dist/src/quality-audit.js

@@ -3,7 +3,6 @@ import { parseSafeVirtualPath } from "./sources.js";
 import { judgeTypeSafeQuality, QUALITY_JUDGE_VERSION } from "./typesafe.js";
 import { qualityTriage } from "./quality-triage.js";
 const MAX_CHUNK_CHARS = 6000;
-const BATCH_SIZE = 4;
 /** A formatting clue, never proof that JSON or structured data is worthless. */
 export function qualityStructure(text) {
     if (!text.trim())
@@ -61,89 +60,95 @@ export async function auditQualityPage(params) {
       AND cv.seq = ? AND cv.pos = ? AND cv.chunk_len = ?`);
     const page = rows.slice(0, limit);
     try {
-        for (let offset = 0; offset < page.length; offset += BATCH_SIZE) {
-            check();
-            const batch = page.slice(offset, offset + BATCH_SIZE).map(row => {
-                const source = sources.get(row.collection);
-                const text = row.doc.slice(row.pos, row.pos + row.chunk_len);
-                const fingerprint = chunkFingerprint(text);
-                const cacheKey = chunkFingerprint(JSON.stringify([QUALITY_JUDGE_VERSION, source.kind, fingerprint]));
-                const eligible = Boolean(parseSafeVirtualPath(`qmd://${source.collection}/${row.path}`, sources)) && row.pos >= 0 && row.chunk_len > 0 &&
-                    row.pos + row.chunk_len <= row.doc.length;
-                const structure = qualityStructure(text);
-                const judgment = eligible && text.length <= MAX_CHUNK_CHARS
-                    ? curation.qualityJudgment(cacheKey) : undefined;
-                return { row, source, text, fingerprint, cacheKey, structure, judgment, eligible };
-            });
-            const missing = [...new Map(batch.filter(item => item.eligible && item.text.length <= MAX_CHUNK_CHARS &&
-                    item.structure !== "empty" && !item.judgment).map(item => [item.cacheKey, item])).values()];
-            const answers = await judgeTypeSafeQuality({
-                apiKey: params.apiKey, timeoutMs: params.timeoutMs, signal,
-                chunks: missing.map(item => ({ text: item.text, sourceKind: item.source.kind === "sessions" ? "sessions" : "files" })),
-            });
+        check();
+        const batch = page.map(row => {
+            const source = sources.get(row.collection);
+            const text = row.doc.slice(row.pos, row.pos + row.chunk_len);
+            const fingerprint = chunkFingerprint(text);
+            const cacheKey = chunkFingerprint(JSON.stringify([QUALITY_JUDGE_VERSION, source.kind, fingerprint]));
+            const eligible = Boolean(parseSafeVirtualPath(`qmd://${source.collection}/${row.path}`, sources)) && row.pos >= 0 && row.chunk_len > 0 &&
+                row.pos + row.chunk_len <= row.doc.length;
+            const structure = qualityStructure(text);
+            const judgment = eligible && text.length <= MAX_CHUNK_CHARS
+                ? curation.qualityJudgment(cacheKey) : undefined;
+            return { row, source, text, fingerprint, cacheKey, structure, judgment, eligible };
+        });
+        const missing = [...new Map(batch.filter(item => item.eligible && item.text.length <= MAX_CHUNK_CHARS &&
+                item.structure !== "empty" && !item.judgment).map(item => [item.cacheKey, item])).values()];
+        const answers = await Promise.allSettled(missing.map(async (item) => (await judgeTypeSafeQuality({
+            apiKey: params.apiKey, timeoutMs: params.timeoutMs, signal,
+            chunks: [{ text: item.text, sourceKind: item.source.kind === "sessions" ? "sessions" : "files" }],
+        }))[0]));
+        check();
+        const fresh = new Map();
+        for (const [index, answer] of answers.entries()) {
+            if (answer.status !== "fulfilled")
+                continue;
+            const { cacheKey, row } = missing[index];
+            if (!current.get(row.document_id, row.collection, row.path, row.hash, row.seq, row.pos, row.chunk_len))
+                continue;
+            fresh.set(cacheKey, answer.value);
+            // Keep successful sibling judgments even if the cursor stops at a failed candidate.
+            curation.cacheQualityJudgment(cacheKey, answer.value);
+            judged++;
+        }
+        for (const item of batch) {
             check();
-            const fresh = new Map(missing.map((item, index) => [item.cacheKey, answers[index]]));
-            judged += answers.length;
-            for (const item of batch) {
-                check();
-                const { row, source, text, fingerprint, cacheKey, structure } = item;
-                const advance = () => { next = { documentId: row.document_id, seq: row.seq }; };
-                scanned++;
-                if (!item.eligible || !parseSafeVirtualPath(`qmd://${source.collection}/${row.path}`, sources) ||
-                    !current.get(row.document_id, row.collection, row.path, row.hash, row.seq, row.pos, row.chunk_len)) {
-                    skippedStale++;
-                    advance();
-                    continue;
-                }
-                if (text.length > MAX_CHUNK_CHARS) {
-                    skippedOversized++;
-                    advance();
-                    continue;
-                }
-                const judgment = structure === "empty"
-                    ? { noise: 1, evidence: 0 } : item.judgment ?? fresh.get(cacheKey);
-                if (!judgment)
-                    throw new Error("missing quality judgment");
-                if (item.judgment)
-                    cached++;
-                else if (structure !== "empty")
-                    curation.cacheQualityJudgment(cacheKey, judgment);
-                if (structure !== "empty" && structure !== "encoded_message" && judgment.noise < params.minNoise) {
-                    advance();
-                    continue;
-                }
-                const reason = structure === "empty" ? "empty_content" :
-                    structure === "encoded_message" ? "possible_double_encoded_message" :
-                        structure === "serialized_message" ? "possible_serialized_message" : "possible_ingestion_noise";
-                const startLine = row.doc.slice(0, row.pos).split("\n").length;
-                const endLine = startLine + text.split("\n").length - 1;
-                const task = curation.addTask({
-                    type: "quality_review", corpus: source.corpus, collection: source.collection,
-                    path: row.path, reason, contentFingerprint: fingerprint,
-                    detail: JSON.stringify({
-                        path: `qmd://${source.collection}/${row.path}`, from: startLine, to: endLine,
-                        excerpt: text.slice(0, 400), excerptTruncated: text.length > 400,
-                        indicator: structure === "empty" ? "deterministic_empty" :
-                            structure === "encoded_message" ? "deterministic_encoding" : "typesafe",
-                        ...judgment, policy: QUALITY_JUDGE_VERSION,
-                        triage: qualityTriage(judgment.noise, judgment.evidence, structure === "encoded_message"),
-                        instruction: "Inspect original source and ingestion before acting. Verify source/index after any authorized repair. Never manually edit generated session projections.",
-                    }),
-                });
-                flagged++;
+            const { row, source, text, fingerprint, cacheKey, structure } = item;
+            const advance = () => { next = { documentId: row.document_id, seq: row.seq }; };
+            scanned++;
+            if (!item.eligible || !parseSafeVirtualPath(`qmd://${source.collection}/${row.path}`, sources) ||
+                !current.get(row.document_id, row.collection, row.path, row.hash, row.seq, row.pos, row.chunk_len)) {
+                skippedStale++;
                 advance();
-                if (task.status !== "pending")
-                    continue;
-                const triage = qualityTriage(judgment.noise, judgment.evidence, structure === "encoded_message");
-                const key = JSON.stringify([source.collection, reason, triage]);
-                const group = groups.get(key) ?? {
-                    corpus: source.corpus, source: source.configuredPath, reason, triage, pending: 0, examples: [],
-                };
-                group.pending++;
-                if (group.examples.length < 3)
-                    group.examples.push(task);
-                groups.set(key, group);
+                continue;
             }
+            if (text.length > MAX_CHUNK_CHARS) {
+                skippedOversized++;
+                advance();
+                continue;
+            }
+            const judgment = structure === "empty"
+                ? { noise: 1, evidence: 0 } : item.judgment ?? fresh.get(cacheKey);
+            if (!judgment)
+                throw new Error("missing quality judgment");
+            if (item.judgment)
+                cached++;
+            if (structure !== "empty" && structure !== "encoded_message" && judgment.noise < params.minNoise) {
+                advance();
+                continue;
+            }
+            const reason = structure === "empty" ? "empty_content" :
+                structure === "encoded_message" ? "possible_double_encoded_message" :
+                    structure === "serialized_message" ? "possible_serialized_message" : "possible_ingestion_noise";
+            const startLine = row.doc.slice(0, row.pos).split("\n").length;
+            const endLine = startLine + text.split("\n").length - 1;
+            const task = curation.addTask({
+                type: "quality_review", corpus: source.corpus, collection: source.collection,
+                path: row.path, reason, contentFingerprint: fingerprint,
+                detail: JSON.stringify({
+                    path: `qmd://${source.collection}/${row.path}`, from: startLine, to: endLine,
+                    excerpt: text.slice(0, 400), excerptTruncated: text.length > 400,
+                    indicator: structure === "empty" ? "deterministic_empty" :
+                        structure === "encoded_message" ? "deterministic_encoding" : "typesafe",
+                    ...judgment, policy: QUALITY_JUDGE_VERSION,
+                    triage: qualityTriage(judgment.noise, judgment.evidence, structure === "encoded_message"),
+                    instruction: "Inspect original source and ingestion before acting. Verify source/index after any authorized repair. Never manually edit generated session projections.",
+                }),
+            });
+            flagged++;
+            advance();
+            if (task.status !== "pending")
+                continue;
+            const triage = qualityTriage(judgment.noise, judgment.evidence, structure === "encoded_message");
+            const key = JSON.stringify([source.collection, reason, triage]);
+            const group = groups.get(key) ?? {
+                corpus: source.corpus, source: source.configuredPath, reason, triage, pending: 0, examples: [],
+            };
+            group.pending++;
+            if (group.examples.length < 3)
+                group.examples.push(task);
+            groups.set(key, group);
         }
         return result("ok", rows.length <= limit);
     }

package/dist/src/response-audit.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { abortable } from "./abortable.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { RESPONSE_EXTRACTOR_VERSION, ResponseTranscriptReader } from "./response-episodes.js";
 import { RESPONSE_RUBRIC_VERSION, RESPONSE_STAGE_VERSIONS, judgeMemoryOpportunity } from "./response-judge.js";
 import { ResponseAuditStore } from "./response-store.js";

package/dist/src/response-judge.d.ts

@@ -6,7 +6,7 @@ export declare const RESPONSE_STAGE_VERSIONS: {
     readonly feedback: "feedback-v9";
     readonly sentiment: "sentiment-v10";
     readonly retrospective: "retrospective-v9";
-    readonly memory: "memory-v1";
+    readonly memory: "memory-v2-isolated";
 };
 declare const qualitySchema: Type.TObject<{
     answers: Type.TObject<{

package/dist/src/response-judge.js

@@ -1,8 +1,9 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { askTypeSafeReview, TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
+import { requestTypeSafe } from "./typesafe-client.js";
+import { TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
 export const RESPONSE_RUBRIC_VERSION = `${TYPESAFE_REVIEW_MODEL}:response-v10`;
-export const RESPONSE_STAGE_VERSIONS = { quality: "quality-v9", feedback: "feedback-v9", sentiment: "sentiment-v10", retrospective: "retrospective-v9", memory: "memory-v1" };
+export const RESPONSE_STAGE_VERSIONS = { quality: "quality-v9", feedback: "feedback-v9", sentiment: "sentiment-v10", retrospective: "retrospective-v9", memory: "memory-v2-isolated" };
 const probability = Type.Number({ minimum: 0, maximum: 1 });
 const noul = Type.Object({ type: Type.Literal("noul"), noul: probability });
 const score = Type.Object({ type: Type.Literal("score"), score: Type.Number({ minimum: 0, maximum: 3 }),
@@ -73,7 +74,7 @@ export async function judgeResponse(episode, params, sentimentEnabled = true, ca
         contextLimited: episode.contextLimited, evidenceLimit: "Visible conversation only. Artifacts, tool results and external facts are not provided." };
     if (!cache?.quality)
         cache?.begin(["quality"]);
-    const qualityPayload = cache?.quality ? { answers: cache.quality } : await askTypeSafeReview(params, state, {
+    const qualityPayload = cache?.quality ? { answers: cache.quality } : await requestTypeSafe(params, state, {
         underdelivery: { type: "noul", instructions: { question: "Does the visible `answer` CLEARLY underdeliver on what the human explicitly asked for in `request`, given `before`?",
                 required: "Identify a concrete unmet requirement, wrong product, explicit constraint violation, materially shallow answer or unjustified deferral. Judge delivery, not politeness or writing style.",
                 exclusions: "Missing verification of unseen work is uncertainty, not failure. Necessary clarification, legitimate safety/approval boundaries, honest blockers and newly added requirements are not underdelivery. Do not infer a failure from memory-search counts or unseen tool activity.", trust } },
@@ -142,7 +143,7 @@ export async function judgeResponse(episode, params, sentimentEnabled = true, ca
     };
     const questions = Object.fromEntries(Object.entries(feedbackQuestions).filter(([key]) => Object.hasOwn(sentimentSchema.properties, key) ? needSentiment : needFeedback));
     cache?.begin([...(needFeedback ? ["feedback"] : []), ...(needSentiment ? ["sentiment"] : [])]);
-    const feedbackPayload = await askTypeSafeReview(params, { ...state, feedback: episode.feedback }, questions);
+    const feedbackPayload = await requestTypeSafe(params, { ...state, feedback: episode.feedback }, questions);
     const base = needFeedback ? feedbackPayload : { answers: cache.feedback };
     if (!Value.Check(feedbackSchema, base))
         throw new Error("Invalid response feedback judgment");
@@ -188,7 +189,7 @@ const retrospectiveSchema = Type.Object({ answers: Type.Object({ correction: nou
 /** Later evidence is kept in a third request and never changes the original grade. */
 export async function judgeResponseFollowup(episode, params) {
     const later = ["complete", "partial"].includes(episode.followup.status) ? episode.followup.messages : [];
-    const payload = await askTypeSafeReview(params, { before: episode.before, originalRequest: episode.request, originalAnswer: episode.answer,
+    const payload = await requestTypeSafe(params, { before: episode.before, originalRequest: episode.request, originalAnswer: episode.answer,
         humanReply: episode.feedback, nextAssistantResponse: later, evidenceStatus: episode.followup.status }, {
         outcome: { type: "choice", instructions: { question: "What does the available conversation establish about delivery of the ORIGINAL request by originalAnswer?",
                 method: "Match each complaint or admission to a concrete requirement or claim in originalRequest/originalAnswer, using before only to resolve existing requirements. Grade the original answer, not the later repair. A concrete shortfall takes precedence over praise.",
@@ -233,16 +234,18 @@ export async function judgeResponseFollowup(episode, params) {
     return { status: episode.followup.status, judgment: payload.answers };
 }
 export async function judgeMemoryOpportunity(episode, candidates, params) {
-    const questions = Object.fromEntries(candidates.map((_c, i) => [`candidate_${i}`, { type: "noul",
-            instructions: { question: `Would the information in \`candidates[${i}]\` materially address the specific context gap expressed in \`feedback\` about \`answer\`?`,
-                limits: "Judge substantive relevance, not shared vocabulary. These are CURRENT indexed excerpts; their presence does not prove historical availability, truth, or agent fault.", trust } }]));
+    const questions = { candidate_0: { type: "noul",
+            instructions: { question: "Would the information in `candidates[0]` materially address the specific context gap expressed in `feedback` about `answer`?",
+                limits: "Judge substantive relevance, not shared vocabulary. This is a CURRENT indexed excerpt; its presence does not prove historical availability, truth, or agent fault.", trust } } };
     if (!candidates.length)
         return [];
-    const payload = await askTypeSafeReview(params, { request: episode.request, answer: episode.answer,
-        feedback: episode.feedback, candidates: candidates.map(c => ({ text: c.text })) }, questions);
-    const schema = Type.Object({ answers: Type.Object(Object.fromEntries(candidates.map((_c, i) => [`candidate_${i}`, noul]))) });
-    if (!Value.Check(schema, payload))
-        throw new Error("Invalid memory opportunity judgment");
-    return candidates.map((c, i) => ({ path: c.path, hash: c.hash, usefulness: payload.answers[`candidate_${i}`].noul,
-        basis: "current_index_only; historical availability and retrieval exposure unknown" }));
+    const schema = Type.Object({ answers: Type.Object({ candidate_0: noul }, { additionalProperties: false }) });
+    return Promise.all(candidates.map(async (candidate) => {
+        const payload = await requestTypeSafe(params, { request: episode.request, answer: episode.answer,
+            feedback: episode.feedback, candidates: [{ text: candidate.text }] }, questions);
+        if (!Value.Check(schema, payload))
+            throw new Error("Invalid memory opportunity judgment");
+        return { path: candidate.path, hash: candidate.hash, usefulness: payload.answers.candidate_0.noul,
+            basis: "current_index_only; historical availability and retrieval exposure unknown" };
+    }));
 }