@remnic/core 1.0.0

package/dist/orchestrator.d.ts

@@ -0,0 +1,21 @@
+import './buffer.js';
+import './port-C1GZFv8h.js';
+import './storage.js';
+import './transcript.js';
+import './summarizer.js';
+import './local-llm.js';
+import './model-registry.js';
+import './relevance.js';
+import './negative.js';
+import './recall-state.js';
+import './session-observer-state.js';
+import './embedding-fallback.js';
+export { c as GraphRecallRankedResult, e as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, f as RecallInvocationOptions, g as RecallModeDecision, h as appendMemoryToGraphContext, i as blendGraphExpandedRecallScore, j as buildCompressionGuidelinesMarkdown, k as buildMemoryPathById, l as computeArtifactCandidateFetchLimit, m as computeArtifactRecallLimit, n as computeQmdHybridFetchLimit, d as defaultWorkspaceDir, o as deriveTopicsFromExtraction, p as filterRecallCandidates, q as formatCompressionGuidelinesForRecall, r as graphPathRelativeToStorage, t as hasIdentityRecoveryIntent, u as isArtifactMemoryPath, v as lifecycleRecallScoreAdjustment, w as mergeArtifactRecallCandidates, x as mergeGraphExpandedResults, y as resolveEffectiveIdentityInjectionMode, z as resolveEffectiveRecallMode, A as resolvePersistedMemoryRelativePath, B as resolveRecallModeDecision, D as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, E as shouldFilterLifecycleRecallCandidate, F as summarizeGraphShadowComparison } from './orchestrator-zTa-Qo-1.js';
+import './types.js';
+import './semantic-consolidation.js';
+import './policy-runtime.js';
+import './profiling.js';
+import './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+import './session-integrity.js';
+import 'zod';

package/dist/orchestrator.js

@@ -0,0 +1,145 @@
+import {
+  Orchestrator,
+  appendMemoryToGraphContext,
+  blendGraphExpandedRecallScore,
+  buildCompressionGuidelinesMarkdown,
+  buildMemoryPathById,
+  computeArtifactCandidateFetchLimit,
+  computeArtifactRecallLimit,
+  computeQmdHybridFetchLimit,
+  defaultWorkspaceDir,
+  deriveTopicsFromExtraction,
+  filterRecallCandidates,
+  formatCompressionGuidelinesForRecall,
+  graphPathRelativeToStorage,
+  hasIdentityRecoveryIntent,
+  isArtifactMemoryPath,
+  lifecycleRecallScoreAdjustment,
+  mergeArtifactRecallCandidates,
+  mergeGraphExpandedResults,
+  resolveEffectiveIdentityInjectionMode,
+  resolveEffectiveRecallMode,
+  resolvePersistedMemoryRelativePath,
+  resolveRecallModeDecision,
+  resolveRecentThreadMemoryPaths,
+  sanitizeSessionKeyForFilename,
+  shouldFilterLifecycleRecallCandidate,
+  summarizeGraphShadowComparison
+} from "./chunk-YAPUAHAY.js";
+import "./chunk-IFFFR3MR.js";
+import "./chunk-TKO4HZCK.js";
+import "./chunk-Z5AAYHUC.js";
+import "./chunk-4A24LIM2.js";
+import "./chunk-TPB3I2AC.js";
+import "./chunk-UHGBNIOS.js";
+import "./chunk-ZKYI7UVO.js";
+import "./chunk-CDW777AI.js";
+import "./chunk-ETOW6ACV.js";
+import "./chunk-G3AG3KZN.js";
+import "./chunk-2CJCWDMR.js";
+import "./chunk-X7XN6YU4.js";
+import "./chunk-BRK4ODMI.js";
+import "./chunk-C7VW7C3F.js";
+import "./chunk-GPGBSNKM.js";
+import "./chunk-V3RXWQIE.js";
+import "./chunk-YCN4BVDK.js";
+import "./chunk-L5RPWGFK.js";
+import "./chunk-HG2NKWR2.js";
+import "./chunk-GJR6D6KC.js";
+import "./chunk-H63EDPFJ.js";
+import "./chunk-WWIQTB2Y.js";
+import "./chunk-QFQVZOGA.js";
+import "./chunk-MWGVGUIS.js";
+import "./chunk-763GUIOU.js";
+import "./chunk-ONRU4L2N.js";
+import "./chunk-MDDAA2AO.js";
+import "./chunk-YAZNBMNF.js";
+import "./chunk-2PO5ZRKV.js";
+import "./chunk-VEWZZM3H.js";
+import "./chunk-QPKFPHOO.js";
+import "./chunk-V4YC4LUK.js";
+import "./chunk-HLBYLYRD.js";
+import "./chunk-OTAVQCSF.js";
+import "./chunk-3QKK7QOS.js";
+import "./chunk-UIYZ5T3I.js";
+import "./chunk-UCYSTFZR.js";
+import "./chunk-J47FNDR7.js";
+import "./chunk-CULXMQJH.js";
+import "./chunk-UV2FO7J4.js";
+import "./chunk-T4WRIV2C.js";
+import "./chunk-LOBRX7VD.js";
+import "./chunk-IZME7KW2.js";
+import "./chunk-YRMVARQP.js";
+import "./chunk-TVVVQQAK.js";
+import "./chunk-BDFZXRSO.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-AAI7JARD.js";
+import "./chunk-C6QPK5GG.js";
+import "./chunk-Q6FETXJA.js";
+import "./chunk-K6WK37A6.js";
+import "./chunk-SCHEKPYH.js";
+import "./chunk-ORZMT74A.js";
+import "./chunk-B7LOFDVE.js";
+import "./chunk-FYIYMQ5N.js";
+import "./chunk-2NMMFZ5T.js";
+import "./chunk-Z5LAYHGJ.js";
+import "./chunk-JWPLJLDU.js";
+import "./chunk-YNI4S5WT.js";
+import "./chunk-DORBM6OB.js";
+import "./chunk-XYIK4LF6.js";
+import "./chunk-KT4NEUNF.js";
+import "./chunk-LU3GQNDQ.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-M5KEYE5E.js";
+import "./chunk-NGAVDO7E.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-N5AKDXAI.js";
+import "./chunk-EQINRHYR.js";
+import "./chunk-EEQLFRUM.js";
+import "./chunk-QWUUMMIK.js";
+import "./chunk-U4PV25RD.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-TP4FZJIZ.js";
+import "./chunk-SCU65EZI.js";
+import "./chunk-BOUYNNYD.js";
+import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
+import "./chunk-YNCQ7E4M.js";
+import "./chunk-HLXVTBF3.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-KWBU5S5U.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+import "./chunk-6HZ6AO2P.js";
+import "./chunk-QCCCQT3O.js";
+export {
+  Orchestrator,
+  appendMemoryToGraphContext,
+  blendGraphExpandedRecallScore,
+  buildCompressionGuidelinesMarkdown,
+  buildMemoryPathById,
+  computeArtifactCandidateFetchLimit,
+  computeArtifactRecallLimit,
+  computeQmdHybridFetchLimit,
+  defaultWorkspaceDir,
+  deriveTopicsFromExtraction,
+  filterRecallCandidates,
+  formatCompressionGuidelinesForRecall,
+  graphPathRelativeToStorage,
+  hasIdentityRecoveryIntent,
+  isArtifactMemoryPath,
+  lifecycleRecallScoreAdjustment,
+  mergeArtifactRecallCandidates,
+  mergeGraphExpandedResults,
+  resolveEffectiveIdentityInjectionMode,
+  resolveEffectiveRecallMode,
+  resolvePersistedMemoryRelativePath,
+  resolveRecallModeDecision,
+  resolveRecentThreadMemoryPaths,
+  sanitizeSessionKeyForFilename,
+  shouldFilterLifecycleRecallCandidate,
+  summarizeGraphShadowComparison
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/orchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/policy-runtime.d.ts

@@ -0,0 +1,37 @@
+import { PluginConfig, BehaviorLoopPolicyState } from './types.js';
+
+interface RuntimePolicyValues {
+    recencyWeight?: number;
+    lifecyclePromoteHeatThreshold?: number;
+    lifecycleStaleDecayThreshold?: number;
+    cronRecallInstructionHeavyTokenCap?: number;
+}
+interface RuntimePolicySnapshot {
+    version: number;
+    updatedAt: string;
+    values: RuntimePolicyValues;
+    sourceAdjustmentCount: number;
+}
+declare function sanitizeRuntimePolicyValues(values: RuntimePolicyValues, options?: {
+    maxStaleDecayThreshold?: number;
+}): RuntimePolicyValues;
+declare function readRuntimePolicySnapshot(filePath: string, options?: {
+    maxStaleDecayThreshold?: number;
+}): Promise<RuntimePolicySnapshot | null>;
+declare class PolicyRuntimeManager {
+    private readonly memoryDir;
+    private readonly config;
+    private readonly runtimePath;
+    private readonly runtimePrevPath;
+    constructor(memoryDir: string, config: PluginConfig);
+    loadRuntimeValues(): Promise<RuntimePolicyValues | null>;
+    rollback(): Promise<boolean>;
+    applyFromBehaviorState(state: BehaviorLoopPolicyState): Promise<{
+        applied: boolean;
+        rolledBack: boolean;
+        values: RuntimePolicyValues | null;
+        reason: string;
+    }>;
+}
+
+export { PolicyRuntimeManager, type RuntimePolicySnapshot, type RuntimePolicyValues, readRuntimePolicySnapshot, sanitizeRuntimePolicyValues };

package/dist/policy-runtime.js

@@ -0,0 +1,13 @@
+import {
+  PolicyRuntimeManager,
+  readRuntimePolicySnapshot,
+  sanitizeRuntimePolicyValues
+} from "./chunk-T4WRIV2C.js";
+import "./chunk-6HZ6AO2P.js";
+import "./chunk-QCCCQT3O.js";
+export {
+  PolicyRuntimeManager,
+  readRuntimePolicySnapshot,
+  sanitizeRuntimePolicyValues
+};
+//# sourceMappingURL=policy-runtime.js.map

package/dist/policy-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/port-C1GZFv8h.d.ts

@@ -0,0 +1,41 @@
+import { QmdSearchResult } from './types.js';
+
+/** Alias so consumers don't need to reference "Qmd" in a backend-agnostic context. */
+type SearchResult = QmdSearchResult;
+interface SearchQueryOptions {
+    intent?: string;
+    explain?: boolean;
+}
+interface SearchExecutionOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Abstract search backend interface.
+ *
+ * Implementations:
+ * - QmdClient (default, local hybrid BM25+vector+reranking)
+ * - OramaBackend (embedded, pure JS, hybrid FTS+vector)
+ * - LanceDbBackend (embedded, native Arrow bindings, RRF reranking)
+ * - MeilisearchBackend (server-based SDK, hybrid search)
+ * - RemoteSearchBackend (HTTP REST adapter)
+ * - NoopSearchBackend (graceful degradation)
+ *
+ * See docs/writing-a-search-backend.md for the implementation guide.
+ */
+interface SearchBackend {
+    probe(): Promise<boolean>;
+    isAvailable(): boolean;
+    debugStatus(): string;
+    search(query: string, collection?: string, maxResults?: number, options?: SearchQueryOptions, execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    searchGlobal(query: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    bm25Search(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    vectorSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    hybridSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]>;
+    update(): Promise<void>;
+    updateCollection(collection: string): Promise<void>;
+    embed(): Promise<void>;
+    embedCollection(collection: string): Promise<void>;
+    ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+}
+
+export type { SearchBackend as S, SearchQueryOptions as a, SearchExecutionOptions as b, SearchResult as c };

package/dist/profiling.d.ts

@@ -0,0 +1,80 @@
+interface ProfileSpan {
+    name: string;
+    startOffsetMs: number;
+    durationMs: number;
+}
+interface ProfileParallelGroupMember {
+    name: string;
+    durationMs: number;
+    resolvedIndex: number;
+}
+interface ProfileParallelGroup {
+    name: string;
+    startOffsetMs: number;
+    wallMs: number;
+    members: ProfileParallelGroupMember[];
+}
+interface ProfileTrace {
+    ts: string;
+    kind: "recall" | "extraction";
+    traceId: string;
+    sessionKey?: string;
+    totalMs: number;
+    spans: ProfileSpan[];
+    parallelGroups?: ProfileParallelGroup[];
+    configSnapshot?: Record<string, unknown>;
+}
+interface ProfilingConfig {
+    enabled: boolean;
+    storageDir: string;
+    maxTraces: number;
+}
+interface ParallelGroupHandle {
+    name: string;
+    startOffsetMs: number;
+    traceId?: string;
+}
+interface ProfilingStats {
+    byKind: Record<string, {
+        count: number;
+        avgMs: number;
+        p50Ms: number;
+        p95Ms: number;
+        maxMs: number;
+    }>;
+    bySpan: Record<string, {
+        count: number;
+        avgMs: number;
+        p50Ms: number;
+        p95Ms: number;
+        maxMs: number;
+    }>;
+}
+declare class ProfilingCollector {
+    private enabled;
+    private storageDir;
+    private maxTraces;
+    private traces;
+    private prunePromise;
+    private activeTraces;
+    private latestTraceId;
+    constructor(config: ProfilingConfig);
+    get isEnabled(): boolean;
+    startTrace(kind: "recall" | "extraction", sessionKey?: string, configSnapshot?: Record<string, unknown>): string;
+    startSpan(name: string, traceId?: string): void;
+    endSpan(name: string, traceId?: string): void;
+    endTrace(traceId?: string): ProfileTrace | null;
+    startParallelGroup(name: string, traceId?: string): ParallelGroupHandle;
+    endParallelGroup(handle: ParallelGroupHandle, members: Array<{
+        name: string;
+        promise: Promise<unknown>;
+    }>): Promise<void>;
+    getRecentTraces(limit?: number): ProfileTrace[];
+    getStats(): ProfilingStats;
+    identifyBottleneck(): string | null;
+    private persistTrace;
+    pruneFiles(): Promise<void>;
+}
+declare function formatProfileTraceAscii(trace: ProfileTrace): string;
+
+export { type ParallelGroupHandle, type ProfileParallelGroup, type ProfileParallelGroupMember, type ProfileSpan, type ProfileTrace, ProfilingCollector, type ProfilingConfig, type ProfilingStats, formatProfileTraceAscii };

package/dist/profiling.js

@@ -0,0 +1,10 @@
+import {
+  ProfilingCollector,
+  formatProfileTraceAscii
+} from "./chunk-763GUIOU.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  ProfilingCollector,
+  formatProfileTraceAscii
+};
+//# sourceMappingURL=profiling.js.map

package/dist/profiling.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/qmd-recall-cache.d.ts

@@ -0,0 +1,29 @@
+import { RecallPlanMode } from './types.js';
+import { a as SearchQueryOptions } from './port-C1GZFv8h.js';
+
+type QmdRecallCacheSource = "fresh" | "stale";
+interface QmdRecallCacheHit<T> {
+    value: T;
+    source: QmdRecallCacheSource;
+    ageMs: number;
+}
+interface QmdRecallCacheKeyOptions {
+    query: string;
+    namespaces: string[];
+    recallMode: RecallPlanMode;
+    maxResults: number;
+    memoryDir?: string;
+    collection?: string;
+    searchOptions?: SearchQueryOptions;
+}
+declare function buildQmdRecallCacheKey(options: QmdRecallCacheKeyOptions): string;
+declare function getCachedQmdRecall<T>(cacheKey: string, options: {
+    freshTtlMs: number;
+    staleTtlMs: number;
+}): QmdRecallCacheHit<T> | null;
+declare function setCachedQmdRecall<T>(cacheKey: string, value: T, options: {
+    maxEntries: number;
+}): void;
+declare function clearQmdRecallCache(): void;
+
+export { type QmdRecallCacheHit, type QmdRecallCacheKeyOptions, type QmdRecallCacheSource, buildQmdRecallCacheKey, clearQmdRecallCache, getCachedQmdRecall, setCachedQmdRecall };

package/dist/qmd-recall-cache.js

@@ -0,0 +1,13 @@
+import {
+  buildQmdRecallCacheKey,
+  clearQmdRecallCache,
+  getCachedQmdRecall,
+  setCachedQmdRecall
+} from "./chunk-YCN4BVDK.js";
+export {
+  buildQmdRecallCacheKey,
+  clearQmdRecallCache,
+  getCachedQmdRecall,
+  setCachedQmdRecall
+};
+//# sourceMappingURL=qmd-recall-cache.js.map

package/dist/qmd-recall-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/qmd.d.ts

@@ -0,0 +1,105 @@
+import { QmdSearchResult, QmdSearchExplain } from './types.js';
+import { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions } from './port-C1GZFv8h.js';
+
+interface QmdClientOptions {
+    slowLog?: {
+        enabled: boolean;
+        thresholdMs: number;
+    };
+    updateTimeoutMs?: number;
+    updateMinIntervalMs?: number;
+    qmdPath?: string;
+    daemonUrl?: string;
+    daemonRecheckIntervalMs?: number;
+}
+declare function parseQmdExplain(value: unknown): QmdSearchExplain | undefined;
+declare class QmdClient implements SearchBackend {
+    private readonly collection;
+    private readonly maxResults;
+    private available;
+    private lastUpdateFailAtMs;
+    private lastEmbedFailAtMs;
+    private lastUpdateRunAtMs;
+    private readonly updateTimeoutMs;
+    private readonly updateMinIntervalMs;
+    private readonly slowLog?;
+    private readonly configuredQmdPath?;
+    private qmdPathSource;
+    private cliVersion;
+    private lastCliProbeError;
+    private daemonSession;
+    private daemonAvailable;
+    private lastDaemonCheckAtMs;
+    private readonly daemonEnabled;
+    private readonly daemonRecheckIntervalMs;
+    /** Consecutive transient daemon failures before invalidating the session. */
+    private daemonTransientFailures;
+    private static readonly DAEMON_MAX_TRANSIENT_FAILURES;
+    constructor(collection: string, maxResults: number, opts?: QmdClientOptions);
+    private qmdPath;
+    probe(): Promise<boolean>;
+    private probeDaemon;
+    private probeCli;
+    private logCliProbeWarning;
+    /** Re-probe daemon if it was down and recheck interval has elapsed. */
+    private maybeProbeDaemon;
+    isAvailable(): boolean;
+    /** Debug string for troubleshooting availability issues. */
+    debugStatus(): string;
+    isDaemonMode(): boolean;
+    /**
+     * Record a daemon search success — resets the transient failure counter.
+     */
+    private recordDaemonSuccess;
+    /**
+     * Handle a non-timeout, non-cancellation daemon error.
+     * Tolerates up to DAEMON_MAX_TRANSIENT_FAILURES consecutive failures
+     * before invalidating the session. This prevents a single transient
+     * error from pushing all concurrent searches through the subprocess
+     * mutex for the full recheck interval.
+     */
+    private handleDaemonTransientError;
+    private runQmdCommand;
+    private supportsIntentHints;
+    private supportsExplainTraces;
+    /**
+     * QMD v2 (>= 2.0.0) uses a new MCP tool API:
+     * - `search` and `vsearch` tools removed; only `query` tool exists
+     * - `query` accepts `{ searches: [{ type, query }], collections?: string[] }`
+     *   instead of `{ query: string, collection?: string }`
+     * - `collection` (singular) → `collections` (plural array)
+     */
+    private isQmdV2;
+    private resolveSearchOptions;
+    resolveSupportedSearchOptions(options?: SearchQueryOptions): SearchQueryOptions | undefined;
+    search(query: string, collection?: string, maxResults?: number, options?: SearchQueryOptions, execution?: SearchExecutionOptions): Promise<QmdSearchResult[]>;
+    searchGlobal(query: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<QmdSearchResult[]>;
+    /**
+     * BM25 keyword search (fast, ~0.3s). Uses `qmd search`.
+     */
+    bm25Search(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<QmdSearchResult[]>;
+    /**
+     * Vector similarity search (~3-4s). Uses `qmd vsearch`.
+     */
+    vectorSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<QmdSearchResult[]>;
+    /**
+     * Hybrid search: runs BM25 + vector in parallel, merges/dedupes by path
+     * keeping the best score and first non-empty snippet.
+     */
+    hybridSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<QmdSearchResult[]>;
+    private searchViaDaemon;
+    private bm25SearchViaDaemon;
+    private vsearchViaDaemon;
+    private searchViaSubprocess;
+    private bm25SearchViaSubprocess;
+    private vsearchViaSubprocess;
+    private searchGlobalViaSubprocess;
+    update(): Promise<void>;
+    updateCollection(collection: string): Promise<void>;
+    private runUpdateForCollection;
+    embed(): Promise<void>;
+    embedCollection(collection: string): Promise<void>;
+    ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+}
+
+export { QmdClient, type QmdClientOptions, parseQmdExplain };

package/dist/qmd.js

@@ -0,0 +1,13 @@
+import {
+  QmdClient,
+  parseQmdExplain
+} from "./chunk-TVVVQQAK.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  QmdClient,
+  parseQmdExplain
+};
+//# sourceMappingURL=qmd.js.map

package/dist/qmd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/recall-qos.d.ts

@@ -0,0 +1,33 @@
+import { LoggerBackend } from './logger.js';
+
+type RecallSectionPriority = "core" | "enrichment";
+type RecallSectionSource = "fresh" | "stale" | "skip";
+interface RecallSectionMetric {
+    section: string;
+    priority: RecallSectionPriority;
+    durationMs: number;
+    deadlineMs: number;
+    source: RecallSectionSource;
+    success: boolean;
+    timing?: string;
+}
+interface RecallSectionMetricLog {
+    message: string;
+    payload: {
+        section: string;
+        priority: RecallSectionPriority;
+        durationMs: number;
+        deadlineMs: number;
+        source: RecallSectionSource;
+        success: boolean;
+    };
+    level: "info" | "debug";
+    timing: string;
+}
+declare function formatRecallSectionMetric(metric: RecallSectionMetric): RecallSectionMetricLog;
+declare function createRecallSectionMetricRecorder(options?: {
+    timings?: Record<string, string>;
+    logger?: Pick<LoggerBackend, "info" | "debug">;
+}): (metric: RecallSectionMetric) => RecallSectionMetricLog;
+
+export { type RecallSectionMetric, type RecallSectionMetricLog, type RecallSectionPriority, type RecallSectionSource, createRecallSectionMetricRecorder, formatRecallSectionMetric };

package/dist/recall-qos.js

@@ -0,0 +1,10 @@
+import {
+  createRecallSectionMetricRecorder,
+  formatRecallSectionMetric
+} from "./chunk-L5RPWGFK.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  createRecallSectionMetricRecorder,
+  formatRecallSectionMetric
+};
+//# sourceMappingURL=recall-qos.js.map

package/dist/recall-qos.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/recall-query-policy.d.ts

@@ -0,0 +1,20 @@
+type RecallPromptShape = "standard" | "instruction_heavy";
+type CronConversationRecallMode = "auto" | "always" | "never";
+type RecallBudgetMode = "full" | "minimal";
+interface RecallQueryPolicyConfig {
+    cronRecallPolicyEnabled: boolean;
+    cronRecallNormalizedQueryMaxChars: number;
+    cronRecallInstructionHeavyTokenCap: number;
+    cronConversationRecallMode: CronConversationRecallMode;
+}
+interface RecallQueryPolicyResult {
+    promptShape: RecallPromptShape;
+    retrievalQuery: string;
+    skipConversationRecall: boolean;
+    retrievalBudgetMode: RecallBudgetMode;
+}
+declare function classifyRecallPromptShape(prompt: string): RecallPromptShape;
+declare function clampInstructionHeavyTokenCap(value: number): number;
+declare function buildRecallQueryPolicy(prompt: string, sessionKey: string | undefined, cfg: RecallQueryPolicyConfig): RecallQueryPolicyResult;
+
+export { type CronConversationRecallMode, type RecallBudgetMode, type RecallPromptShape, type RecallQueryPolicyConfig, type RecallQueryPolicyResult, buildRecallQueryPolicy, clampInstructionHeavyTokenCap, classifyRecallPromptShape };

package/dist/recall-query-policy.js

@@ -0,0 +1,11 @@
+import {
+  buildRecallQueryPolicy,
+  clampInstructionHeavyTokenCap,
+  classifyRecallPromptShape
+} from "./chunk-6HZ6AO2P.js";
+export {
+  buildRecallQueryPolicy,
+  clampInstructionHeavyTokenCap,
+  classifyRecallPromptShape
+};
+//# sourceMappingURL=recall-query-policy.js.map

package/dist/recall-query-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}