@unblocklabs/unblock-memory 0.3.22 → 0.3.24

package/dist/src/plugin.js

@@ -14,28 +14,33 @@ import { getContext } from "./tool-context.js";
 import { WhispererDiagnostics } from "./diagnostics.js";
 import { registerReviewTools } from "./review-tools.js";
 import { registerResponseAudit } from "./response-runtime.js";
+import { resolveTimezone } from "./session-projector.js";
 const searchParameters = Type.Object({
     query: Type.String({ pattern: "\\S" }),
-    corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), { minItems: 1 })),
+    corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), {
+        minItems: 1, description: 'Configured corpus names; default is all non-skill corpora. Use ["all"] alone for explicit all-corpora recall.',
+    })),
     sessionFilter: Type.Optional(Type.Object({
         startedFrom: Type.Optional(Type.String({
+            description: "Inclusive lower bound on session start time, not message or claim dates (ISO 8601).",
             pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$",
         })),
         startedTo: Type.Optional(Type.String({
+            description: "Inclusive upper bound on session start time, not message or claim dates (ISO 8601).",
             pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$",
         })),
         provider: Type.Optional(Type.String({ pattern: "\\S" })),
         chatType: Type.Optional(Type.Union([Type.Literal("channel"), Type.Literal("group"), Type.Literal("direct")])),
         accountId: Type.Optional(Type.String({ pattern: "\\S" })),
         conversationId: Type.Optional(Type.String({ pattern: "\\S" })),
-    }, { additionalProperties: false })),
-    maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20 })),
-    minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+    }, { additionalProperties: false, description: "Restricts session documents only; selected file corpora remain eligible. Not an audience access control." })),
+    maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Maximum hits; default 5." })),
+    minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1, description: "Minimum vector similarity; default 0.3. Not confidence in factual truth." })),
 }, { additionalProperties: false });
 const getParameters = Type.Object({
     path: Type.String({ pattern: "\\S" }),
-    from: Type.Optional(Type.Integer({ minimum: 1 })),
-    lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000 })),
+    from: Type.Optional(Type.Integer({ minimum: 1, description: "First source line, 1-based; default 1. Use nextFrom from a truncated read to continue." })),
+    lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000, description: "Requested lines; default 120, also bounded by 12,000 content characters." })),
 }, { additionalProperties: false });
 const syncSessionsParameters = Type.Object({
     force: Type.Optional(Type.Boolean()),
@@ -48,7 +53,7 @@ function createSearchTool(runtime, ctx) {
     return {
         name: "memory_search",
         label: "Memory Search",
-        description: "Search configured memory corpora with semantic vector retrieval. The isolated skills corpus is never included.",
+        description: "Search this agent's configured memory corpora with local vector retrieval, not QMD's hybrid query. Skills are excluded. Session snippets are arrays of messages (type, name, timestamp, body; partial when incomplete); file snippets are strings. Results are evidence leads; inspect source context with memory_get. Empty results or errors do not prove absence of a fact.",
         parameters: searchParameters,
         async execute(_toolCallId, params, signal) {
             const { query: untrimmedQuery, corpora, sessionFilter, maxResults, minScore, } = Value.Parse(searchParameters, params);
@@ -64,18 +69,22 @@ function createSearchTool(runtime, ctx) {
                 signal,
                 requestContext: active.requestContext,
             });
-            return jsonResult({
-                results: results.map((result) => result.session
-                    ? {
-                        ...result,
-                        session: {
-                            ...result.session,
-                            startedAt: new Date(result.session.startedAt).toISOString(),
-                        },
-                    }
-                    : result),
-                provider: "unblock-memory",
-            });
+            // Compact only the public tool response; internal ranking and consumers keep
+            // full-precision scores and the host's source/citation compatibility fields.
+            const payload = {
+                results: results.map(({ source: _source, citation: _citation, session, sessionMessages, ...result }) => ({
+                    ...result,
+                    snippet: result.corpus === "sessions" ? sessionMessages ?? [{ body: result.snippet, partial: true }] : result.snippet,
+                    score: Number(result.score.toFixed(2)),
+                    ...(result.vectorScore !== undefined ? { vectorScore: Number(result.vectorScore.toFixed(2)) } : {}),
+                    ...(result.textScore !== undefined ? { textScore: Number(result.textScore.toFixed(2)) } : {}),
+                    ...(session ? { session: { ...session, startedAt: new Date(session.startedAt).toISOString() } } : {}),
+                })),
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+                details: payload,
+            };
         },
     };
 }
@@ -86,7 +95,7 @@ function createGetTool(runtime, ctx) {
     return {
         name: "memory_get",
         label: "Memory Get",
-        description: "Read an exact qmd:// path returned by memory_search.",
+        description: "Read an exact indexed qmd:// source path returned by memory tools. Defaults to 120 lines, bounded to 12,000 content characters. Check truncated/nextFrom and continue when present; not_found or unavailable is not a successful empty read.",
         parameters: getParameters,
         async execute(_toolCallId, params) {
             const { path: untrimmedPath, from, lines } = Value.Parse(getParameters, params);
@@ -383,25 +392,12 @@ function parseByteSize(value) {
     const bytes = Math.round(Number(match[1]) * 1024 ** powers[unit]);
     return Number.isSafeInteger(bytes) ? bytes : undefined;
 }
-function resolveTimezone(cfg) {
-    const configured = cfg?.agents?.defaults?.userTimezone?.trim();
-    if (configured) {
-        try {
-            new Intl.DateTimeFormat("en-US", { timeZone: configured }).format();
-            return configured;
-        }
-        catch {
-            // Host validation normally prevents this; fall through defensively.
-        }
-    }
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-}
 export function resolveFlushPlan(params = {}) {
     const configured = params.cfg?.agents?.defaults?.compaction?.memoryFlush;
     if (configured?.enabled === false)
         return null;
     const nowMs = params.nowMs ?? Date.now();
-    const date = formatDateInTimezone(nowMs, resolveTimezone(params.cfg));
+    const date = formatDateInTimezone(nowMs, resolveTimezone(params.cfg?.agents?.defaults?.userTimezone?.trim()));
     const target = `memory/${date}.md`;
     return {
         softThresholdTokens: nonNegativeInteger(configured?.softThresholdTokens, 4000),
@@ -427,7 +423,7 @@ export function registerUnblockMemory(api) {
         supportsPrivateTranscriptRecall: false,
         promptBuilder: ({ availableTools }) => availableTools.has("memory_search")
             ? [
-                "Use memory_search for relevant past facts, then memory_get when more surrounding context is needed.",
+                "Use memory_search for relevant past facts, then memory_get to verify source context, attribution and dates. Follow read continuation when present. Empty search is not proof of absence; historical memory is not current authorization.",
             ]
             : [],
         flushPlanResolver: resolveFlushPlan,

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

@@ -0,0 +1,39 @@
+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"];
+type Field = typeof fields[number];
+export type RetrievalObservation = {
+    outcome: RetrievalOutcome;
+    elapsedMs: number;
+} & Partial<Record<Field, number>>;
+/** Only fixed operation/outcome names and nonnegative numbers enter this store. */
+export declare class RetrievalTelemetry {
+    #private;
+    record(operation: RetrievalOperation, observation: RetrievalObservation): void;
+    snapshot(): {
+        scope: string;
+        operations: {
+            [k: string]: {
+                calls: number;
+                outcomes: {
+                    ok?: number | undefined;
+                    skipped?: number | undefined;
+                    failed?: number | undefined;
+                    empty?: number | undefined;
+                    cancelled?: number | undefined;
+                    timed_out?: number | undefined;
+                };
+                measurements: {
+                    [k: string]: {
+                        total: number;
+                        samples: number;
+                        recentSamples: number;
+                        p50: number | null;
+                        p95: number | null;
+                    };
+                };
+            };
+        };
+    };
+}
+export {};

package/dist/src/retrieval-telemetry.js

@@ -0,0 +1,40 @@
+const fields = ["elapsedMs", "retrievalMs", "judgeMs", "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. */
+export class RetrievalTelemetry {
+    #entries = new Map();
+    record(operation, observation) {
+        const entry = this.#entries.get(operation) ?? { calls: 0, outcomes: {}, totals: {}, recent: [] };
+        this.#entries.set(operation, entry);
+        entry.calls = boundedAdd(entry.calls, 1);
+        entry.outcomes[observation.outcome] = boundedAdd(entry.outcomes[observation.outcome] ?? 0, 1);
+        const sample = {};
+        for (const field of fields) {
+            const value = observation[field];
+            if (value === undefined || !Number.isFinite(value) || value < 0)
+                continue;
+            sample[field] = value;
+            const total = entry.totals[field] ?? { sum: 0, samples: 0 };
+            entry.totals[field] = { sum: boundedAdd(total.sum, value), samples: boundedAdd(total.samples, 1) };
+        }
+        entry.recent.push(sample);
+        if (entry.recent.length > recentLimit)
+            entry.recent.shift();
+    }
+    snapshot() {
+        return {
+            scope: "Lifetime counters; percentiles cover at most the last 256 calls per operation, including failures. No content or hashes; resets on recreation.",
+            operations: Object.fromEntries([...this.#entries].map(([operation, entry]) => [operation, {
+                    calls: entry.calls,
+                    outcomes: { ...entry.outcomes },
+                    measurements: Object.fromEntries(fields.map(field => {
+                        const values = entry.recent.flatMap(sample => sample[field] === undefined ? [] : [sample[field]]).sort((a, b) => a - b);
+                        const percentile = (fraction) => values.length ? values[Math.ceil(values.length * fraction) - 1] : null;
+                        return [field, { total: entry.totals[field]?.sum ?? 0, samples: entry.totals[field]?.samples ?? 0,
+                                recentSamples: values.length, p50: percentile(0.5), p95: percentile(0.95) }];
+                    })),
+                }])),
+        };
+    }
+}

package/dist/src/session-projector.d.ts

@@ -22,10 +22,27 @@ export type SessionProjectionInput = SessionMetadata & {
         attachmentBudgetSkipped: number;
     };
 };
+export type SessionSnippetMessage = {
+    type?: "user" | "assistant";
+    name?: string;
+    timestamp?: string;
+    body: string;
+    partial?: true;
+};
+/** Character offsets in the exact indexed projection; end excludes message separators. */
+export type SessionMessageSpan = {
+    type: "user" | "assistant";
+    name: string;
+    timestamp: string;
+    start: number;
+    bodyStart: number;
+    end: number;
+};
 export type SessionContextSpans = {
     message: {
         start: number;
         end: number;
+        timestamp: string;
     };
     turn: {
         start: number;
@@ -33,6 +50,20 @@ export type SessionContextSpans = {
     };
 };
 export declare function projectSession(input: SessionProjectionInput): string | undefined;
-export declare function sessionContextSpans(content: string, position: number): SessionContextSpans | undefined;
+export declare function projectSessionDocument(input: SessionProjectionInput): {
+    content: string;
+    messages: SessionMessageSpan[];
+} | undefined;
+/** Legacy fallback only. New projections retain exact boundaries before rendering Markdown. */
+export declare function parseSessionMessageSpans(content: string): SessionMessageSpan[];
+export declare function sessionContextSpans(content: string, position: number, markers?: SessionMessageSpan[]): SessionContextSpans | undefined;
+export declare function sessionSnippetMessages(content: string, selected: {
+    text: string;
+    position: number;
+    sourceText?: string;
+}, spans: readonly SessionMessageSpan[], identity?: {
+    agentId: string;
+    agentName: string;
+}): SessionSnippetMessage[];
 export declare function sessionDocumentPath(metadata: SessionMetadata): string;
 export declare function resolveTimezone(configured?: string): string;

package/dist/src/session-projector.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { projectLoggieMessage } from "./loggie-projection.js";
 import { applyProposal, parseAttachments, parseInternalMessage } from "./session-noise.js";
-const MESSAGE_HEADING = /^## (User|Assistant) — .* — \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} \S.*$/gmu;
+const MESSAGE_HEADING = /^## (User|Assistant) — (.+) — (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} \S.*)$/u;
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -126,6 +126,9 @@ function formatTimestamp(value, timezone) {
         `${part("hour")}:${part("minute")}:${part("second")} ${part("timeZoneName")}`.trim();
 }
 export function projectSession(input) {
+    return projectSessionDocument(input)?.content;
+}
+export function projectSessionDocument(input) {
     const messages = input.events.flatMap((event) => {
         const projected = projectMessage(event, input);
         return projected ? [projected] : [];
@@ -164,28 +167,64 @@ export function projectSession(input) {
         else if (!previous || (!previous.meeting?.complete && meeting.complete))
             latest.set(meeting.key, message);
     }
-    const transcript = messages.filter(message => !hidden.has(message)).map((message) => `## ${message.role === "user" ? "User" : "Assistant"} — ${message.speaker} — ` +
-        `${formatTimestamp(message.timestamp, input.timezone)}\n\n${message.text}`);
-    return `# Transcript\n\n${transcript.join("\n\n")}\n`;
+    let content = "# Transcript\n\n";
+    const spans = [];
+    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);
+        content += `## ${message.role === "user" ? "User" : "Assistant"} — ${message.speaker} — ${timestamp}\n\n`;
+        const bodyStart = content.length;
+        content += message.text;
+        spans.push({ type: message.role, name: message.speaker, timestamp, start, bodyStart, end: content.length });
+    }
+    return { content: `${content}\n`, messages: spans };
 }
-export function sessionContextSpans(content, position) {
-    const markers = [...content.matchAll(MESSAGE_HEADING)].map((match) => ({
-        start: match.index,
-        role: match[1] === "User" ? "user" : "assistant",
-    }));
+/** Legacy fallback only. New projections retain exact boundaries before rendering Markdown. */
+export function parseSessionMessageSpans(content) {
+    const messages = [];
+    let fence;
+    for (const line of content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+        const text = line[0].replace(/\n$/u, "");
+        const delimiter = /^ {0,3}(`{3,}|~{3,})(.*)$/u.exec(text);
+        if (fence) {
+            if (delimiter?.[1]?.[0] === fence.char && delimiter[1].length >= fence.length && !delimiter[2]?.trim())
+                fence = undefined;
+            continue;
+        }
+        if (delimiter) {
+            fence = { char: delimiter[1][0], length: delimiter[1].length };
+            continue;
+        }
+        const match = MESSAGE_HEADING.exec(text);
+        // Only the projector's complete heading + blank-line form is recognized.
+        if (!match || !content.startsWith("\n\n", line.index + text.length))
+            continue;
+        const previous = messages.at(-1);
+        if (previous)
+            previous.end = content.startsWith("\n\n", line.index - 2) ? line.index - 2 : line.index;
+        messages.push({ type: match[1] === "User" ? "user" : "assistant", name: match[2], timestamp: match[3],
+            start: line.index, bodyStart: line.index + text.length + 2,
+            end: content.endsWith("\n") ? content.length - 1 : content.length });
+    }
+    return messages;
+}
+export function sessionContextSpans(content, position, markers = parseSessionMessageSpans(content)) {
     const containing = markers.findLastIndex((marker) => marker.start <= position);
     if (containing < 0)
         return undefined;
     const message = {
         start: markers[containing].start,
         end: markers[containing + 1]?.start ?? content.length,
+        timestamp: markers[containing].timestamp,
     };
     let turnStart = containing;
-    while (turnStart > 0 && markers[turnStart].role !== "user")
+    while (turnStart > 0 && markers[turnStart].type !== "user")
         turnStart -= 1;
-    if (markers[turnStart].role !== "user")
+    if (markers[turnStart].type !== "user")
         turnStart = containing;
-    const nextUser = markers.findIndex((marker, index) => index > turnStart && marker.role === "user");
+    const nextUser = markers.findIndex((marker, index) => index > turnStart && marker.type === "user");
     return {
         message,
         turn: {
@@ -194,6 +233,39 @@ export function sessionContextSpans(content, position) {
         },
     };
 }
+export function sessionSnippetMessages(content, selected, spans, identity) {
+    const sourceText = selected.sourceText ?? selected.text;
+    const end = selected.position + sourceText.length;
+    // Added meeting speaker/revision context is evidence too; retain it in the first body.
+    const prefix = selected.text.endsWith(sourceText) ? selected.text.slice(0, selected.text.length - sourceText.length) : "";
+    const messages = [];
+    let cursor = selected.position;
+    const keepUnattributed = (from, to) => {
+        const body = content.slice(from, to);
+        if (body.trim() && !(from === 0 && body === "# Transcript\n\n"))
+            messages.push({ body, partial: true });
+    };
+    for (const span of spans) {
+        if (span.start >= end || span.end <= selected.position)
+            continue;
+        if (span.start > cursor)
+            keepUnattributed(cursor, span.start);
+        const from = Math.max(span.bodyStart, selected.position);
+        const to = Math.min(span.end, end);
+        messages.push({ type: span.type,
+            name: span.type === "assistant" && span.name === identity?.agentId ? identity.agentName : span.name,
+            timestamp: span.timestamp, body: content.slice(from, Math.max(from, to)),
+            ...(from > span.bodyStart || to < span.end ? { partial: true } : {}),
+        });
+        cursor = Math.min(span.end, end);
+    }
+    if (cursor < end)
+        keepUnattributed(cursor, end);
+    if (!messages.length)
+        return [{ body: selected.text, partial: true }];
+    messages[0].body = prefix + messages[0].body;
+    return messages;
+}
 function hash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }

package/dist/src/session-sync.d.ts

@@ -1,6 +1,6 @@
 import type { ChatType } from "./config.js";
-import { type SessionMetadata, type SessionProjectionInput } from "./session-projector.js";
-export declare const PROJECTOR_VERSION = 6;
+import { type SessionMetadata, type SessionProjectionInput, type SessionMessageSpan } from "./session-projector.js";
+export declare const PROJECTOR_VERSION = 7;
 type IndexedSession = SessionMetadata & {
     sourceGeneration: string;
     maxSeq: number;
@@ -10,6 +10,7 @@ type IndexedSession = SessionMetadata & {
     documentPath: string;
     projectorVersion: number;
     sourceFingerprint?: string;
+    messages?: SessionMessageSpan[];
 };
 export type SessionManifest = {
     version: number;

package/dist/src/session-sync.js

@@ -3,9 +3,9 @@ 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 { projectSession, sessionDocumentPath, } from "./session-projector.js";
+import { projectSessionDocument, sessionDocumentPath, } from "./session-projector.js";
 const MANIFEST_VERSION = 1;
-export const PROJECTOR_VERSION = 6;
+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).
@@ -290,7 +290,7 @@ export async function syncSessionProjections(params) {
                 sessions[window.sessionId] = previous;
             continue;
         }
-        let content;
+        let projection;
         try {
             const input = {
                 ...metadata,
@@ -300,7 +300,7 @@ export async function syncSessionProjections(params) {
                 events,
                 diagnostics,
             };
-            content = projectSession(input);
+            projection = projectSessionDocument(input);
         }
         catch {
             counts.failed += 1;
@@ -308,7 +308,7 @@ export async function syncSessionProjections(params) {
                 sessions[window.sessionId] = previous;
             continue;
         }
-        if (!content) {
+        if (!projection) {
             ignoredSessions[window.sessionId] = JSON.stringify(window);
             counts.skipped += 1;
             if (previous) {
@@ -317,6 +317,7 @@ export async function syncSessionProjections(params) {
             }
             continue;
         }
+        const { content, messages } = projection;
         const target = projectionPath(params.outputDir, documentPath);
         const hash = projectionHash(content);
         const contentChanged = params.force === true || previous?.projectorVersion !== PROJECTOR_VERSION ||
@@ -338,6 +339,7 @@ export async function syncSessionProjections(params) {
             documentPath,
             projectorVersion: PROJECTOR_VERSION,
             sourceFingerprint: JSON.stringify(window),
+            messages,
         };
         if (contentChanged)
             counts.updated += 1;

package/dist/src/slack-directory.js

@@ -95,7 +95,8 @@ export async function syncSlackDirectory(params) {
         }
         try {
             const existing = params.store.findIdentity("slack", params.accountId, externalId);
-            if (existing && params.store.getPerson(existing.personId)?.status !== "active") {
+            const existingPerson = existing ? params.store.getPerson(existing.personId) : undefined;
+            if (existing && existingPerson?.status !== "active") {
                 counts.skipped += 1;
                 continue;
             }
@@ -118,7 +119,7 @@ export async function syncSlackDirectory(params) {
             });
             if (result.created)
                 counts.created += 1;
-            else if (changed)
+            else if (changed || result.person.displayName !== existingPerson?.displayName)
                 counts.updated += 1;
             else
                 counts.unchanged += 1;

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

@@ -6,7 +6,7 @@ type RequestOptions = {
 type Json = string | number | boolean | null | Json[] | {
     [key: string]: Json;
 };
-export declare const TYPESAFE_REVIEW_MODEL = "jev-1.13.0";
+export { TYPESAFE_MODEL as TYPESAFE_REVIEW_MODEL } from "./typesafe-transport.js";
 export declare function askTypeSafeReview(params: RequestOptions, state: Json, questions: Json): Promise<unknown>;
 /** The source is an indexed snapshot, not proof of current truth or permission to write. */
 export declare function reviewTypeSafeClaim(params: RequestOptions & {
@@ -50,4 +50,3 @@ export declare function reviewClusterDefects(params: RequestOptions & {
     defect: "encoding" | "wrapper" | "boilerplate" | "none_or_uncertain";
     confidence: number;
 }[]>;
-export {};

package/dist/src/typesafe-review.js

@@ -1,21 +1,13 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { backgroundWordCount, PEOPLE_BACKGROUND_MAX_WORDS } from "./people-background.js";
-export const TYPESAFE_REVIEW_MODEL = "jev-1.13.0";
+import { postTypeSafe } from "./typesafe-transport.js";
+export { TYPESAFE_MODEL as TYPESAFE_REVIEW_MODEL } from "./typesafe-transport.js";
 export async function askTypeSafeReview(params, state, questions) {
     const signal = AbortSignal.any([params.signal, AbortSignal.timeout(params.timeoutMs)]);
     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_REVIEW_MODEL, state, questions }),
-        });
-        if (!response.ok) {
-            await response.body?.cancel();
-            throw new Error("HTTP failure");
-        }
-        return await response.json();
+        return await postTypeSafe({ apiKey: params.apiKey, signal }, state, questions);
     }
     catch {
         throw new Error(signal.aborted ? "TypeSafe review aborted" : "TypeSafe review unavailable");

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

@@ -0,0 +1,10 @@
+export declare const TYPESAFE_MODEL = "jev-1.13.0";
+export declare class TypeSafeHttpError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+/** Shared wire protocol; callers own deadlines, judgments and public errors. */
+export declare function postTypeSafe(params: {
+    apiKey: string;
+    signal: AbortSignal;
+}, state: unknown, questions: unknown): Promise<unknown>;

package/dist/src/typesafe-transport.js

@@ -0,0 +1,26 @@
+export const TYPESAFE_MODEL = "jev-1.13.0";
+export class TypeSafeHttpError extends Error {
+    status;
+    constructor(status) {
+        super(`TypeSafe HTTP ${status}`);
+        this.status = status;
+    }
+}
+/** Shared wire protocol; callers own deadlines, judgments and public errors. */
+export async function postTypeSafe(params, state, questions) {
+    const response = await fetch("https://api.typesafe.ai/v1/systemone", {
+        method: "POST", redirect: "error", signal: params.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();
+        }
+        finally {
+            // Preserve the status even if cancellation fails; never include provider content.
+            throw new TypeSafeHttpError(response.status);
+        }
+    }
+    return response.json();
+}

package/dist/src/typesafe.d.ts

@@ -41,7 +41,7 @@ export declare function judgeTypeSafeMemories(params: {
     candidates: readonly {
         excerpt: string;
         corpus: string;
-        startedAt?: number;
+        messageTimestamp?: string;
     }[];
 }): Promise<number[]>;
 export {};