@unblocklabs/unblock-memory 0.3.27 → 0.3.29

package/dist/src/session-sync.js

@@ -3,10 +3,10 @@ import { existsSync, lstatSync, readFileSync, statSync } from "node:fs";
 import { chmod, mkdir, readFile, rename, unlink, utimes, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { ACTIVE_EVENTS_FROM, agentTranscriptSchemaVersion, assertAgentTranscriptIdentity } from "./agent-transcript.js";
 import { projectSessionDocument, sessionDocumentPath, } from "./session-projector.js";
 const MANIFEST_VERSION = 1;
 export const PROJECTOR_VERSION = 7;
-const SUPPORTED_SCHEMA_VERSIONS = new Set([17, 18, 19]);
 // Source lives in src/, published code in dist/src/. Read our own pinned dependency
 // metadata, not QMD internals (which may also be substituted by runtime inspectors).
 const sourcePackage = new URL("../package.json", import.meta.url);
@@ -76,12 +76,7 @@ function projectionPath(outputDir, documentPath) {
     return target;
 }
 function assertSchema(db, expectedAgentId) {
-    const pragma = db.prepare("PRAGMA user_version").get();
-    const schemaVersion = pragma?.user_version;
-    if (typeof schemaVersion !== "number" || !SUPPORTED_SCHEMA_VERSIONS.has(schemaVersion)) {
-        throw new Error("unsupported OpenClaw agent database schema: expected one of 17, 18, 19, " +
-            `found ${String(schemaVersion ?? "unknown")}`);
-    }
+    const version = agentTranscriptSchemaVersion(db);
     for (const [table, required] of Object.entries(REQUIRED_COLUMNS)) {
         const columns = new Set(db.prepare(`PRAGMA table_info(${table})`).all()
             .map((column) => column.name));
@@ -89,14 +84,7 @@ function assertSchema(db, expectedAgentId) {
         if (missing)
             throw new Error(`unsupported OpenClaw agent database: missing ${table}.${missing}`);
     }
-    const meta = db.prepare("SELECT role, schema_version AS schemaVersion, agent_id AS agentId " +
-        "FROM schema_meta WHERE meta_key = 'primary' LIMIT 1").get();
-    if (meta?.role !== "agent" || meta.schemaVersion !== schemaVersion) {
-        throw new Error("unsupported OpenClaw agent database primary schema metadata");
-    }
-    if (meta.agentId !== expectedAgentId) {
-        throw new Error(`OpenClaw agent database belongs to ${String(meta.agentId)}, not ${expectedAgentId}`);
-    }
+    assertAgentTranscriptIdentity(db, expectedAgentId, version);
 }
 function readSnapshot(params) {
     const db = new DatabaseSync(params.databasePath, { readOnly: true });
@@ -129,13 +117,11 @@ function readSnapshot(params) {
       ORDER BY window.created_at, window.session_id
     `).all(...params.chatTypes);
         const readEvents = db.prepare(`
-      SELECT active.session_id AS sessionId, event.event_json AS eventJson,
-             event.created_at AS createdAt
-      FROM session_transcript_active_events AS active
-      JOIN transcript_events AS event
-        ON event.session_id = active.session_id AND event.seq = active.event_seq
-      WHERE active.session_id = ?
-      ORDER BY active.active_position
+      SELECT a.session_id AS sessionId, e.event_json AS eventJson,
+             e.created_at AS createdAt
+      ${ACTIVE_EVENTS_FROM}
+      WHERE a.session_id = ?
+      ORDER BY a.active_position
     `);
         const events = new Map();
         const changed = new Set();

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

@@ -12,6 +12,5 @@ type SkillWhispererRuntime = {
         agentId: string;
     }, 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,20 +1,13 @@
 import { basename } from "node:path";
-import { resolveTypeSafeApiKey, selectTypeSafeSkill } from "./typesafe.js";
-import { messageText } from "./whisperer-context.js";
+import { selectTypeSafeSkill } from "./typesafe.js";
+import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
+import { buildSkillWhispererQuery, messageText } from "./whisperer-context.js";
 const CANDIDATE_LIMIT = 10;
 const MAX_QUERY_CHARS = 12_000;
 const TYPESAFE_CANDIDATE_LIMIT = 3;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-export function buildSkillWhispererQuery(prompt, messages, historyMessages) {
-    const availableHistory = messages.flatMap((message) => {
-        const parsed = messageText(message);
-        return parsed ? [`${parsed.role}: ${parsed.text}`] : [];
-    });
-    const history = historyMessages === 0 ? [] : availableHistory.slice(-historyMessages);
-    return [...history, `user: ${prompt.trim()}`].join("\n\n").slice(-MAX_QUERY_CHARS);
-}
 function typeSafeConversation(prompt, messages, historyMessages) {
     const currentRequest = prompt.trim().slice(-MAX_QUERY_CHARS);
     let remaining = MAX_QUERY_CHARS - currentRequest.length;
@@ -55,78 +48,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 +159,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,8 @@
 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";
+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 +11,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 +68,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();
@@ -154,11 +134,7 @@ export class TrainingTranscriptReader {
         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 training transcript schema or agent");
-            }
+            assertAgentTranscriptSchema(this.#db, agentId, "Unsupported training transcript schema or agent");
             const columns = this.#db.prepare("PRAGMA table_info(session_windows)").all().map(c => c.name);
             this.#lineage = ["parent_session_key", "spawned_by", "plugin_owner_id", "hook_external_content_source"].every(c => columns.includes(c));
         }
@@ -181,14 +157,10 @@ export class TrainingTranscriptReader {
                 /:(?:cron|subagent|heartbeat|hook)(?::|$)/i.test(String(session.session_key)) ||
                 session.parent_session_key || session.spawned_by || session.plugin_owner_id || session.hook_external_content_source)
                 return null;
-            const size = 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(sessionId);
+            const size = this.#db.prepare(ACTIVE_EVENT_COUNT_SQL).get(sessionId);
             if (Number(size.n) > 50_000 || Number(size.bytes) > 32_000_000)
                 return { oversized: true };
-            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`).iterate(sessionId);
+            const rows = this.#db.prepare(ACTIVE_EVENT_ROWS_SQL).iterate(sessionId);
             return trainingExamples(rows);
         }
         finally {

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

@@ -7,14 +7,7 @@ import { TrainingStore } from "./training-store.js";
 import { TRAINING_GATE_THRESHOLD } from "./training-gate.js";
 import { collectTraining, runTraining } from "./training.js";
 import { generateTrainingQueries, evaluateTrainingQueries, exportQueryTraining, TRAINING_EVALUATION_CONCURRENCY } from "./training-queries.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";
 function thresholdOption(value) {
     const result = Number(value);
     if (!value.trim() || !Number.isFinite(result) || result < 0 || result > 1)

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>;

package/dist/src/typesafe-client.js

@@ -0,0 +1,75 @@
+import { readFile } from "node:fs/promises";
+import { parseEnv } from "node:util";
+export const TYPESAFE_MODEL = "jev-1.13.0";
+export class TypeSafeRequestError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}
+/** Explicit credentials take precedence; a missing explicit file never selects another key. */
+export async function resolveTypeSafeApiKey(config) {
+    if (!config.enabled)
+        return undefined;
+    if (config.apiKey)
+        return config.apiKey.trim() || undefined;
+    if (!config.apiKeyFile)
+        return process.env.TYPESAFE_API_KEY?.trim() || undefined;
+    let contents;
+    try {
+        contents = (await readFile(config.apiKeyFile, "utf8")).trim();
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw new Error("TypeSafe credential file could not be read");
+    }
+    if (!contents)
+        return undefined;
+    if (/^(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=/m.test(contents) || contents.startsWith("#")) {
+        return parseEnv(contents).TYPESAFE_API_KEY?.trim() || undefined;
+    }
+    if (/\s/.test(contents))
+        throw new Error("TypeSafe credential file must contain a key or dotenv entries");
+    return contents;
+}
+/** One TypeSafe request. The caller owns the response schema and failure policy. */
+export async function requestTypeSafe(params, state, questions) {
+    const timeout = params.timeoutMs === undefined ? undefined : AbortSignal.timeout(params.timeoutMs);
+    const signal = params.signal && timeout ? AbortSignal.any([params.signal, timeout]) : params.signal ?? timeout;
+    try {
+        signal?.throwIfAborted();
+        const response = await fetch("https://api.typesafe.ai/v1/systemone", {
+            method: "POST", redirect: "error", signal,
+            headers: { Authorization: `Bearer ${params.apiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ model: TYPESAFE_MODEL, state, questions }),
+        });
+        if (!response.ok) {
+            try {
+                await response.body?.cancel();
+            }
+            catch { /* Status is authoritative; discard unsafe cancellation detail. */ }
+            throw new TypeSafeRequestError(`TypeSafe HTTP ${response.status}`, "http_error", response.status);
+        }
+        try {
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                throw new TypeSafeRequestError("TypeSafe returned invalid JSON", "invalid_response");
+            throw error;
+        }
+    }
+    catch (error) {
+        if (error instanceof TypeSafeRequestError)
+            throw error;
+        if (signal?.aborted) {
+            const timedOut = signal.reason instanceof Error && signal.reason.name === "TimeoutError";
+            throw new TypeSafeRequestError(timedOut ? "TypeSafe request timed out" : "TypeSafe request cancelled", timedOut ? "timeout" : "cancelled");
+        }
+        throw new TypeSafeRequestError("TypeSafe request failed", "network_error");
+    }
+}

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

@@ -3,11 +3,7 @@ type RequestOptions = {
     timeoutMs: number;
     signal: AbortSignal;
 };
-type Json = string | number | boolean | null | Json[] | {
-    [key: string]: Json;
-};
-export { TYPESAFE_MODEL as TYPESAFE_REVIEW_MODEL } from "./typesafe-transport.js";
-export declare function askTypeSafeReview(params: RequestOptions, state: Json, questions: Json): Promise<unknown>;
+export { TYPESAFE_MODEL as TYPESAFE_REVIEW_MODEL } from "./typesafe-client.js";
 /** The source is an indexed snapshot, not proof of current truth or permission to write. */
 export declare function reviewTypeSafeClaim(params: RequestOptions & {
     claim: string;
@@ -34,9 +30,9 @@ export declare function reviewTypeSafeClaim(params: RequestOptions & {
 export declare function reviewMemoryRedundancy(params: RequestOptions & {
     excerpts: readonly string[];
 }): Promise<{
-    redundant: number;
     earlier: number;
     later: number;
+    redundant: number;
 }[]>;
 export declare function complementaryIndices(count: number, pairs: readonly {
     earlier: number;