@unblocklabs/unblock-memory 0.7.0 → 0.7.2

package/dist/src/people-primer.js

@@ -1,13 +1,12 @@
 import { createHash } from "node:crypto";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA } 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;
-const noul = Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) });
-const answerSchema = Type.Object({ answers: Type.Record(Type.String(), noul) });
+const answerSchema = Type.Object({ answers: Type.Record(Type.String(), TYPESAFE_NOUL_SCHEMA) });
 function questionsFor(name, agent) {
     return [
         { id: "role", question: `Who is ${name}? What is their explicitly stated role and organization?` },
@@ -115,15 +114,14 @@ export async function primePersonDossier(params) {
                     requests++;
                     payload = await requestTypeSafe({ apiKey: params.apiKey, timeoutMs: config.timeoutMs, signal }, state, questions);
                     signal.throwIfAborted();
-                    if (!valid(payload) || !Value.Check(answerSchema, payload))
+                    if (!valid(payload))
                         throw new Error("Invalid primer judgments");
                     // Keep only validated numerical answers, never provider extras or echoes.
                     const answers = payload.answers;
-                    payload = { answers: Object.fromEntries(expectedKeys.map(k => [k, { type: "noul", noul: answers[k].noul }])) };
-                    store.cachePrimerJudgment(person.id, key, payload);
+                    store.cachePrimerJudgment(person.id, key, {
+                        answers: Object.fromEntries(expectedKeys.map(k => [k, { type: "noul", noul: answers[k].noul }])),
+                    });
                 }
-                if (!Value.Check(answerSchema, payload))
-                    throw new Error("Invalid primer cache");
                 graded.push({ ...candidate, aboutPerson: payload.answers.aboutPerson.noul,
                     explicitBackground: payload.answers.explicitBackground.noul, enduring: payload.answers.enduring.noul,
                     recognition: payload.answers.recognition.noul,

package/dist/src/people-store.js

@@ -153,6 +153,8 @@ export class PeopleStore {
         this.#maxBlurbChars = options.maxBlurbChars;
         try {
             this.#migrate();
+            this.#db.exec(`CREATE INDEX IF NOT EXISTS person_identities_person
+        ON person_identities(person_id, provider, account_scope, external_id)`);
         }
         catch (error) {
             this.#db.close();

package/dist/src/people-tools.js

@@ -112,10 +112,6 @@ const syncParameters = Type.Object({
     accountId: Type.String({ pattern: "\\S", maxLength: 200 }),
     limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
 }, { additionalProperties: false });
-function context(ctx) {
-    const cfg = ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config;
-    return cfg && ctx.agentId ? { agentId: ctx.agentId } : undefined;
-}
 function personView(stores, agentId, selector, maxChars) {
     const store = stores.get(agentId);
     const person = "personId" in selector
@@ -138,7 +134,7 @@ function personView(stores, agentId, selector, maxChars) {
     };
 }
 function createInspectTool(stores, config, ctx) {
-    const active = context(ctx);
+    const active = getContext(ctx);
     if (!active)
         return null;
     return {
@@ -265,7 +261,7 @@ function createUpdateTool(stores, config, runtime, ctx) {
     };
 }
 function createSyncTool(stores, reader, ctx) {
-    const active = context(ctx);
+    const active = getContext(ctx);
     if (!active)
         return null;
     return {

package/dist/src/plugin.js

@@ -2,7 +2,6 @@ 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-client.js";
 import { registerPeopleHooks } from "./people-hooks.js";
 import { PeopleStores } from "./people-store.js";
 import { registerPeopleTools } from "./people-tools.js";
@@ -13,7 +12,7 @@ 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";
+import { registerReviewTools, reviewRequestContext } from "./review-tools.js";
 import { registerResponseAudit } from "./response-runtime.js";
 import { registerInsideOut } from "./inside-out-runtime.js";
 import { registerMemoryTraining } from "./training-runtime.js";
@@ -263,20 +262,13 @@ function createAuditQualityTool(runtime, ctx, config) {
             const options = Value.Parse(auditQualityParameters, params);
             if (!config.qualityAudit.enabled || !config.typesafe.enabled)
                 return jsonResult({ status: "disabled" });
-            const deadline = AbortSignal.timeout(30_000);
-            const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
             try {
-                combined.throwIfAborted();
-                const apiKey = await resolveTypeSafeApiKey(config.typesafe);
-                if (!apiKey)
-                    return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                combined.throwIfAborted();
-                const { manager } = await runtime.getMemorySearchManager(active);
-                if (!manager)
-                    return jsonResult({ status: "unavailable", reason: "Memory manager unavailable" });
-                return jsonResult(await manager.auditQuality({
+                const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                if (context.status !== "ready")
+                    return jsonResult(context);
+                return jsonResult(await context.manager.auditQuality({
                     ...options, corpora: config.qualityAudit.corpora, minNoise: config.qualityAudit.minNoise,
-                    apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined,
+                    apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal,
                 }));
             }
             catch {

package/dist/src/query-contract.js

@@ -44,15 +44,23 @@ export function prepareQueryConversation(history, currentRequest) {
         conversation.history.unshift(message);
         bytes += added;
     }
-    let contextLimited = conversation.history.length < history.length;
-    for (;;) {
-        const serialized = serializeQueryConversation(conversation);
-        if (Buffer.byteLength(serialized) <= contract.conversationBytes && queryTokenIds(serialized).length <= contract.conversationTokens) {
-            return { conversation, contextLimited };
-        }
-        if (!conversation.history.length)
-            throw new QueryInputBudgetError();
-        conversation.history.shift();
-        contextLimited = true;
+    const fits = (start) => queryTokenIds(serializeQueryConversation({
+        history: conversation.history.slice(start), currentRequest,
+    })).length <= contract.conversationTokens;
+    if (fits(0))
+        return { conversation, contextLimited: conversation.history.length < history.length };
+    if (!fits(conversation.history.length))
+        throw new QueryInputBudgetError();
+    // Search whole-message suffixes with the exact serialized tokenizer contract;
+    // never approximate the budget by adding independently tokenized messages.
+    let tooLarge = 0, fitting = conversation.history.length;
+    while (fitting - tooLarge > 1) {
+        const middle = Math.floor((tooLarge + fitting) / 2);
+        if (fits(middle))
+            fitting = middle;
+        else
+            tooLarge = middle;
     }
+    conversation.history = conversation.history.slice(fitting);
+    return { conversation, contextLimited: true };
 }

package/dist/src/response-audit.js

@@ -142,11 +142,11 @@ export async function auditResponses(options) {
                         }
                     }
                     signal.throwIfAborted();
-                    const fresh = reader.read(session, config.responseAudit);
-                    if (!fresh?.episodes.some(candidate => candidate.id === e.id && candidate.inputHash === e.inputHash)) {
+                    const fresh = reader.read(session, config.responseAudit, snapshot.revision);
+                    if (!fresh || !("unchanged" in fresh) && !fresh.episodes.some(candidate => candidate.id === e.id && candidate.inputHash === e.inputHash)) {
                         coverage.stale++;
                         store.stale(cohort, e);
-                        if (fresh !== undefined) {
+                        if (fresh !== undefined && (!fresh || !("unchanged" in fresh))) {
                             store.observe(cohort, session, fresh?.episodes ?? []);
                             store.checkpointForget(cohort, session);
                         }

package/dist/src/response-judge.js

@@ -1,11 +1,10 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA as noul } 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-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 }),
     confidence: probability, probabilities: Type.Object({ "0": probability, "1": probability, "2": probability, "3": probability }) });
 function choiceSchema(criteria) {

package/dist/src/response-store.js

@@ -22,7 +22,8 @@ export class ResponseAuditStore {
           attempts INTEGER NOT NULL DEFAULT 0, attempted_at INTEGER, assessed_at INTEGER, result TEXT,
           PRIMARY KEY(cohort,id));
         CREATE TABLE IF NOT EXISTS response_scans (cohort TEXT PRIMARY KEY, observed_at INTEGER, coverage TEXT);
-        CREATE INDEX IF NOT EXISTS response_results_time ON response_results(cohort,episode_at);`);
+        CREATE INDEX IF NOT EXISTS response_results_time ON response_results(cohort,episode_at);
+        CREATE INDEX IF NOT EXISTS response_results_session ON response_results(cohort,session_id,episode_at);`);
             this.#db.exec(`CREATE TABLE IF NOT EXISTS response_checkpoints (
         cohort TEXT NOT NULL, session_id TEXT NOT NULL, revision TEXT NOT NULL, coverage TEXT NOT NULL,
         PRIMARY KEY(cohort,session_id));

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

@@ -1,4 +1,4 @@
-type RetrievalOperation = "vector" | "lexical" | "memoryWhisperer";
+type RetrievalOperation = "vector" | "memoryWhisperer";
 type RetrievalOutcome = "ok" | "empty" | "failed" | "cancelled" | "timed_out" | "skipped";
 declare const fields: readonly ["elapsedMs", "retrievalMs", "judgeMs", "gateMs", "generationMs", "candidates", "eligible", "results", "contextChars"];
 type Field = typeof fields[number];

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

@@ -2,4 +2,28 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
 import type { UnblockMemoryConfig } from "./config.js";
 import type { QmdMemoryRuntime } from "./runtime.js";
 import type { WhispererDiagnostics } from "./diagnostics.js";
+import { getContext } from "./tool-context.js";
+/** Bound initialization as well as inference, without cancelling shared managers. */
+export declare function reviewRequestContext(runtime: QmdMemoryRuntime, active: NonNullable<ReturnType<typeof getContext>>, typesafe: UnblockMemoryConfig["typesafe"], signal?: AbortSignal): Promise<{
+    readonly status: "unavailable";
+    readonly reason: "TypeSafe API key not configured";
+    readonly manager?: undefined;
+    readonly apiKey?: undefined;
+    readonly signal?: undefined;
+    readonly timeoutMs?: undefined;
+} | {
+    readonly status: "unavailable";
+    readonly reason: "Memory manager unavailable";
+    readonly manager?: undefined;
+    readonly apiKey?: undefined;
+    readonly signal?: undefined;
+    readonly timeoutMs?: undefined;
+} | {
+    readonly status: "ready";
+    readonly manager: import("./manager.js").QmdMemoryManager;
+    readonly apiKey: string;
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    reason?: undefined;
+}>;
 export declare function registerReviewTools(api: OpenClawPluginApi, runtime: QmdMemoryRuntime, config: UnblockMemoryConfig, diagnostics: WhispererDiagnostics): void;

package/dist/src/review-tools.js

@@ -13,6 +13,18 @@ const claimParameters = Type.Object({
 }, { additionalProperties: false });
 const clusterParameters = Type.Object({ clusterId: Type.String({ pattern: "^[0-9a-f]{10}$" }) }, { additionalProperties: false });
 const noParameters = Type.Object({}, { additionalProperties: false });
+/** Bound initialization as well as inference, without cancelling shared managers. */
+export async function reviewRequestContext(runtime, active, typesafe, signal) {
+    const deadline = AbortSignal.timeout(30_000);
+    const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    const apiKey = await abortable(resolveTypeSafeApiKey(typesafe), combined);
+    if (!apiKey)
+        return { status: "unavailable", reason: "TypeSafe API key not configured" };
+    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
+    if (!manager)
+        return { status: "unavailable", reason: "Memory manager unavailable" };
+    return { status: "ready", manager, apiKey, signal: combined, timeoutMs: typesafe.timeoutMs };
+}
 export function registerReviewTools(api, runtime, config, diagnostics) {
     api.registerTool(ctx => {
         const active = getContext(ctx);
@@ -59,20 +71,12 @@ export function registerReviewTools(api, runtime, config, diagnostics) {
                 const parsed = Value.Parse(claimParameters, params);
                 if (!config.evidenceReview.enabled || !config.typesafe.enabled)
                     return jsonResult({ status: "disabled" });
-                const deadline = AbortSignal.timeout(30_000);
-                const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
                 try {
-                    combined.throwIfAborted();
-                    const apiKey = await abortable(resolveTypeSafeApiKey(config.typesafe), combined);
-                    combined.throwIfAborted();
-                    if (!apiKey)
-                        return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
-                    combined.throwIfAborted();
-                    if (!manager)
-                        return jsonResult({ status: "unavailable" });
-                    return jsonResult(await manager.reviewClaim({ ...parsed, corpora: config.evidenceReview.corpora,
-                        apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined }));
+                    const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                    if (context.status !== "ready")
+                        return jsonResult(context);
+                    return jsonResult(await context.manager.reviewClaim({ ...parsed, corpora: config.evidenceReview.corpora,
+                        apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal }));
                 }
                 catch {
                     return jsonResult({ status: "unavailable", needsReview: true, reason: "Claim review failed or was cancelled; no claim verified" });
@@ -92,20 +96,12 @@ export function registerReviewTools(api, runtime, config, diagnostics) {
                 const parsed = Value.Parse(clusterParameters, params);
                 if (!config.qualityAudit.enabled || !config.typesafe.enabled)
                     return jsonResult({ status: "disabled" });
-                const deadline = AbortSignal.timeout(30_000);
-                const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
                 try {
-                    combined.throwIfAborted();
-                    const apiKey = await abortable(resolveTypeSafeApiKey(config.typesafe), combined);
-                    combined.throwIfAborted();
-                    if (!apiKey)
-                        return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
-                    combined.throwIfAborted();
-                    if (!manager)
-                        return jsonResult({ status: "unavailable" });
-                    return jsonResult(await manager.reviewCluster({ ...parsed, corpora: config.qualityAudit.corpora,
-                        apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined }));
+                    const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                    if (context.status !== "ready")
+                        return jsonResult(context);
+                    return jsonResult(await context.manager.reviewCluster({ ...parsed, corpora: config.qualityAudit.corpora,
+                        apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal }));
                 }
                 catch {
                     return jsonResult({ status: "unavailable", reason: "Cluster review failed or was cancelled; no cluster judgment made" });

package/dist/src/session-projector.js

@@ -109,8 +109,8 @@ export function projectMessage(row, input) {
         timestamp: timestamp(eventRecord.timestamp) ?? row.createdAt ?? timestamp(message.timestamp) ?? input.startedAt,
     };
 }
-function formatTimestamp(value, timezone) {
-    const parts = new Intl.DateTimeFormat("en-CA", {
+function timestampFormatter(timezone) {
+    return new Intl.DateTimeFormat("en-CA", {
         timeZone: timezone,
         year: "numeric",
         month: "2-digit",
@@ -120,7 +120,10 @@ function formatTimestamp(value, timezone) {
         second: "2-digit",
         hourCycle: "h23",
         timeZoneName: "short",
-    }).formatToParts(value);
+    });
+}
+function formatTimestamp(value, formatter) {
+    const parts = formatter.formatToParts(value);
     const part = (type) => parts.find((entry) => entry.type === type)?.value ?? "";
     return `${part("year")}-${part("month")}-${part("day")} ` +
         `${part("hour")}:${part("minute")}:${part("second")} ${part("timeZoneName")}`.trim();
@@ -169,11 +172,12 @@ export function projectSessionDocument(input) {
     }
     let content = "# Transcript\n\n";
     const spans = [];
+    const formatter = timestampFormatter(input.timezone);
     for (const message of messages.filter(message => !hidden.has(message))) {
         if (spans.length)
             content += "\n\n";
         const start = content.length;
-        const timestamp = formatTimestamp(message.timestamp, input.timezone);
+        const timestamp = formatTimestamp(message.timestamp, formatter);
         content += `## ${message.role === "user" ? "User" : "Assistant"} — ${message.speaker} — ${timestamp}\n\n`;
         const bodyStart = content.length;
         content += message.text;

package/dist/src/skill-whisperer.js

@@ -2,9 +2,11 @@ import { basename } from "node:path";
 import { selectTypeSafeSkill } from "./typesafe.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
 import { buildSkillWhispererQuery, messageText } from "./whisperer-context.js";
+import { abortable } from "./abortable.js";
 const CANDIDATE_LIMIT = 10;
 const MAX_QUERY_CHARS = 12_000;
 const TYPESAFE_CANDIDATE_LIMIT = 3;
+const TOTAL_TIMEOUT_MS = 3000;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -56,16 +58,23 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         const state = stateFor(scope);
         if (state.lastRunId === runId)
             return state.result;
+        state.controller?.abort();
+        const controller = new AbortController();
+        state.controller = controller;
+        const { signal } = controller;
+        const timer = setTimeout(() => controller.abort(new DOMException("Skill deadline", "TimeoutError")), TOTAL_TIMEOUT_MS);
         state.lastRunId = runId;
         state.turn += 1;
         // 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);
+                const apiKey = await abortable(resolveTypeSafeApiKey(typesafe), signal);
+                signal.throwIfAborted();
                 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 candidates = await abortable(runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT), signal);
+                signal.throwIfAborted();
                 const resolvedCandidates = candidates.flatMap((candidate) => {
                     const canonicalPath = runtime.resolveSkillPath(runtimeParams, candidate.path);
                     return canonicalPath ? [{ candidate, canonicalPath }] : [];
@@ -75,19 +84,29 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                     diagnostics?.record(agentId, "skill", "no_candidates");
                     return;
                 }
+                const cooling = (path) => {
+                    const previous = state.skills.get(path);
+                    return state.turn - Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity) <= config.cooldownTurns;
+                };
                 if (apiKey) {
                     const shortlist = resolvedCandidates.slice(0, TYPESAFE_CANDIDATE_LIMIT);
-                    const selectedIndex = await selectTypeSafeSkill({
-                        apiKey, timeoutMs: typesafe.timeoutMs,
+                    if (shortlist.every(({ canonicalPath }) => cooling(canonicalPath))) {
+                        diagnostics?.record(agentId, "skill", "cooldown");
+                        return;
+                    }
+                    const selectedIndex = await abortable(selectTypeSafeSkill({
+                        apiKey, timeoutMs: typesafe.timeoutMs, signal,
                         ...typeSafeConversation(event.prompt, event.messages, config.historyMessages),
                         candidates: shortlist.map(({ candidate }) => candidate),
                         onCandidateFailure: (candidateIndex, error) => {
+                            if (signal.aborted)
+                                return;
                             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 }));
                         },
-                    });
+                    }), signal);
                     if (selectedIndex === undefined) {
                         diagnostics?.record(agentId, "skill", "rejected");
                         return;
@@ -108,9 +127,7 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                 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) {
+                if (cooling(canonicalPath)) {
                     diagnostics?.record(agentId, "skill", "cooldown");
                     return;
                 }
@@ -123,10 +140,16 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                 };
             }
             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");
+                const timedOut = (error instanceof TypeSafeRequestError && error.code === "timeout") ||
+                    (signal.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError");
+                diagnostics?.record(agentId, "skill", timedOut ? "timed_out" : signal.aborted ? "cancelled" : "failed");
+                if (!signal.aborted)
+                    api.logger.warn("unblock-memory skill whisperer failed; no hint emitted");
                 return;
             }
+            finally {
+                clearTimeout(timer);
+            }
         };
         state.result = run();
         return state.result;
@@ -153,11 +176,17 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         }
     }, { matcher: ["read"] });
     api.on("session_end", (event, context) => {
-        sessions.delete(event.sessionId);
-        if (event.sessionKey)
-            sessions.delete(event.sessionKey);
-        if (context.sessionKey)
-            sessions.delete(context.sessionKey);
+        for (const scope of [event.sessionId, event.sessionKey, context.sessionKey]) {
+            if (!scope)
+                continue;
+            sessions.get(scope)?.controller?.abort();
+            sessions.delete(scope);
+        }
+    });
+    api.on("gateway_stop", () => {
+        for (const state of sessions.values())
+            state.controller?.abort();
+        sessions.clear();
     });
     return beforePrompt;
 }

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

@@ -1,22 +1,21 @@
 import type { QMDStore } from "@unblocklabs/qmd";
 import type { QueryLane } from "./query-contract.js";
-type Candidate = {
-    file: string;
-    body: string;
-    bestChunk: string;
-    bestChunkPos: number;
-    score: number;
-    explain: {
-        methods: string[];
-    };
+/** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
+export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal): Promise<{
     vector?: {
         score: number;
         rank: number;
-    };
+    } | undefined;
     bm25?: {
         score: number;
         rank: number;
+    } | undefined;
+    file: string;
+    body: string;
+    bestChunk: string;
+    bestChunkPos: number;
+    score: number;
+    explain: {
+        methods: ("vector" | "bm25")[];
     };
-};
-export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal): Promise<Candidate[]>;
-export {};
+}[]>;

package/dist/src/training-candidates.js

@@ -1,83 +1,13 @@
-import { randomUUID } from "node:crypto";
-const stopWords = new Set("a an and are as at be by can did do does for from how i in is it of on or that the their this to was were what when where which who why will with you".split(" "));
-function queryTerms(query) {
-    const words = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [])];
-    const meaningful = words.filter(word => !stopWords.has(word));
-    return (meaningful.length ? meaningful : words).slice(0, 64);
-}
-function lexicalChunk(chunks, body, highlighted, marker, intent) {
-    const compactLength = (text) => text.replace(/\s/gu, "").length;
-    const ranges = [];
-    let offset = 0;
-    for (const [i, part] of highlighted.split(marker).entries()) {
-        const end = offset + compactLength(part);
-        if (i % 2 === 1)
-            ranges.push({ start: offset, end });
-        offset = end;
-    }
-    const intentTerms = queryTerms(intent);
-    let sourcePos = 0, compactPos = 0;
-    return chunks.map(chunk => {
-        compactPos += compactLength(body.slice(sourcePos, chunk.pos));
-        sourcePos = chunk.pos;
-        const end = compactPos + compactLength(chunk.text);
-        const matches = ranges.reduce((sum, range) => sum + Math.max(0, Math.min(end, range.end) - Math.max(compactPos, range.start)) / Math.max(1, range.end - range.start), 0);
-        const lower = chunk.text.toLowerCase();
-        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;
-}
+/** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
 export async function trainingCandidates(qmd, query, collection, lane, 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, rawScore) => {
-        if (!hit.bestChunk.trim() || hit.bestChunk.length > 12_000)
-            return;
-        const key = JSON.stringify([hit.file, hit.bestChunk.trim()]), existing = candidates.get(key);
-        if (existing) {
-            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] },
-                [method]: { score: rawScore, rank: rank + 1 } });
-    };
-    if (lane === "vec") {
-        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, hit.score);
-        }
-        return [...candidates.values()];
-    }
-    const expression = queryTerms(query).map(term => `"${chunksApi.normalizeCjkForFTS(term).trim()}"`).join(" OR ");
-    if (expression) {
-        const marker = `qmd-match-${randomUUID()}`;
-        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 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)
-                .map(span => ({ pos: span.pos, text: row.doc.slice(span.pos, span.pos + span.chunk_len) }));
-            const chunks = stored.length ? stored : await chunksApi.chunkDocumentAsync(row.doc, undefined, undefined, undefined, file);
-            const selected = lexicalChunk(chunks, row.doc, row.highlighted, marker, query);
-            if (selected)
-                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);
+    const hits = await qmd.discoverCandidates({ query, lane, collection, limit: 10, signal,
+        // Preserve keyword chunk tie-breaking against this lane's own query.
+        intent: query });
+    return hits.map(({ method, rank, score, file, body, bestChunk, bestChunkPos }) => {
+        const retrieval = {
+            [method]: { score, rank: rank + 1 },
+        };
+        return { file, body, bestChunk, bestChunkPos, score: 1 / (rank + 1),
+            explain: { methods: [method] }, ...retrieval };
+    });
 }

package/dist/src/training-gate.js

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe, TYPESAFE_MODEL, TypeSafeRequestError } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_MODEL, TYPESAFE_NOUL_SCHEMA, TypeSafeRequestError } from "./typesafe-client.js";
 export const TRAINING_GATE_VERSION = "historical-recall-v2";
 export const TRAINING_GATE_MODEL = TYPESAFE_MODEL;
 export const TRAINING_GATE_THRESHOLD = 0.7;
@@ -27,7 +27,7 @@ export const TRAINING_GATE_QUESTIONS = { recall_needed: {
     } };
 const resultSchema = Type.Object({
     model: Type.Literal(TRAINING_GATE_MODEL),
-    answers: Type.Object({ recall_needed: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }) }),
+    answers: Type.Object({ recall_needed: TYPESAFE_NOUL_SCHEMA }),
     usage: Type.Object({ input_tokens: Type.Integer({ minimum: 0 }), output_tokens: Type.Integer({ minimum: 0 }) }),
 });
 export async function judgeTrainingInput(input, apiKey, signal) {