@unblocklabs/unblock-memory 0.3.27 → 0.3.28

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 }),

package/dist/src/skill-whisperer.d.ts

@@ -13,5 +13,5 @@ type SkillWhispererRuntime = {
     }, path: string): string | undefined;
 };
 export declare function buildSkillWhispererQuery(prompt: string, messages: readonly unknown[], historyMessages: number): string;
-export declare function registerSkillWhisperer(api: OpenClawPluginApi, runtime: SkillWhispererRuntime, config: UnblockMemoryConfig["skillWhisperer"], typesafe: UnblockMemoryConfig["typesafe"], diagnostics?: WhispererDiagnostics): void;
+export declare function registerSkillWhisperer(api: OpenClawPluginApi, runtime: SkillWhispererRuntime, config: UnblockMemoryConfig["skillWhisperer"], typesafe: UnblockMemoryConfig["typesafe"], diagnostics?: WhispererDiagnostics): Parameters<typeof api.on<"before_prompt_build">>[1] | undefined;
 export {};

package/dist/src/skill-whisperer.js

@@ -1,5 +1,6 @@
 import { basename } from "node:path";
-import { resolveTypeSafeApiKey, selectTypeSafeSkill } from "./typesafe.js";
+import { selectTypeSafeSkill } from "./typesafe.js";
+import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
 import { messageText } from "./whisperer-context.js";
 const CANDIDATE_LIMIT = 10;
 const MAX_QUERY_CHARS = 12_000;
@@ -55,78 +56,89 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         return state;
     };
     const active = (agentId) => ({ cfg: api.config, agentId });
-    api.on("before_prompt_build", async (event, context) => {
+    const beforePrompt = async (event, context) => {
+        const { agentId, runId } = context;
         const scope = sessionScope(context);
-        if (context.trigger !== "user" || !scope || !context.runId || !context.agentId)
+        if (context.trigger !== "user" || !scope || !runId || !agentId)
             return;
         const state = stateFor(scope);
-        if (state.lastRunId === context.runId)
-            return;
-        state.lastRunId = context.runId;
+        if (state.lastRunId === runId)
+            return state.result;
+        state.lastRunId = runId;
         state.turn += 1;
-        try {
-            const runtimeParams = active(context.agentId);
-            const apiKey = await resolveTypeSafeApiKey(typesafe);
-            if (!apiKey)
-                diagnostics?.record(context.agentId, "skill", typesafe.enabled ? "missing_key" : "typesafe_disabled");
-            const candidates = await runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT);
-            const resolvedCandidates = candidates.flatMap((candidate) => {
-                const canonicalPath = runtime.resolveSkillPath(runtimeParams, candidate.path);
-                return canonicalPath ? [{ candidate, canonicalPath }] : [];
-            });
-            let resolved = resolvedCandidates[0];
-            if (!resolved) {
-                diagnostics?.record(context.agentId, "skill", "no_candidates");
-                return;
-            }
-            if (apiKey) {
-                const shortlist = resolvedCandidates.slice(0, TYPESAFE_CANDIDATE_LIMIT);
-                const selectedIndex = await selectTypeSafeSkill({
-                    apiKey, timeoutMs: typesafe.timeoutMs,
-                    ...typeSafeConversation(event.prompt, event.messages, config.historyMessages),
-                    candidates: shortlist.map(({ candidate }) => candidate),
+        // Reuse even an in-flight result when the host rebuilds this run's prompt.
+        const run = async () => {
+            try {
+                const runtimeParams = active(agentId);
+                const apiKey = await resolveTypeSafeApiKey(typesafe);
+                if (!apiKey)
+                    diagnostics?.record(agentId, "skill", typesafe.enabled ? "missing_key" : "typesafe_disabled");
+                const candidates = await runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT);
+                const resolvedCandidates = candidates.flatMap((candidate) => {
+                    const canonicalPath = runtime.resolveSkillPath(runtimeParams, candidate.path);
+                    return canonicalPath ? [{ candidate, canonicalPath }] : [];
                 });
-                if (selectedIndex === undefined) {
-                    diagnostics?.record(context.agentId, "skill", "rejected");
+                let resolved = resolvedCandidates[0];
+                if (!resolved) {
+                    diagnostics?.record(agentId, "skill", "no_candidates");
                     return;
                 }
-                resolved = shortlist[selectedIndex];
-            }
-            else if (resolved && resolved.candidate.score < config.minScore) {
-                diagnostics?.record(context.agentId, "skill", "rejected");
-                return;
-            }
-            if (!resolved)
-                return;
-            // A selection completing after session teardown must not resurrect its hint.
-            if (sessions.get(scope) !== state || state.lastRunId !== context.runId) {
-                diagnostics?.record(context.agentId, "skill", "cancelled");
-                return;
+                if (apiKey) {
+                    const shortlist = resolvedCandidates.slice(0, TYPESAFE_CANDIDATE_LIMIT);
+                    const selectedIndex = await selectTypeSafeSkill({
+                        apiKey, timeoutMs: typesafe.timeoutMs,
+                        ...typeSafeConversation(event.prompt, event.messages, config.historyMessages),
+                        candidates: shortlist.map(({ candidate }) => candidate),
+                        onCandidateFailure: (candidateIndex, error) => {
+                            diagnostics?.record(agentId, "skill", "judge_candidate_failed");
+                            api.logger.warn("unblock-memory skill_whisperer " + JSON.stringify({ event: "candidate_failed",
+                                agentId, runId, candidateIndex, errorCode: error instanceof TypeSafeRequestError ? error.code : "unexpected",
+                                httpStatus: error instanceof TypeSafeRequestError ? error.status : undefined }));
+                        },
+                    });
+                    if (selectedIndex === undefined) {
+                        diagnostics?.record(agentId, "skill", "rejected");
+                        return;
+                    }
+                    resolved = shortlist[selectedIndex];
+                }
+                else if (resolved && resolved.candidate.score < config.minScore) {
+                    diagnostics?.record(agentId, "skill", "rejected");
+                    return;
+                }
+                if (!resolved)
+                    return;
+                // A selection completing after session teardown must not resurrect its hint.
+                if (sessions.get(scope) !== state || state.lastRunId !== runId) {
+                    diagnostics?.record(agentId, "skill", "cancelled");
+                    return;
+                }
+                const { candidate: selected, canonicalPath } = resolved;
+                if (apiKey && runtime.resolveSkillPath(runtimeParams, selected.path) !== canonicalPath)
+                    return;
+                const previous = state.skills.get(canonicalPath);
+                const lastSeen = Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity);
+                if (state.turn - lastSeen <= config.cooldownTurns) {
+                    diagnostics?.record(agentId, "skill", "cooldown");
+                    return;
+                }
+                const history = state.skills.get(canonicalPath) ?? {};
+                history.suggested = state.turn;
+                state.skills.set(canonicalPath, history);
+                diagnostics?.record(agentId, "skill", "emitted");
+                return {
+                    appendContext: `<skill>This skill may be relevant: ${JSON.stringify(selected.path).replace(/</gu, "\\u003c").replace(/>/gu, "\\u003e")}</skill>`,
+                };
             }
-            const { candidate: selected, canonicalPath } = resolved;
-            if (apiKey && runtime.resolveSkillPath(runtimeParams, selected.path) !== canonicalPath)
-                return;
-            const previous = state.skills.get(canonicalPath);
-            const lastSeen = Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity);
-            if (state.turn - lastSeen <= config.cooldownTurns) {
-                diagnostics?.record(context.agentId, "skill", "cooldown");
+            catch (error) {
+                diagnostics?.record(agentId, "skill", error instanceof TypeSafeRequestError && error.code === "timeout" ? "timed_out" : "failed");
+                api.logger.warn("unblock-memory skill whisperer failed; no hint emitted");
                 return;
             }
-            const history = state.skills.get(canonicalPath) ?? {};
-            history.suggested = state.turn;
-            state.skills.set(canonicalPath, history);
-            diagnostics?.record(context.agentId, "skill", "emitted");
-            return {
-                prependContext: `A potentially relevant skill is available: ${JSON.stringify(selected.name)} ` +
-                    `at ${JSON.stringify(selected.path)}. Check it before proceeding if applicable.`,
-            };
-        }
-        catch (error) {
-            diagnostics?.record(context.agentId, "skill", error instanceof Error && error.message === "TypeSafe selection timed out" ? "timed_out" : "failed");
-            api.logger.warn("unblock-memory skill whisperer failed; no hint emitted");
-            return;
-        }
-    });
+        };
+        state.result = run();
+        return state.result;
+    };
     api.on("after_tool_call", (event, context) => {
         if (event.toolName !== "read" || event.error ||
             (isRecord(event.result) && event.result.isError === true) || !context.agentId)
@@ -155,4 +167,5 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         if (context.sessionKey)
             sessions.delete(context.sessionKey);
     });
+    return beforePrompt;
 }

package/dist/src/training-candidates.d.ts

@@ -8,6 +8,14 @@ type Candidate = {
     explain: {
         methods: string[];
     };
+    vector?: {
+        score: number;
+        rank: number;
+    };
+    bm25?: {
+        score: number;
+        rank: number;
+    };
 };
-export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string, intent: string): Promise<Candidate[]>;
+export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], intent: string, signal?: AbortSignal): Promise<Candidate[]>;
 export {};

package/dist/src/training-candidates.js

@@ -26,14 +26,15 @@ function lexicalChunk(chunks, body, highlighted, marker, intent) {
         return { chunk, matches, intentMatches: intentTerms.filter(term => lower.includes(term)).length };
     }).sort((a, b) => b.matches - a.matches || b.intentMatches - a.intentMatches || a.chunk.pos - b.chunk.pos)[0]?.chunk;
 }
-export async function trainingCandidates(qmd, query, collection, intent) {
+export async function trainingCandidates(qmd, query, collection, intent, signal) {
+    signal?.throwIfAborted();
     if (!query.trim() || query.length > 12_000)
         throw new Error("Invalid training query");
     // QMD exposes its store but not these chunk helpers at the package root.
     // Resolve relative to its installed SDK, never a global QMD or modified copy.
     const chunksApi = await import(new URL("./store.js", import.meta.resolve("@unblocklabs/qmd")).href);
     const candidates = new Map();
-    const add = (hit, method, rank) => {
+    const add = (hit, method, rank, rawScore) => {
         if (!hit.bestChunk.trim() || hit.bestChunk.length > 12_000)
             return;
         const key = JSON.stringify([hit.file, hit.bestChunk.trim()]), existing = candidates.get(key);
@@ -41,16 +42,19 @@ export async function trainingCandidates(qmd, query, collection, intent) {
             if (!existing.explain.methods.includes(method))
                 existing.explain.methods.push(method);
             existing.score = Math.max(existing.score, 1 / (rank + 1));
+            existing[method] ??= { score: rawScore, rank: rank + 1 };
         }
         else
-            candidates.set(key, { ...hit, score: 1 / (rank + 1), explain: { methods: [method] } });
+            candidates.set(key, { ...hit, score: 1 / (rank + 1), explain: { methods: [method] },
+                [method]: { score: rawScore, rank: rank + 1 } });
     };
     const vectors = await qmd.searchVector(query, { limit: 10, collection });
+    signal?.throwIfAborted();
     for (const [rank, hit] of vectors.entries()) {
         const pos = hit.chunkPos, len = hit.chunkLen, body = hit.body ?? "";
         if (pos === undefined || len === undefined || pos < 0 || len <= 0 || pos + len > body.length)
             continue;
-        add({ file: hit.filepath, body, bestChunk: body.slice(pos, pos + len), bestChunkPos: pos }, "vector", rank);
+        add({ file: hit.filepath, body, bestChunk: body.slice(pos, pos + len), bestChunkPos: pos }, "vector", rank, hit.score);
     }
     const expression = queryTerms(query).map(term => `"${chunksApi.normalizeCjkForFTS(term).trim()}"`).join(" OR ");
     if (expression) {
@@ -58,9 +62,10 @@ export async function trainingCandidates(qmd, query, collection, intent) {
         const rows = qmd.internal.db.prepare(`SELECT d.collection,d.path,d.hash,c.doc,
       bm25(documents_fts,1.5,4.0,1.0) AS rank, highlight(documents_fts,2,?,?) AS highlighted
       FROM documents_fts JOIN documents d ON d.id=documents_fts.rowid JOIN content c ON c.hash=d.hash
-      WHERE documents_fts MATCH ? AND d.active=1 AND d.collection=?
-      ORDER BY rank,d.collection,d.path LIMIT 10`).all(marker, marker, expression, collection);
+      WHERE documents_fts MATCH ? AND d.active=1 AND d.collection IN (SELECT value FROM json_each(?))
+      ORDER BY rank,d.collection,d.path LIMIT 10`).all(marker, marker, expression, JSON.stringify(typeof collection === "string" ? [collection] : collection));
         for (const [rank, row] of rows.entries()) {
+            signal?.throwIfAborted();
             const file = `qmd://${row.collection}/${row.path}`;
             const stored = chunksApi.getStoredChunkSpans(qmd.internal.db, row.hash)
                 .filter(span => span.pos >= 0 && span.chunk_len > 0 && span.pos + span.chunk_len <= row.doc.length)
@@ -68,7 +73,7 @@ export async function trainingCandidates(qmd, query, collection, intent) {
             const chunks = stored.length ? stored : await chunksApi.chunkDocumentAsync(row.doc, undefined, undefined, undefined, file);
             const selected = lexicalChunk(chunks, row.doc, row.highlighted, marker, intent);
             if (selected)
-                add({ file, body: row.doc, bestChunk: selected.text, bestChunkPos: selected.pos }, "bm25", rank);
+                add({ file, body: row.doc, bestChunk: selected.text, bestChunkPos: selected.pos }, "bm25", rank, row.rank);
         }
     }
     return [...candidates.values()].sort((a, b) => b.score - a.score);

package/dist/src/training-gate.js

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { postTypeSafe, TYPESAFE_MODEL } from "./typesafe-transport.js";
+import { requestTypeSafe, TYPESAFE_MODEL, TypeSafeRequestError } from "./typesafe-client.js";
 export const TRAINING_GATE_VERSION = "historical-recall-v1";
 export const TRAINING_GATE_MODEL = TYPESAFE_MODEL;
 export const TRAINING_GATE_THRESHOLD = 0.7;
@@ -25,9 +25,9 @@ const resultSchema = Type.Object({
     usage: Type.Object({ input_tokens: Type.Integer({ minimum: 0 }), output_tokens: Type.Integer({ minimum: 0 }) }),
 });
 export async function judgeTrainingInput(input, apiKey, signal) {
-    const result = await postTypeSafe({ apiKey, signal }, input, TRAINING_GATE_QUESTIONS);
+    const result = await requestTypeSafe({ apiKey, signal }, input, TRAINING_GATE_QUESTIONS);
     if (!Value.Check(resultSchema, result) || !Number.isFinite(result.answers.recall_needed.noul)) {
-        throw new Error("Invalid training gate response");
+        throw new TypeSafeRequestError("Invalid training gate response", "invalid_response");
     }
     return { probability: result.answers.recall_needed.noul, model: result.model, usage: result.usage };
 }

package/dist/src/training-input.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { messageText } from "./whisperer-context.js";
-import { responseUserText } from "./response-text.js";
+import { conversationUserText } from "./response-text.js";
 // Identical serialized inputs keep their checkpoints when eligibility broadens.
 export const TRAINING_PREPARATION = "visible-history-v1";
 // A deliberately conservative byte budget, NOT a tokenizer or a 32k-token target.
@@ -10,27 +10,6 @@ export const trainingHash = (value) => createHash("sha256").update(JSON.stringif
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-/** Legacy sender IDs are useful for envelope cleanup, not an admission requirement. */
-function userText(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;
-            }
-            const id = record(record(metadata)?.sender)?.id;
-            if (typeof id === "string")
-                senderId = id;
-        }
-        senderId ??= /^From: [^\r\n]+ \(([^()\r\n]+)\)\r?\n/.exec(raw.trim())?.[1];
-    }
-    return responseUserText(raw, senderId ?? "");
-}
 /** The following answer establishes eligibility, but is never part of that example's input. */
 export function trainingExamples(rows) {
     const examples = [];
@@ -88,7 +67,7 @@ export function trainingExamples(rows) {
                 continue;
             }
             const raw = typeof meta?.upstreamUserText === "string" ? meta.upstreamUserText : messageText(message)?.text;
-            const visible = raw ? userText(raw, meta?.senderId ?? message.senderId) : undefined;
+            const visible = raw ? conversationUserText(raw, meta?.senderId ?? message.senderId) : undefined;
             if (!visible || /^(?:\[OpenClaw heartbeat poll\]|\[Queued messages while agent was busy\]|\[Subagent Context\]|<relevant-memories>)/.test(visible.text)) {
                 coverage.filtered++;
                 boundary();

package/dist/src/training-judge.js

@@ -1,8 +1,8 @@
 import { Type } from 'typebox';
 import { Value } from 'typebox/value';
-import { postTypeSafe } from './typesafe-transport.js';
+import { requestTypeSafe, TYPESAFE_MODEL } from './typesafe-client.js';
 export const CONTEXT_JUDGE_VERSION = 'conversation-context-usefulness-v1';
-const CONTEXT_JUDGE_MODEL = 'jev-1.13.0';
+const CONTEXT_JUDGE_MODEL = TYPESAFE_MODEL;
 const CONTEXT_QUESTIONS = {
     usefulness: {
         type: 'score',
@@ -53,5 +53,5 @@ export function parseContextJudgment(payload) {
     return { score: answer.score / 3, answer, model: payload.model, usage: payload.usage ?? null };
 }
 export async function judgeTrainingPassage(request, apiKey) {
-    return parseContextJudgment(await postTypeSafe({ apiKey, signal: AbortSignal.timeout(30_000) }, request.state, request.questions));
+    return parseContextJudgment(await requestTypeSafe({ apiKey, timeoutMs: 30_000 }, request.state, request.questions));
 }

package/dist/src/training-queries.js

@@ -1,11 +1,10 @@
 import { collectTraining } from "./training.js";
 import { trainingHash } from "./training-input.js";
 import { TRAINING_GATE_THRESHOLD } from "./training-gate.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
 import { trainingTeacher, trainingTeacherMessage, TRAINING_TEACHER_MODEL, TRAINING_TEACHER_PROMPT, TRAINING_TEACHER_VERSION } from "./training-models.js";
 import { historicalTrainingSearch, TRAINING_RETRIEVAL_VERSION, TRAINING_SEARCH_OPTIONS } from "./training-retrieval.js";
 import { contextJudgeRequest, judgeTrainingPassage, CONTEXT_JUDGE_VERSION } from "./training-judge.js";
-import { TypeSafeHttpError } from "./typesafe-transport.js";
 const SELECTION_VERSION = "conversation-utility-top5-sum-v2";
 export const TRAINING_EVALUATION_CONCURRENCY = 4;
 function bounds(options) {
@@ -41,9 +40,11 @@ async function checkpoint(store, step, result, operation) {
         const hostCode = error && typeof error === "object" && "code" in error && typeof error.code === "string" &&
             /^LLM_[A-Z_]+$/u.test(error.code) ? error.code : undefined;
         const status = hostCode === "LLM_COMPLETION_NOT_AUTHORIZED" ||
-            (error instanceof TypeSafeHttpError && error.status >= 400 && error.status < 500) ? "failed" : "ambiguous";
+            (error instanceof TypeSafeRequestError && error.code === "http_error" &&
+                error.status !== undefined && error.status >= 400 && error.status < 500) ? "failed" : "ambiguous";
         store.finishStep(step.stage, step.id, attempt, { status,
-            error: error instanceof TypeSafeHttpError ? `http_${error.status}` : hostCode ?? "request_or_response_uncertain" });
+            error: error instanceof TypeSafeRequestError && error.code === "http_error" ?
+                `http_${error.status}` : hostCode ?? "request_or_response_uncertain" });
         result[status]++;
         return;
     }

package/dist/src/training.js

@@ -1,5 +1,4 @@
-import { TypeSafeHttpError } from "./typesafe-transport.js";
-import { resolveTypeSafeApiKey } from "./typesafe.js";
+import { TypeSafeRequestError, resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { TrainingTranscriptReader } from "./training-input.js";
 import { judgeTrainingInput, TRAINING_GATE_QUESTIONS } from "./training-gate.js";
 /** A full active-branch rescan is cheap/local; only changed exact inputs need inference. */
@@ -78,9 +77,11 @@ export async function runTraining(source, store, config, options) {
                     judgment = await judgeTrainingInput(input, key, AbortSignal.timeout(30_000));
                 }
                 catch (error) {
-                    const definite = error instanceof TypeSafeHttpError && error.status >= 400 && error.status < 500;
+                    const definite = error instanceof TypeSafeRequestError && error.code === "http_error" &&
+                        error.status !== undefined && error.status >= 400 && error.status < 500;
                     const status = definite ? "failed" : "ambiguous";
-                    store.finish(job.id, attempt, { status, error: error instanceof TypeSafeHttpError ? `http_${error.status}` : "request_or_response_uncertain" });
+                    store.finish(job.id, attempt, { status, error: error instanceof TypeSafeRequestError && error.code === "http_error" ?
+                            `http_${error.status}` : "request_or_response_uncertain" });
                     result[status]++;
                     // Stop on the first failure rather than spending the rest of the budget during an outage.
                     return;

package/dist/src/typesafe-client.d.ts

@@ -0,0 +1,15 @@
+import type { UnblockMemoryConfig } from "./config.js";
+export declare const TYPESAFE_MODEL = "jev-1.13.0";
+export declare class TypeSafeRequestError extends Error {
+    readonly code: "timeout" | "cancelled" | "http_error" | "invalid_response" | "network_error";
+    readonly status?: number | undefined;
+    constructor(message: string, code: "timeout" | "cancelled" | "http_error" | "invalid_response" | "network_error", status?: number | undefined);
+}
+/** Explicit credentials take precedence; a missing explicit file never selects another key. */
+export declare function resolveTypeSafeApiKey(config: UnblockMemoryConfig["typesafe"]): Promise<string | undefined>;
+/** One TypeSafe request. The caller owns the response schema and failure policy. */
+export declare function requestTypeSafe(params: {
+    apiKey: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}, state: unknown, questions: unknown): Promise<unknown>;