@remnic/core 1.0.2 → 1.1.0

package/dist/direct-answer.d.ts

@@ -0,0 +1,106 @@
+import { MemoryFile } from './types.js';
+import { TrustZoneName } from './trust-zones.js';
+
+/**
+ * Direct-answer retrieval tier eligibility (issue #518 slice 2).
+ *
+ * This module is a pure decision layer.  It takes a query, a set of
+ * caller-resolved candidates (each already decorated with trust-zone,
+ * taxonomy-bucket, and importance information), and the direct-answer
+ * config, then returns an eligibility verdict.
+ *
+ * Keeping the module pure means:
+ *
+ * - Tests do not need a trust-zones store, taxonomy resolver, or importance
+ *   scorer on disk.
+ * - Slice 3 (retrieval.ts wiring) is responsible for resolving those signals
+ *   before calling in; the wiring layer decides where candidates come from
+ *   (entity index, token prefilter, etc.).  This module only decides
+ *   whether the surfaced candidates add up to a confident direct answer.
+ *
+ * Not wired into retrieval yet — see slice 3.
+ */
+
+/**
+ * Caller-supplied candidate.
+ *
+ * `trustZone`, `taxonomyBucket`, and `importanceScore` are resolved outside
+ * this module because each comes from a different subsystem.  Passing them
+ * as inputs keeps the function deterministic and easy to unit-test.
+ *
+ * `matchScore` is optional; if omitted, candidates are ranked by
+ * token-overlap ratio.  Callers that already computed a better ranking
+ * score (e.g. BM25, vector similarity) can supply it to drive the
+ * ambiguity check.
+ */
+interface DirectAnswerCandidate {
+    memory: MemoryFile;
+    trustZone: TrustZoneName | null;
+    taxonomyBucket: string | null;
+    importanceScore: number;
+    matchScore?: number;
+}
+interface DirectAnswerConfig {
+    enabled: boolean;
+    tokenOverlapFloor: number;
+    importanceFloor: number;
+    ambiguityMargin: number;
+    eligibleTaxonomyBuckets: string[];
+}
+interface DirectAnswerInput {
+    query: string;
+    candidates: DirectAnswerCandidate[];
+    config: DirectAnswerConfig;
+    /**
+     * Optional entity-ref hints resolved from the query upstream.  When
+     * supplied, a candidate with a set `entityRef` must match one of these
+     * (case-insensitive) to remain eligible.  Candidates without an
+     * `entityRef` are allowed through regardless.
+     */
+    queryEntityRefs?: string[];
+}
+type DirectAnswerReason = "disabled" | "empty-query" | "no-candidates" | "no-eligible-candidates" | "below-token-overlap-floor" | "ambiguous" | "eligible";
+interface DirectAnswerResult {
+    eligible: boolean;
+    reason: DirectAnswerReason;
+    /** Winning candidate when eligible. */
+    winner?: DirectAnswerCandidate;
+    /** Computed token-overlap ratio (0..1) of the winner. */
+    tokenOverlap?: number;
+    /**
+     * Human-readable summary suitable for
+     * `RecallTierExplain.tierReason`.
+     */
+    narrative: string;
+    /**
+     * Filter labels that eliminated at least one candidate along the way.
+     * Populated regardless of eligibility so the caller can surface the
+     * narrowing steps in `RecallTierExplain.filteredBy`.
+     */
+    filteredBy: string[];
+}
+/** Filter labels — exported so callers and tests can match them structurally. */
+declare const FILTER_LABELS: {
+    readonly nonActiveStatus: "non-active-status";
+    readonly notTrustedZone: "not-trusted-zone";
+    readonly ineligibleTaxonomyBucket: "ineligible-taxonomy-bucket";
+    readonly belowImportanceFloor: "below-importance-floor";
+    readonly entityRefMismatch: "entity-ref-mismatch";
+    readonly belowTokenOverlapFloor: "below-token-overlap-floor";
+};
+/**
+ * Determine whether a query can be served by the direct-answer tier.
+ *
+ * Decision ladder, in order:
+ *
+ *   1. config.enabled === false → "disabled"
+ *   2. empty query tokens → "empty-query"
+ *   3. empty candidates → "no-candidates"
+ *   4. hard filters drop all candidates → "no-eligible-candidates"
+ *   5. token-overlap floor drops all → "below-token-overlap-floor"
+ *   6. top two candidates within ambiguityMargin → "ambiguous"
+ *   7. otherwise → "eligible"
+ */
+declare function isDirectAnswerEligible(input: DirectAnswerInput): DirectAnswerResult;
+
+export { type DirectAnswerCandidate, type DirectAnswerConfig, type DirectAnswerInput, type DirectAnswerReason, type DirectAnswerResult, FILTER_LABELS, isDirectAnswerEligible };

package/dist/direct-answer.js

@@ -0,0 +1,10 @@
+import {
+  FILTER_LABELS,
+  isDirectAnswerEligible
+} from "./chunk-Y4FHOFJ2.js";
+import "./chunk-DT5TVLJE.js";
+export {
+  FILTER_LABELS,
+  isDirectAnswerEligible
+};
+//# sourceMappingURL=direct-answer.js.map

package/dist/direct-answer.js.map

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

package/dist/embedding-fallback.d.ts

@@ -1,12 +1,106 @@
 import { PluginConfig } from './types.js';
 
+/**
+ * Thrown by `EmbeddingFallback.search()` (via `embed()`) when the embedding
+ * backend is effectively unavailable on the lookup path — either because the
+ * HTTP fetch exceeded its deadline OR because the endpoint returned a non-2xx
+ * status code. Callers that need to distinguish a backend outage from "no
+ * candidates" can `instanceof`-check against this class.
+ *
+ * Round 9 fix (Finding UZqB): previously a timeout returned null from embed(),
+ * which caused search() to return [] silently. decideSemanticDedup then
+ * classified the result as no_candidates instead of backend_unavailable, so
+ * the per-batch batchBackendUnavailable short-circuit never activated and
+ * batches of N facts each paid a full timeout roundtrip.
+ *
+ * Round 10 fix (Findings Ui1J + Ui1L): search() now only re-throws this error
+ * when the caller explicitly passes `{ throwOnTimeout: true }`. Without that
+ * flag search() catches it and returns [] instead, preserving fail-open
+ * semantics for recall-path callers (searchEmbeddingFallback) that have no
+ * try/catch. Only the semantic-dedup path (semanticDedupLookup) passes the
+ * flag so it can still reach decideSemanticDedup's backend_unavailable branch.
+ *
+ * Round 11 fix (Finding Ur_J): `embed()` now also throws this error from the
+ * lookup path when the HTTP response is non-2xx (e.g. 429, 500, 503). Without
+ * this, repeated 5xx outages would each return null → [] → no_candidates and
+ * subsequent facts in the same batch would all pay full roundtrips instead of
+ * tripping the per-batch backend_unavailable short-circuit.
+ *
+ * The class name is kept for backward compatibility — `EmbeddingTimeoutError`
+ * now signals "lookup backend unavailable" rather than strictly "timed out".
+ */
+declare class EmbeddingTimeoutError extends Error {
+    readonly name: "EmbeddingTimeoutError";
+    constructor(message: string);
+}
+/**
+ * Options for the low-level embed() call.
+ *
+ * `mode` selects the timeout profile:
+ *   - "lookup" (default): bounded by the short lookup budget; fails open fast.
+ *   - "index": bounded by a much longer budget so slow backends can still
+ *     index newly persisted memories.
+ */
+type EmbedMode = "lookup" | "index";
 declare class EmbeddingFallback {
     private readonly config;
     private readonly indexPath;
     private loaded;
     constructor(config: PluginConfig);
     isAvailable(): Promise<boolean>;
-    search(query: string, limit: number): Promise<Array<{
+    /**
+     * Embed an array of texts and return their embedding vectors.
+     *
+     * This is the public batch-embed interface used by semantic chunking
+     * (Finding 1, PR #420 post-merge). Texts are grouped into batches of
+     * `embeddingBatchSize` (from `semanticChunkingConfig`, default 32) and
+     * each batch is dispatched concurrently via `Promise.all()`. This
+     * preserves the semantic intent of `embeddingBatchSize` — without batching,
+     * every text incurred a sequential HTTP round-trip, making the batch size
+     * config ineffective. (PR #439 post-merge Finding 2.)
+     *
+     * If the provider is unavailable or any single embedding fails, the method
+     * throws so the caller can fall back to recursive chunking.
+     */
+    embedTexts(texts: string[]): Promise<number[][]>;
+    /**
+     * Nearest-neighbor search against the embedding index.
+     *
+     * @param query         The query string to embed and search for.
+     * @param limit         Max number of hits to return.
+     * @param options       Optional filters.
+     *   - `pathPrefix`   Restrict candidates to entries whose indexed `path`
+     *                    starts with this prefix (relative to `memoryDir`).
+     *                    Used by the semantic dedup guard to scope lookups
+     *                    to the target namespace so a high-similarity hit
+     *                    from a different namespace can't suppress a write
+     *                    in the target namespace. Default: no filter.
+     *   - `pathExcludePrefixes`
+     *                    Exclude any entry whose indexed `path` starts with
+     *                    any of these prefixes. Used for the default
+     *                    namespace case: when the default namespace lives at
+     *                    `memoryDir` root (legacy layout) we still want to
+     *                    exclude `namespaces/<other>/…` entries.
+     */
+    search(query: string, limit: number, options?: {
+        pathPrefix?: string;
+        pathExcludePrefixes?: readonly string[];
+        /**
+         * When true, an `EmbeddingTimeoutError` from the embedding backend is
+         * re-thrown to the caller. Use this on the semantic-dedup path so
+         * `decideSemanticDedup`'s catch block can classify the result as
+         * `reason="backend_unavailable"` and activate the per-batch
+         * short-circuit.
+         *
+         * When false (the default), a timeout is caught here and search()
+         * returns [] instead — preserving fail-open semantics for the recall
+         * path (`searchEmbeddingFallback`) which has no surrounding try/catch.
+         * Without this gate a timed-out embedding request on the recall path
+         * would propagate as an unhandled rejection and abort recall entirely.
+         * (Round 10 fix, Findings Ui1J + Ui1L.)
+         */
+        throwOnTimeout?: boolean;
+    }): Promise<Array<{
         id: string;
         score: number;
         path: string;
@@ -19,4 +113,4 @@ declare class EmbeddingFallback {
     private saveIndex;
 }
 
-export { EmbeddingFallback };
+export { type EmbedMode, EmbeddingFallback, EmbeddingTimeoutError };

package/dist/embedding-fallback.js

@@ -1,8 +1,10 @@
 import {
-  EmbeddingFallback
-} from "./chunk-QPKFPHOO.js";
-import "./chunk-KWBU5S5U.js";
+  EmbeddingFallback,
+  EmbeddingTimeoutError
+} from "./chunk-ALXMCZEU.js";
+import "./chunk-2ODBA7MQ.js";
 export {
-  EmbeddingFallback
+  EmbeddingFallback,
+  EmbeddingTimeoutError
 };
 //# sourceMappingURL=embedding-fallback.js.map

package/dist/{engine-2A6J4XEX.js → engine-5TIQBYZR.js}

@@ -1,19 +1,22 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UYSKNO6E.js";
-import "./chunk-QWUUMMIK.js";
-import "./chunk-U4PV25RD.js";
-import "./chunk-ESSMF2FR.js";
-import "./chunk-TP4FZJIZ.js";
+} from "./chunk-DHHP2Z4X.js";
+import "./chunk-GV6NLQ4X.js";
+import "./chunk-3WHVNEN7.js";
+import "./chunk-4KAN3GZ3.js";
+import "./chunk-6ZH4TU6I.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-BOUYNNYD.js";
+import "./chunk-6PFRXT4K.js";
+import "./chunk-TP4FZJIZ.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-M62O4P4T.js";
-import "./chunk-KWBU5S5U.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
 };
-//# sourceMappingURL=engine-2A6J4XEX.js.map
+//# sourceMappingURL=engine-5TIQBYZR.js.map

package/dist/engine-5TIQBYZR.js.map

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

package/dist/entity-retrieval.d.ts

@@ -1,6 +1,7 @@
 import { StorageManager } from './storage.js';
 import { PluginConfig, TranscriptEntry } from './types.js';
-import './memory-projection-store-NxMkbocT.js';
+import './page-versioning.js';
+import './memory-projection-store-DeSXPh1j.js';
 import 'better-sqlite3';
 
 interface BuildEntityRecallSectionOptions {
@@ -17,7 +18,7 @@ interface BuildEntityRecallSectionOptions {
 }
 declare function buildEntityRecallSection(options: BuildEntityRecallSectionOptions): Promise<string | null>;
 declare function readRecentEntityTranscriptEntries(transcriptEntriesPromise: Promise<TranscriptEntry[]>, recentTurns: number): Promise<TranscriptEntry[]>;
-declare const entityIndexVersion = 1;
+declare const entityIndexVersion = 3;
 declare const entityRecentTranscriptLookbackHours = 24;
 
 export { type BuildEntityRecallSectionOptions, buildEntityRecallSection, entityIndexVersion, entityRecentTranscriptLookbackHours, readRecentEntityTranscriptEntries };

package/dist/entity-retrieval.js

@@ -3,18 +3,21 @@ import {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-V4YC4LUK.js";
-import "./chunk-Q6FETXJA.js";
-import "./chunk-QWUUMMIK.js";
-import "./chunk-U4PV25RD.js";
-import "./chunk-ESSMF2FR.js";
-import "./chunk-TP4FZJIZ.js";
+} from "./chunk-7WQ6SLIE.js";
+import "./chunk-7SEAZFFB.js";
+import "./chunk-GV6NLQ4X.js";
+import "./chunk-3WHVNEN7.js";
+import "./chunk-4KAN3GZ3.js";
+import "./chunk-6ZH4TU6I.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-BOUYNNYD.js";
+import "./chunk-6PFRXT4K.js";
+import "./chunk-TP4FZJIZ.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-M62O4P4T.js";
-import "./chunk-KWBU5S5U.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   buildEntityRecallSection,
   entityIndexVersion,

package/dist/entity-schema.d.ts

@@ -0,0 +1,11 @@
+import { EntitySchemaDefinition, EntitySchemaSectionDefinition, EntityStructuredSection } from './types.js';
+
+declare function normalizeEntityText(value: string): string;
+declare function normalizeEntitySchemas(raw: unknown): Record<string, EntitySchemaDefinition> | undefined;
+declare function getEntitySchema(entityType: string, entitySchemas?: Record<string, EntitySchemaDefinition>): EntitySchemaDefinition | undefined;
+declare function matchEntitySchemaSection(entityType: string, title: string, entitySchemas?: Record<string, EntitySchemaDefinition>): EntitySchemaSectionDefinition | null;
+declare function normalizeEntityStructuredSection(entityType: string, section: Pick<EntityStructuredSection, "key" | "title">, entitySchemas?: Record<string, EntitySchemaDefinition>): Pick<EntityStructuredSection, "key" | "title">;
+declare function resolveRequestedEntitySectionKeys(query: string, entityType: string, availableSections: EntityStructuredSection[], entitySchemas?: Record<string, EntitySchemaDefinition>): string[];
+declare function sortStructuredSectionsBySchema(entityType: string, sections: EntityStructuredSection[], entitySchemas?: Record<string, EntitySchemaDefinition>): EntityStructuredSection[];
+
+export { getEntitySchema, matchEntitySchemaSection, normalizeEntitySchemas, normalizeEntityStructuredSection, normalizeEntityText, resolveRequestedEntitySectionKeys, sortStructuredSectionsBySchema };

package/dist/entity-schema.js

@@ -0,0 +1,19 @@
+import {
+  getEntitySchema,
+  matchEntitySchemaSection,
+  normalizeEntitySchemas,
+  normalizeEntityStructuredSection,
+  normalizeEntityText,
+  resolveRequestedEntitySectionKeys,
+  sortStructuredSectionsBySchema
+} from "./chunk-4DJQYKMN.js";
+export {
+  getEntitySchema,
+  matchEntitySchemaSection,
+  normalizeEntitySchemas,
+  normalizeEntityStructuredSection,
+  normalizeEntityText,
+  resolveRequestedEntitySectionKeys,
+  sortStructuredSectionsBySchema
+};
+//# sourceMappingURL=entity-schema.js.map

package/dist/entity-schema.js.map

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

package/dist/explicit-capture.d.ts

@@ -1,8 +1,9 @@
-import { O as Orchestrator } from './orchestrator-zTa-Qo-1.js';
+import { O as Orchestrator } from './orchestrator-DRYA6_lW.js';
 import { MemoryCategory, PluginConfig } from './types.js';
 import './buffer.js';
 import './storage.js';
-import './memory-projection-store-NxMkbocT.js';
+import './page-versioning.js';
+import './memory-projection-store-DeSXPh1j.js';
 import 'better-sqlite3';
 import './port-C1GZFv8h.js';
 import './transcript.js';
@@ -15,7 +16,9 @@ import './negative.js';
 import './recall-state.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
-import './semantic-consolidation.js';
+import './semantic-consolidation-DrvSYRdB.js';
+import './codex-materialize-CQlLTzke.js';
+import './logger.js';
 import 'zod';
 import './policy-runtime.js';
 import './profiling.js';

package/dist/explicit-capture.js

@@ -7,8 +7,8 @@ import {
   shouldSkipImplicitExtraction,
   stripInlineExplicitCaptureNotes,
   validateExplicitCaptureInput
-} from "./chunk-YNCQ7E4M.js";
-import "./chunk-HLXVTBF3.js";
+} from "./chunk-QDYXG4CS.js";
+import "./chunk-QNJMBKFK.js";
 import "./chunk-M62O4P4T.js";
 export {
   hasInlineExplicitCaptureMarkup,

package/dist/extraction-judge.d.ts

@@ -0,0 +1,66 @@
+import { ImportanceLevel, PluginConfig } from './types.js';
+import { LocalLlmClient } from './local-llm.js';
+import { FallbackLlmClient } from './fallback-llm.js';
+import './model-registry.js';
+
+/**
+ * Extraction Judge — LLM-as-judge fact-worthiness gate (issue #376).
+ *
+ * Evaluates extracted facts against a durability rubric before they are
+ * persisted. Facts that are unlikely to be useful 30+ days from now or
+ * across sessions are rejected (or shadow-logged depending on config).
+ *
+ * Design constraints:
+ *   - Corrections and principles are auto-approved (safety bypass).
+ *   - Critical-importance facts are auto-approved.
+ *   - Batches respect extractionJudgeBatchSize.
+ *   - Content-hash caching avoids redundant LLM calls.
+ *   - Performance budget: <= 1.5s per batch.
+ */
+
+interface JudgeCandidate {
+    text: string;
+    category: string;
+    confidence: number;
+    tags?: string[];
+    /** Local importance level, set by caller before judging. */
+    importanceLevel?: ImportanceLevel;
+}
+interface JudgeVerdict {
+    durable: boolean;
+    reason: string;
+}
+interface JudgeBatchResult {
+    verdicts: Map<number, JudgeVerdict>;
+    /** Number of verdicts served from cache. */
+    cached: number;
+    /** Number of verdicts produced by an LLM call. */
+    judged: number;
+    /** Total wall-clock time in milliseconds. */
+    elapsed: number;
+}
+/**
+ * Deterministic gate for extracted `procedure` memories: ≥2 steps with non-empty
+ * intents and explicit trigger wording in title and/or steps.
+ */
+declare function validateProcedureExtraction(input: {
+    content: string;
+    procedureSteps?: unknown;
+}): JudgeVerdict;
+/**
+ * Evaluate a batch of candidate facts for durability.
+ *
+ * Auto-approves corrections, principles, and critical-importance facts.
+ * Remaining candidates are batched (up to extractionJudgeBatchSize),
+ * checked against an in-memory content-hash cache, and sent to the LLM
+ * for verdict.
+ */
+declare function judgeFactDurability(candidates: JudgeCandidate[], config: PluginConfig, localLlm: LocalLlmClient | null, fallbackLlm: FallbackLlmClient | null, cache?: Map<string, JudgeVerdict>): Promise<JudgeBatchResult>;
+/** Clear the in-memory default verdict cache. Primarily for tests. */
+declare function clearVerdictCache(): void;
+/** Return the current default verdict cache size. Primarily for tests. */
+declare function verdictCacheSize(): number;
+/** Create a new per-instance verdict cache. Orchestrators should hold one. */
+declare function createVerdictCache(): Map<string, JudgeVerdict>;
+
+export { type JudgeBatchResult, type JudgeCandidate, type JudgeVerdict, clearVerdictCache, createVerdictCache, judgeFactDurability, validateProcedureExtraction, verdictCacheSize };

package/dist/extraction-judge.js

@@ -0,0 +1,18 @@
+import {
+  clearVerdictCache,
+  createVerdictCache,
+  judgeFactDurability,
+  validateProcedureExtraction,
+  verdictCacheSize
+} from "./chunk-LAYN4LDC.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-QDW3E4RD.js";
+import "./chunk-2ODBA7MQ.js";
+export {
+  clearVerdictCache,
+  createVerdictCache,
+  judgeFactDurability,
+  validateProcedureExtraction,
+  verdictCacheSize
+};
+//# sourceMappingURL=extraction-judge.js.map

package/dist/extraction-judge.js.map

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

package/dist/extraction.d.ts

@@ -37,6 +37,7 @@ declare class ExtractionEngine {
     private sanitizeExtractionResult;
     private hasExtractionOutputs;
     private normalizeExtractionResultPayload;
+    private normalizeEntityUpdate;
     private parseJsonObject;
     private normalizeContradictionVerificationResult;
     private normalizeSuggestedLinksResult;

package/dist/extraction.js

@@ -1,22 +1,24 @@
 import {
   ExtractionEngine
-} from "./chunk-6UJQNRIO.js";
-import "./chunk-MWGVGUIS.js";
-import "./chunk-763GUIOU.js";
-import "./chunk-ONRU4L2N.js";
-import "./chunk-MDDAA2AO.js";
-import "./chunk-2PO5ZRKV.js";
+} from "./chunk-3SV6CQHO.js";
+import "./chunk-UEYA6UC7.js";
+import "./chunk-NBNN5GOB.js";
+import "./chunk-FEMOX5AD.js";
+import "./chunk-JL2PU6AI.js";
+import "./chunk-GZCUW5IC.js";
 import "./chunk-VEWZZM3H.js";
 import "./chunk-LK6SGL53.js";
-import "./chunk-XUHI52HK.js";
-import "./chunk-M5ZBBBJI.js";
-import "./chunk-OOSWAUYB.js";
+import "./chunk-EJI5XIBB.js";
+import "./chunk-44ICJRF3.js";
+import "./chunk-XZ2TIKGC.js";
 import "./chunk-Y27UJK6V.js";
+import "./chunk-ODWDQNRE.js";
 import "./chunk-UZB5KHKX.js";
 import "./chunk-MARWOCVP.js";
 import "./chunk-EEQLFRUM.js";
+import "./chunk-QDW3E4RD.js";
 import "./chunk-M62O4P4T.js";
-import "./chunk-KWBU5S5U.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   ExtractionEngine
 };

package/dist/fallback-llm.d.ts

@@ -16,6 +16,10 @@ interface FallbackLlmResponse {
         totalTokens?: number;
     };
 }
+interface FallbackLlmRuntimeContext {
+    agentDir?: string;
+    workspaceDir?: string;
+}
 /**
  * Generic fallback LLM client that uses the gateway's default AI configuration
  * and walks through the full fallback chain (primary + fallbacks).
@@ -23,7 +27,8 @@ interface FallbackLlmResponse {
  */
 declare class FallbackLlmClient {
     private gatewayConfig;
-    constructor(gatewayConfig?: GatewayConfig);
+    private runtimeContext;
+    constructor(gatewayConfig?: GatewayConfig, runtimeContext?: FallbackLlmRuntimeContext);
     /**
      * Check if fallback is available (gateway config has at least one model).
      */
@@ -105,10 +110,14 @@ declare class FallbackLlmClient {
      * Call OpenAI-compatible API.
      */
     private callOpenAI;
+    /**
+     * Call an OpenAI-compatible Responses API.
+     */
+    private callOpenAIResponses;
     /**
      * Call Anthropic Messages API.
      */
     private callAnthropic;
 }
 
-export { FallbackLlmClient, type FallbackLlmOptions, type FallbackLlmResponse };
+export { FallbackLlmClient, type FallbackLlmOptions, type FallbackLlmResponse, type FallbackLlmRuntimeContext };

package/dist/fallback-llm.js

@@ -1,12 +1,12 @@
 import {
   FallbackLlmClient
-} from "./chunk-XUHI52HK.js";
-import "./chunk-M5ZBBBJI.js";
-import "./chunk-OOSWAUYB.js";
+} from "./chunk-44ICJRF3.js";
+import "./chunk-XZ2TIKGC.js";
 import "./chunk-Y27UJK6V.js";
+import "./chunk-ODWDQNRE.js";
 import "./chunk-UZB5KHKX.js";
 import "./chunk-MARWOCVP.js";
-import "./chunk-KWBU5S5U.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   FallbackLlmClient
 };

package/dist/graph.js

@@ -10,7 +10,7 @@ import {
   graphsDir,
   readAllEdges,
   readEdges
-} from "./chunk-SCHEKPYH.js";
+} from "./chunk-C2EFFULQ.js";
 export {
   CAUSAL_PHRASES,
   GraphIndex,

package/dist/harmonic-retrieval.js

@@ -1,7 +1,8 @@
 import {
   searchHarmonicRetrieval
-} from "./chunk-AAI7JARD.js";
+} from "./chunk-HMDCOMYU.js";
 import "./chunk-C6QPK5GG.js";
+import "./chunk-PVGDJXVK.js";
 import "./chunk-NGAVDO7E.js";
 import "./chunk-DT5TVLJE.js";
 import "./chunk-DGXUHMOV.js";

package/dist/importance.d.ts

@@ -21,5 +21,15 @@ declare function rescoreMemoryImportance(memory: MemoryFile): ImportanceScore;
  * Get importance level from numeric score.
  */
 declare function importanceLevel(score: number): ImportanceLevel;
+/**
+ * Return true if `candidate` meets or exceeds `threshold`. Used by the
+ * extraction write gate in orchestrator.persistExtraction() to drop trivial
+ * content before it is written to the memory store.
+ *
+ * Note: callers should pass the ALREADY-BOOSTED level returned by
+ * scoreImportance(), because category boosts (e.g. corrections) are applied
+ * inside scoreImportance() before the level is derived.
+ */
+declare function isAboveImportanceThreshold(candidate: ImportanceLevel, threshold: ImportanceLevel): boolean;
 
-export { importanceLevel, rescoreMemoryImportance, scoreImportance };
+export { importanceLevel, isAboveImportanceThreshold, rescoreMemoryImportance, scoreImportance };

package/dist/importance.js

@@ -1,10 +1,12 @@
 import {
   importanceLevel,
+  isAboveImportanceThreshold,
   rescoreMemoryImportance,
   scoreImportance
-} from "./chunk-BDFZXRSO.js";
+} from "./chunk-J4IYOZZ5.js";
 export {
   importanceLevel,
+  isAboveImportanceThreshold,
   rescoreMemoryImportance,
   scoreImportance
 };