@unblocklabs/unblock-memory 0.3.27 → 0.3.29

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-episodes.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
+import { ACTIVE_EVENT_COUNT_SQL, ACTIVE_EVENT_ROWS_SQL, assertAgentTranscriptSchema } from "./agent-transcript.js";
 import { messageText } from "./whisperer-context.js";
 import { responseUserText } from "./response-text.js";
 export const RESPONSE_EXTRACTOR_VERSION = 5;
@@ -182,11 +183,7 @@ export class ResponseTranscriptReader {
         this.#db = new DatabaseSync(path, { readOnly: true });
         try {
             this.#db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000");
-            const version = this.#db.prepare("PRAGMA user_version").get()?.user_version;
-            const meta = this.#db.prepare("SELECT role,agent_id,schema_version FROM schema_meta WHERE meta_key='primary'").get();
-            if (![17, 18, 19].includes(Number(version)) || meta?.role !== "agent" || meta.agent_id !== agentId || meta.schema_version !== version) {
-                throw new Error("Unsupported response-audit transcript schema or agent");
-            }
+            assertAgentTranscriptSchema(this.#db, agentId, "Unsupported response-audit transcript schema or agent");
         }
         catch (error) {
             this.#db.close();
@@ -219,14 +216,10 @@ export class ResponseTranscriptReader {
                 return null;
             const session = { sessionId, accountId: String(window.accountId),
                 conversationId: String(window.conversationId), chatType: String(window.chatType) };
-            const count = this.#db.prepare(`SELECT COUNT(*) n,COALESCE(SUM(length(e.event_json)),0) bytes
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=?`).get(session.sessionId);
+            const count = this.#db.prepare(ACTIVE_EVENT_COUNT_SQL).get(session.sessionId);
             if (Number(count.n) > MAX_EVENTS || Number(count.bytes) > MAX_SESSION_BYTES)
                 return undefined;
-            const rows = this.#db.prepare(`SELECT e.seq,e.event_json eventJson,e.created_at createdAt
-        FROM session_transcript_active_events a JOIN transcript_events e ON e.session_id=a.session_id AND e.seq=a.event_seq
-        WHERE a.session_id=? ORDER BY a.active_position`).all(session.sessionId);
+            const rows = this.#db.prepare(ACTIVE_EVENT_ROWS_SQL).all(session.sessionId);
             // Exact active content catches in-place edits and branch changes even when writer
             // watermarks are absent. Raw text is never retained in the checkpoint database.
             const revision = hash([RESPONSE_EXTRACTOR_VERSION, session, config.historyMessages, [...config.senderIds].sort(), rows]);

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" };
+    }));
 }

package/dist/src/response-runtime.js

@@ -6,14 +6,7 @@ import { normalizeAgentIdStrict } from "openclaw/plugin-sdk/routing";
 import { resolveSources } from "./sources.js";
 import { auditResponses, responseCohort } from "./response-audit.js";
 import { ResponseAuditStore } from "./response-store.js";
-function dateOption(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
-        throw new Error("Dates must be valid YYYY-MM-DD UTC dates");
-    }
-    return Date.parse(value);
-}
+import { dateOption } from "./date-option.js";
 export function registerResponseAudit(api, config) {
     const options = (cfg, id) => {
         const normalized = normalizeAgentIdStrict(id);

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

@@ -50,8 +50,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
     quality: {
         taskType: {
             type: "choice";
-            choice: "action" | "question" | "artifact" | "discussion" | "other";
             confidence: number;
+            choice: "action" | "question" | "artifact" | "discussion" | "other";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -59,8 +59,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         };
         assessability: {
             type: "choice";
-            choice: "assessable" | "not_assessable";
             confidence: number;
+            choice: "assessable" | "not_assessable";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -68,8 +68,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         };
         fitAssessability: {
             type: "choice";
-            choice: "assessable" | "not_assessable";
             confidence: number;
+            choice: "assessable" | "not_assessable";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -81,8 +81,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         };
         failureReason: {
             type: "choice";
-            choice: "none_or_unclear" | "missing_requested_work" | "wrong_deliverable" | "missed_constraint" | "insufficient_answer_depth" | "unnecessary_deferral";
             confidence: number;
+            choice: "none_or_unclear" | "missing_requested_work" | "wrong_deliverable" | "missed_constraint" | "insufficient_answer_depth" | "unnecessary_deferral";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -112,8 +112,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         };
         consistency: {
             type: "choice";
-            choice: "not_assessable" | "consistent" | "contradicted";
             confidence: number;
+            choice: "not_assessable" | "consistent" | "contradicted";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -123,8 +123,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
     feedback: {
         feedbackType: {
             type: "choice";
-            choice: "mixed" | "unrelated" | "unclear" | "acceptance" | "correction" | "continuation";
             confidence: number;
+            choice: "mixed" | "unrelated" | "unclear" | "acceptance" | "correction" | "continuation";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -132,8 +132,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         };
         target: {
             type: "choice";
-            choice: "delivery" | "mixed" | "unclear" | "current_answer" | "earlier_behavior" | "proactive_action" | "external" | "new_work";
             confidence: number;
+            choice: "delivery" | "mixed" | "unclear" | "current_answer" | "earlier_behavior" | "proactive_action" | "external" | "new_work";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -154,8 +154,8 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
     } & Partial<{
         sentiment: {
             type: "choice";
-            choice: "satisfied" | "dissatisfied" | "mixed" | "neutral" | "unrelated" | "unclear";
             confidence: number;
+            choice: "satisfied" | "dissatisfied" | "mixed" | "neutral" | "unrelated" | "unclear";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;

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

@@ -1,3 +1,8 @@
+/** Infer legacy transport sender metadata only to unwrap visible conversation text. */
+export declare function conversationUserText(raw: string, sender?: unknown): {
+    text: string;
+    contextLimited: boolean;
+} | undefined;
 /** Parse only recognized transport envelopes. Ambiguous wrappers are excluded,
  * never flattened into a human's request or used to approve embedded speakers. */
 export declare function responseUserText(input: string, senderId: string): {

package/dist/src/response-text.js

@@ -1,3 +1,25 @@
+/** Infer legacy transport sender metadata only to unwrap visible conversation text. */
+export function conversationUserText(raw, sender) {
+    let senderId = typeof sender === "string" ? sender : undefined;
+    if (senderId === undefined) {
+        const header = /^Conversation info: ⟦openclaw:ctx⟧\r?\n```json\r?\n([^]*?)\r?\n```\r?\n/.exec(raw.trim());
+        if (header) {
+            let metadata;
+            try {
+                metadata = JSON.parse(header[1]);
+            }
+            catch {
+                return;
+            }
+            if (metadata && typeof metadata === "object" && "sender" in metadata && metadata.sender &&
+                typeof metadata.sender === "object" && "id" in metadata.sender && typeof metadata.sender.id === "string") {
+                senderId = metadata.sender.id;
+            }
+        }
+        senderId ??= /^From: [^\r\n]+ \(([^()\r\n]+)\)\r?\n/.exec(raw.trim())?.[1];
+    }
+    return responseUserText(raw, senderId ?? "");
+}
 /** Parse only recognized transport envelopes. Ambiguous wrappers are excluded,
  * never flattened into a human's request or used to approve embedded speakers. */
 export function responseUserText(input, senderId) {
@@ -15,7 +37,7 @@ export function responseUserText(input, senderId) {
         if (!meta || meta.sender?.id !== senderId || typeof meta.sender.name !== "string")
             return undefined;
         const rest = text.slice(header[0].length);
-        const markers = [...rest.matchAll(/^System: \[[^\]\r\n]+\] Slack message in [^\r\n]+ from ([^\r\n]+)\r?\n\r?\n/gm)];
+        const markers = [...rest.matchAll(/^System: \[[^\]\r\n]+\] Slack (?:message in [^\r\n]+|DM) from ([^\r\n]+)\r?\n\r?\n/gm)];
         if (markers.length !== 1 || markers[0][1] !== meta.sender.name)
             return undefined;
         const marker = markers[0];

package/dist/src/retrieval-telemetry.d.ts

@@ -1,6 +1,6 @@
 type RetrievalOperation = "vector" | "lexical" | "memoryWhisperer";
 type RetrievalOutcome = "ok" | "empty" | "failed" | "cancelled" | "timed_out" | "skipped";
-declare const fields: readonly ["elapsedMs", "retrievalMs", "judgeMs", "candidates", "eligible", "results", "contextChars"];
+declare const fields: readonly ["elapsedMs", "retrievalMs", "judgeMs", "gateMs", "generationMs", "candidates", "eligible", "results", "contextChars"];
 type Field = typeof fields[number];
 export type RetrievalObservation = {
     outcome: RetrievalOutcome;
@@ -16,11 +16,11 @@ export declare class RetrievalTelemetry {
             [k: string]: {
                 calls: number;
                 outcomes: {
+                    cancelled?: number | undefined;
                     ok?: number | undefined;
                     skipped?: number | undefined;
                     failed?: number | undefined;
                     empty?: number | undefined;
-                    cancelled?: number | undefined;
                     timed_out?: number | undefined;
                 };
                 measurements: {

package/dist/src/retrieval-telemetry.js

@@ -1,4 +1,4 @@
-const fields = ["elapsedMs", "retrievalMs", "judgeMs", "candidates", "eligible", "results", "contextChars"];
+const fields = ["elapsedMs", "retrievalMs", "judgeMs", "gateMs", "generationMs", "candidates", "eligible", "results", "contextChars"];
 const recentLimit = 256;
 const boundedAdd = (left, right) => Math.min(Number.MAX_SAFE_INTEGER, left + right);
 /** Only fixed operation/outcome names and nonnegative numbers enter this store. */

package/dist/src/review-tools.js

@@ -2,7 +2,7 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { getContext } from "./tool-context.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { abortable } from "./abortable.js";
 const claimParameters = Type.Object({
     claim: Type.String({ pattern: "\\S", maxLength: 2000 }),