@snoai/memory 0.0.0-stage → 1.0.1

package/dist/error-D-wb-rZw.js

@@ -0,0 +1,23 @@
+//#region src/contract/error.ts
+const DEGRADED_REASONS = [
+	"sidecar-unreachable",
+	"sidecar-unresponsive",
+	"principal-mismatch",
+	"store-mismatch",
+	"no-agent-endpoint",
+	"invalid-input",
+	"timeout",
+	"storage-unavailable",
+	"engine-failed"
+];
+var ContractError = class extends Error {
+	reason;
+	degraded = true;
+	constructor(reason, message = reason) {
+		super(message);
+		this.reason = reason;
+		this.name = "ContractError";
+	}
+};
+//#endregion
+export { DEGRADED_REASONS as n, ContractError as t };

package/dist/error-signals-D8_3vYu4.d.ts

@@ -0,0 +1,28 @@
+//#region src/engine/security/error-signals.d.ts
+type ReflectionErrorSignal = {
+  at: number;
+  toolName: string;
+  summary: string;
+  source: "tool_error" | "tool_output";
+  signature: string;
+  signatureHash: string;
+};
+type ReflectionErrorState = {
+  entries: ReflectionErrorSignal[];
+  lastInjectedCount: number;
+  signatureSet: Set<string>;
+  updatedAt: number;
+};
+type CreateErrorSignalTrackerOptions = {
+  maxTrackedSessions?: number;
+};
+/** Creates the per-session tracker that batches runtime errors for reflection feedback. */
+declare function createErrorSignalTracker(options?: CreateErrorSignalTrackerOptions): {
+  getState: (sessionKey: string) => ReflectionErrorState;
+  addSignal: (sessionKey: string, signal: ReflectionErrorSignal, dedupeEnabled: boolean) => void;
+  getPendingSignals: (sessionKey: string, maxEntries: number) => ReflectionErrorSignal[];
+  clearSession: (sessionKey: string) => void;
+  prune: (ttlMs: number, maxSessions: number) => void;
+};
+//#endregion
+export { createErrorSignalTracker as n, ReflectionErrorSignal as t };

package/dist/error-signals-lMH2uAdV.js

@@ -0,0 +1,134 @@
+import "./internal/config/index.js";
+import { redactSecrets } from "./internal/engine/security/redact.js";
+import { createHash } from "node:crypto";
+//#region src/engine/security/error-signals.ts
+/** @file error-signals.ts
+* @purpose Classifies error-like text patterns used by capture and retrieval heuristics.
+* @boundary Multilingual runtime regexes and operational signal extraction.
+* @see capture-policy-detector.ts, intent-analyzer.ts, memory-noise-classifier.ts.
+*/
+const ERROR_SIGNAL_PATTERNS = [
+	/\[error\]|error:|exception:|fatal:|traceback|syntaxerror|typeerror|referenceerror|npm err!/,
+	/command not found|no such file|permission denied|non-zero|exit code/,
+	/"status"\s*:\s*"error"|"status"\s*:\s*"failed"|\biserror\b/,
+	/错误\s*[：:]|异常\s*[：:]|报错\s*[：:]|失败\s*[：:]/
+];
+const SUMMARY_MAX_LEN = 220;
+const SIGNATURE_MAX_LEN = 240;
+const MAX_ENTRIES_PER_SESSION = 30;
+/** Implements touch session state as the local runtime error signal extraction operation. */
+function touchSessionState(sessions, key, state) {
+	sessions.delete(key);
+	sessions.set(key, state);
+	return state;
+}
+/** Filters oldest sessions before it affects runtime error signal extraction decisions. */
+function pruneOldestSessions(sessions, maxSessions) {
+	const cappedMaxSessions = Math.max(0, maxSessions);
+	while (sessions.size > cappedMaxSessions) {
+		const oldestKey = sessions.keys().next().value;
+		if (oldestKey === void 0) break;
+		sessions.delete(oldestKey);
+	}
+}
+/** Implements contains error signal as the local runtime error signal extraction operation. */
+function containsErrorSignal(text) {
+	const normalized = text.toLowerCase();
+	return ERROR_SIGNAL_PATTERNS.some((p) => p.test(normalized));
+}
+/**
+* Normalizes error signature at the boundary before runtime error signal extraction uses it.
+*/
+function normalizeErrorSignature(text) {
+	return redactSecrets(String(text || "")).toLowerCase().replace(/[a-z]:\\[^ \n\r\t]+/gi, "<path>").replace(/\/[^ \n\r\t]+/g, "<path>").replace(/\b0x[0-9a-f]+\b/gi, "<hex>").replace(/\b\d+\b/g, "<n>").replace(/\s+/g, " ").trim().slice(0, SIGNATURE_MAX_LEN);
+}
+/** Implements summarize error text as the local runtime error signal extraction operation. */
+function summarizeErrorText(text, maxLen = SUMMARY_MAX_LEN) {
+	const oneLine = redactSecrets(text).replace(/\s+/g, " ").trim();
+	if (!oneLine) return "(empty tool error)";
+	return oneLine.length <= maxLen ? oneLine : `${oneLine.slice(0, maxLen - 3)}...`;
+}
+/** Implements sha256 hex as the local runtime error signal extraction operation. */
+function sha256Hex(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+/** Extracts text from tool result from raw inputs while tolerating partial data. */
+function extractTextFromToolResult(result) {
+	if (result == null) return "";
+	if (typeof result === "string") return result;
+	if (typeof result !== "object") return "";
+	const obj = result;
+	const content = obj.content;
+	if (!Array.isArray(content)) return typeof obj.text === "string" ? obj.text : "";
+	const parts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const rec = item;
+		if (rec.type === "text" && typeof rec.text === "string") parts.push(rec.text);
+	}
+	return parts.join("\n");
+}
+/** Creates the per-session tracker that batches runtime errors for reflection feedback. */
+function createErrorSignalTracker(options = {}) {
+	const sessions = /* @__PURE__ */ new Map();
+	const maxTrackedSessions = Math.max(0, options.maxTrackedSessions ?? 200);
+	/** Returns state from runtime error signal extraction state without side effects. */
+	const getState = (sessionKey) => {
+		const key = sessionKey.trim();
+		const current = sessions.get(key);
+		if (current) {
+			current.updatedAt = Date.now();
+			return touchSessionState(sessions, key, current);
+		}
+		pruneOldestSessions(sessions, Math.max(0, maxTrackedSessions - 1));
+		return touchSessionState(sessions, key, {
+			entries: [],
+			lastInjectedCount: 0,
+			signatureSet: /* @__PURE__ */ new Set(),
+			updatedAt: Date.now()
+		});
+	};
+	return {
+		getState,
+		/** Adds signal to the local runtime error signal extraction accumulator. */
+		addSignal(sessionKey, signal, dedupeEnabled) {
+			if (!sessionKey.trim()) return;
+			const state = getState(sessionKey);
+			if (dedupeEnabled && state.signatureSet.has(signal.signatureHash)) return;
+			state.entries.push(signal);
+			state.signatureSet.add(signal.signatureHash);
+			state.updatedAt = Date.now();
+			if (state.entries.length > MAX_ENTRIES_PER_SESSION) {
+				const removed = state.entries.length - MAX_ENTRIES_PER_SESSION;
+				state.entries.splice(0, removed);
+				state.lastInjectedCount = Math.max(0, state.lastInjectedCount - removed);
+				state.signatureSet = new Set(state.entries.map((e) => e.signatureHash));
+			}
+		},
+		/** Drains the not-yet-injected error signals, advancing the injection marker so callers never re-receive them. */
+		getPendingSignals(sessionKey, maxEntries) {
+			if (maxEntries <= 0) return [];
+			const key = sessionKey.trim();
+			const state = sessions.get(key);
+			if (!state) return [];
+			state.updatedAt = Date.now();
+			touchSessionState(sessions, key, state);
+			const start = Math.min(Math.max(0, state.lastInjectedCount), state.entries.length);
+			const pending = state.entries.slice(start);
+			state.lastInjectedCount = state.entries.length;
+			return pending.length > maxEntries ? pending.slice(-maxEntries) : pending;
+		},
+		/** Removes session while preserving runtime error signal extraction invariants. */
+		clearSession(sessionKey) {
+			sessions.delete(sessionKey.trim());
+		},
+		/** Implements prune as the local runtime error signal extraction operation. */
+		prune(ttlMs, maxSessions) {
+			const now = Date.now();
+			for (const [key, state] of sessions.entries()) if (now - state.updatedAt > ttlMs) sessions.delete(key);
+			pruneOldestSessions(sessions, maxSessions);
+		}
+	};
+}
+//#endregion
+export { sha256Hex as a, normalizeErrorSignature as i, createErrorSignalTracker as n, summarizeErrorText as o, extractTextFromToolResult as r, containsErrorSignal as t };

package/dist/errors-CeVRxf9V.d.ts

@@ -0,0 +1,49 @@
+//#region src/engine/shared/errors.d.ts
+/** @file errors.ts
+ * @purpose Defines typed plugin errors and stable codes for callers and CLI output.
+ * @boundary Runtime boundaries, CLI error mapping, and test assertions.
+ * @see memory-management-cli.ts, sno-station-mem-plugin-runtime.ts, memory-tool-registration.ts.
+ */
+declare class SnoStationMemError extends Error {
+  readonly code: string;
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(code: string, message: string, cause?: unknown);
+}
+declare class StorageError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class EmbeddingError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class RetrievalError extends SnoStationMemError {
+  /**
+   * Carries the cause's own message in `message`, not only in `cause`.
+   *
+   * Retrieval wraps every failure as "Failed to retrieve memories", and every consumer that
+   * reports one — a tool result, an eval harness, an HTTP boundary — reports `message` and drops
+   * the Error. Measured 2026-09-04: a whole evaluation round scored nothing and the only trace
+   * on disk was fifteen identical copies of that sentence, so the reason had to be re-derived by
+   * reproducing the run. The cause stays attached as well; this only makes it survive the trip.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class ConfigError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { StorageError as a, SnoStationMemError as i, EmbeddingError as n, RetrievalError as r, ConfigError as t };

package/dist/extraction-text-sanitizer-B_AhIecT.d.ts

@@ -0,0 +1,32 @@
+//#region src/engine/extraction/extraction-text-sanitizer.d.ts
+/**
+ * Keeps a section's clause list inside `DEFAULT_MAX_CONTEXT_TOKENS`, the repository-wide
+ * per-record ceiling the store refuses to write past.
+ *
+ * A profile section is one row by design (`getByFactKey` is singular), and merging appends, so
+ * a long-lived section grows without bound — measured 2026-09-14 on a real persona store, five
+ * successive versions of `preferences.general` ran 516 → 533 → 538 → 540 → 576 tokens. Past the
+ * ceiling the embedder and the reranker both truncate silently, so the tail of such a section is
+ * already invisible to retrieval; dropping it here is the same loss made honest, and it keeps the
+ * merge writing instead of throwing.
+ *
+ * Oldest clauses go first: `mergeProfileSection` seeds the map with the stored clauses and then
+ * the incoming ones, so insertion order runs oldest to newest. The abstract is kept whatever
+ * happens — it is the section's only summary and it leads the indexed text.
+ */
+declare function boundSectionContent(content: string, abstract: string, countRecordTokens: (text: string) => number): string;
+/**
+ * Build the string that goes into the `text` column of `nodix_memories`.
+ *
+ * The FTS5 BM25 index is derived from this column only (see
+ * drizzle/0001_virtual_tables.sql). Concatenating abstract and content gives
+ * BM25 the same source surface used for vector embedding.
+ */
+declare function buildIndexedText(abstract: string, content: string): string;
+/**
+ * Strip platform envelope metadata injected by SnoStationMem channels before the
+ * conversation text reaches the extraction LLM.
+ */
+declare function stripEnvelopeMetadata(text: string): string;
+//#endregion
+export { buildIndexedText as n, stripEnvelopeMetadata as r, boundSectionContent as t };

package/dist/i18n-text-DbD6Qify.d.ts

@@ -0,0 +1,13 @@
+//#region src/engine/shared/i18n-text.d.ts
+declare const HTML_TAG_PATTERN: RegExp;
+/** Builds a Unicode-aware left/right token-boundary regex around a regex body. */
+declare function unicodeBoundaryRegex(body: string, flags?: string): RegExp;
+/** Matches CJK terms by substring and alphabetic terms by Unicode token boundaries. */
+declare function boundaryAwareRegex(term: string, flags?: string): RegExp;
+declare function stripHtmlTags(text: string): string;
+declare function stripRoleLabelPrefix(text: string): string;
+declare function normalizeForCompare(text: string): string;
+declare function truncateGraphemes(text: string, maxGraphemes: number, suffix?: string): string;
+declare function tokenizeForFts(rawQuery: string): string[];
+//#endregion
+export { stripRoleLabelPrefix as a, unicodeBoundaryRegex as c, stripHtmlTags as i, boundaryAwareRegex as n, tokenizeForFts as o, normalizeForCompare as r, truncateGraphemes as s, HTML_TAG_PATTERN as t };

package/dist/index-0aqS8pVF.d.ts

@@ -0,0 +1,351 @@
+import { p as LlmRoutingConfig, t as PluginConfig } from "./plugin-config-schema-C0UUbOmG.js";
+import { g as MemoryEntry, h as MemoryCategory, t as AGGREGATION_OPERATIONS, x as RetrievalResult } from "./types-CWdhXLxr.js";
+import { r as SnoStationMemMemorySearchResult } from "./provider-runtime-types-DFhtdA6d.js";
+import { z } from "zod";
+//#region src/contract/error.d.ts
+declare const DEGRADED_REASONS: readonly ["sidecar-unreachable", "sidecar-unresponsive", "principal-mismatch", "store-mismatch", "no-agent-endpoint", "invalid-input", "timeout", "storage-unavailable", "engine-failed"];
+type DegradedReason = (typeof DEGRADED_REASONS)[number];
+declare class ContractError extends Error {
+  readonly reason: DegradedReason;
+  readonly degraded = true;
+  constructor(reason: DegradedReason, message?: string);
+}
+//#endregion
+//#region src/contract/inputs.d.ts
+type JsonValue = z.infer<ReturnType<typeof z.json>>;
+type HostContext = {
+  observeSessionUuid?: string;
+  agentId?: string;
+  sessionKey?: string;
+  sessionId?: string;
+  sessionTimezone?: string;
+  workspace?: string;
+  sessionFile?: string;
+  boundary?: "new" | "reset" | "session-end";
+  systemCaller?: boolean;
+  at?: number;
+};
+/** Every call reads `project` plus the shared global memory; writes land on `project`. */
+type ScopeCtx = {
+  principal: string;
+  project: string;
+  session: string;
+  host?: HostContext;
+};
+type Message = {
+  role: "system" | "developer" | "user" | "assistant" | "tool";
+  content: JsonValue;
+  at: number;
+};
+type Turn = {
+  turnId: string;
+  rewindEpoch: number;
+  messages: Message[];
+};
+type AgentModelRegistration = {
+  baseUrl: string;
+  credential: string;
+  model: string;
+};
+type Registration = {
+  skinId: string;
+  model?: AgentModelRegistration;
+};
+type InitRegistration = Registration;
+type RecallOptions = {
+  corpus?: "memory" | "wiki" | "all" | "sessions";
+  source?: "auto" | "manual" | "native";
+  injectionPhase?: "session-start" | "prompt" | "first-prompt";
+  maxChars?: number;
+  limit?: number;
+  minScore?: number;
+  category?: MemoryCategory;
+  includeMetadata?: boolean;
+  includeHistory?: boolean;
+  includeRefused?: boolean;
+  tokenBudget?: number;
+  externalReference?: string;
+  externalReferenceVisibility?: "public" | "private";
+  aggregation?: {
+    operation: (typeof AGGREGATION_OPERATIONS)[number];
+    terms: string[];
+  };
+};
+type Mutation = {
+  op: "correct";
+  id: string;
+  content: string;
+} | {
+  op: "store";
+  content: string;
+  category?: MemoryCategory;
+  importance?: number;
+  metadata?: Record<string, JsonValue>;
+} | {
+  op: "forget";
+  id?: string;
+  query?: string;
+  suppressKey?: {
+    subject: string;
+    attribute: string;
+  };
+  suppressContent?: string;
+  minScore?: number;
+  maxDelete?: number;
+  confirm?: boolean;
+} | {
+  op: "update";
+  id: string;
+  text?: string;
+  category?: MemoryCategory;
+  importance?: number;
+  metadata?: Record<string, JsonValue>;
+  timestamp?: number;
+} | {
+  op: "clear";
+  confirm: boolean;
+  all?: boolean;
+} | {
+  op: "resolveReflection";
+  memoryId?: string;
+  query?: string;
+  dryRun?: boolean;
+  note?: string;
+  limit?: number;
+};
+type Inspection = {
+  op: "storage";
+} | {
+  op: "stats";
+  scope?: string;
+} | {
+  op: "list";
+  category?: MemoryCategory;
+  limit?: number;
+  offset?: number;
+  importanceMin?: number;
+} | {
+  op: "get";
+  id?: string;
+  path?: string;
+  from?: number;
+  lines?: number;
+} | {
+  op: "listReflection";
+  limit?: number;
+  unresolvedOnly?: boolean;
+};
+type UsageSignal = {
+  event: "inject" | "used" | "rejected" | "tool-error";
+  memoryIds: string[];
+  toolName?: string;
+  text?: string;
+  error?: JsonValue;
+  result?: JsonValue;
+  at: number;
+};
+/** What the host agent did, for the skin's observe session: a prompt, a host model call, a tool call, or a permission decision. */
+type HostDecision = "allow" | "deny";
+type HostEvent = {
+  kind: "prompt";
+  prompt: string;
+} | {
+  kind: "llm";
+  model: string;
+  promptTokens: number;
+  completionTokens: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  latencyMs: number;
+} | {
+  kind: "tool";
+  toolName: string;
+  decision: HostDecision;
+  input: string;
+  output: string;
+  latencyMs: number;
+} | {
+  kind: "permission";
+  permissionKind: string;
+  decision: HostDecision;
+  target: string;
+};
+interface ContractInputs {
+  init: {
+    scope: ScopeCtx;
+    registration: InitRegistration;
+  };
+  hostEvent: {
+    scope: ScopeCtx;
+    event: HostEvent;
+  };
+  getRecall: {
+    query: string;
+    scope: ScopeCtx;
+    options: RecallOptions;
+  };
+  capture: {
+    turn: Turn;
+    scope: ScopeCtx;
+  };
+  mutate: {
+    op: Mutation;
+    scope: ScopeCtx;
+  };
+  inspect: {
+    op: Inspection;
+    scope: ScopeCtx;
+  };
+  recordUsage: {
+    recallId: string;
+    signal: UsageSignal;
+    scope: ScopeCtx;
+  };
+  onSessionEnd: {
+    messages: Message[];
+    scope: ScopeCtx;
+  };
+  staticBlock: {
+    scope: ScopeCtx;
+  };
+}
+declare const scopeSchema: z.ZodType<ScopeCtx, unknown>;
+declare const messageSchema: z.ZodType<Message, unknown>;
+declare const turnSchema: z.ZodType<Turn, unknown>;
+declare const registrationSchema: z.ZodType<Registration, unknown>;
+declare const initRegistrationSchema: z.ZodType<InitRegistration, unknown>;
+declare const recallOptionsSchema: z.ZodType<RecallOptions, unknown>;
+declare const mutationSchema: z.ZodType<Mutation, unknown>;
+declare const inspectionSchema: z.ZodType<Inspection, unknown>;
+declare const usageSignalSchema: z.ZodType<UsageSignal, unknown>;
+declare const hostEventSchema: z.ZodType<HostEvent, unknown>;
+declare const inputSchemas: { [K in keyof ContractInputs]: z.ZodType<ContractInputs[K], unknown>; };
+//#endregion
+//#region src/contract/results.d.ts
+type Result<T> = T & ({
+  degraded: false;
+} | {
+  degraded: true;
+  reason: DegradedReason;
+  error?: string;
+});
+type ToolResponse = {
+  isError?: boolean;
+  content: Array<{
+    type: "text";
+    text: string;
+  }>;
+  details: Record<string, JsonValue>;
+};
+type InspectData = {
+  op: "storage";
+  dimension: number | null;
+  failed: boolean;
+  reason?: string;
+} | {
+  op: "stats";
+  total: number;
+  projectBreakdown: Record<string, number>;
+  categoryBreakdown: Record<string, number>;
+} | {
+  op: "list" | "listReflection";
+  project: string;
+  entries: MemoryEntry[];
+} | {
+  op: "get";
+  entry: MemoryEntry | null;
+  file?: {
+    text: string;
+    path: string;
+    truncated?: boolean;
+    from?: number;
+    lines?: number;
+    nextFrom?: number;
+  };
+};
+interface ContractOutputs {
+  init: Result<{
+    principal: string;
+    skinId: string;
+  }>;
+  hostEvent: Result<{
+    accepted: boolean;
+  }>;
+  getRecall: Result<{
+    recallId: string;
+    contextText: string;
+    hits?: RetrievalResult[];
+    memoryIds?: string[];
+    toolResult?: ToolResponse;
+    nativeHits?: SnoStationMemMemorySearchResult[];
+    unavailable?: string;
+  }>;
+  capture: Result<{
+    turnId: string;
+    committed: boolean;
+    accepted?: boolean;
+    skipped?: true;
+    partial?: true;
+  }>;
+  mutate: Result<{
+    result: ToolResponse;
+  }>;
+  inspect: Result<{
+    result: InspectData;
+  }>;
+  recordUsage: Result<{
+    accepted: boolean;
+  }>;
+  onSessionEnd: Result<{
+    completed: boolean;
+  }>;
+  staticBlock: Result<{
+    contextText: string;
+  }>;
+}
+declare const memoryEntrySchema: z.ZodType<MemoryEntry, unknown>;
+declare const retrievalResultSchema: z.ZodType<RetrievalResult, unknown>;
+declare const toolResponseSchema: z.ZodType<ToolResponse, unknown>;
+declare const inspectDataSchema: z.ZodType<InspectData, unknown>;
+declare const outputSchemas: { [K in keyof ContractOutputs]: z.ZodType<ContractOutputs[K], unknown>; };
+//#endregion
+//#region src/contract/settings.d.ts
+type EngineSettings = Omit<PluginConfig, keyof LlmRoutingConfig | "remEnhanced">;
+declare const engineSettingsSchema: z.ZodType<EngineSettings, unknown>;
+//#endregion
+//#region src/contract/routes.d.ts
+declare const MEMORY_ROUTES: Readonly<Record<ContractMethod, {
+  path: string;
+  timeoutMs: number;
+}>>;
+declare const MEMORY_BODY_LIMIT_BYTES: number;
+declare const MEMORY_SKIN_HEADER = "x-sno-station-mem-skin";
+declare const REM_SIDECAR_TOKEN_HEADER = "x-sidecar-token";
+declare const MEMORY_HEALTH_TIMEOUT_MS = 5e3;
+declare const MEMORY_START_TIMEOUT_MS = 3e4;
+declare function memoryMethod(pathname: string): ContractMethod | undefined;
+declare const MEMORY_ERROR_STATUS: Readonly<Record<DegradedReason, number>>;
+declare const MEMORY_RECONNECT_INTERVAL_MS = 1e3;
+declare const MEMORY_DEFAULT_SKIN_ID = "default";
+//#endregion
+//#region src/contract/index.d.ts
+type ContractMethod = keyof ContractInputs;
+interface MemoryContract {
+  init(scope: ScopeCtx, registration: Registration): Promise<ContractOutputs["init"]>;
+  hostEvent(event: HostEvent, scope: ScopeCtx): Promise<ContractOutputs["hostEvent"]>;
+  getRecall(query: string, scope: ScopeCtx, options: RecallOptions): Promise<ContractOutputs["getRecall"]>;
+  capture(turn: Turn, scope: ScopeCtx): Promise<ContractOutputs["capture"]>;
+  mutate(op: Mutation, scope: ScopeCtx): Promise<ContractOutputs["mutate"]>;
+  inspect(op: Inspection, scope: ScopeCtx): Promise<ContractOutputs["inspect"]>;
+  recordUsage(recallId: string, signal: UsageSignal, scope: ScopeCtx): Promise<ContractOutputs["recordUsage"]>;
+  onSessionEnd(messages: Message[], scope: ScopeCtx): Promise<ContractOutputs["onSessionEnd"]>;
+  staticBlock(scope: ScopeCtx): Promise<ContractOutputs["staticBlock"]>;
+}
+declare function parseInput<K extends ContractMethod>(method: K, input: unknown): ContractInputs[K];
+declare function parseOutput<K extends ContractMethod>(method: K, output: unknown): ContractOutputs[K];
+declare function contractJsonSchemas(method: ContractMethod): {
+  input: z.core.JSONSchema.JSONSchema;
+  output: z.core.JSONSchema.JSONSchema;
+};
+//#endregion
+export { ContractError as $, HostDecision as A, Turn as B, memoryEntrySchema as C, AgentModelRegistration as D, toolResponseSchema as E, Message as F, inspectionSchema as G, hostEventSchema as H, Mutation as I, recallOptionsSchema as J, messageSchema as K, RecallOptions as L, InitRegistration as M, Inspection as N, ContractInputs as O, JsonValue as P, usageSignalSchema as Q, Registration as R, inspectDataSchema as S, retrievalResultSchema as T, initRegistrationSchema as U, UsageSignal as V, inputSchemas as W, scopeSchema as X, registrationSchema as Y, turnSchema as Z, engineSettingsSchema as _, parseOutput as a, Result as b, MEMORY_ERROR_STATUS as c, MEMORY_ROUTES as d, DEGRADED_REASONS as et, MEMORY_SKIN_HEADER as f, EngineSettings as g, memoryMethod as h, parseInput as i, HostEvent as j, HostContext as k, MEMORY_HEALTH_TIMEOUT_MS as l, REM_SIDECAR_TOKEN_HEADER as m, MemoryContract as n, MEMORY_BODY_LIMIT_BYTES as o, MEMORY_START_TIMEOUT_MS as p, mutationSchema as q, contractJsonSchemas as r, MEMORY_DEFAULT_SKIN_ID as s, ContractMethod as t, DegradedReason as tt, MEMORY_RECONNECT_INTERVAL_MS as u, ContractOutputs as v, outputSchemas as w, ToolResponse as x, InspectData as y, ScopeCtx as z };