@remnic/core 1.0.3 → 1.1.1

package/dist/operator-toolkit.d.ts

@@ -1,7 +1,12 @@
+import { StorageManager } from './storage.js';
 import { EvalHarnessStatus, validateEvalBenchmarkPack, EvalBaselineDeltaReport, EvalCiGateReport } from './evals.js';
 import { GraphHealthReport } from './graph.js';
 import { SessionIntegrityReport, SessionRepairPlan, SessionRepairApplyResult } from './session-integrity.js';
 import { PluginConfig } from './types.js';
+import './page-versioning.js';
+import './consolidation-operator.js';
+import './memory-projection-store-DeSXPh1j.js';
+import 'better-sqlite3';
 
 interface QmdRuntimeLike {
     probe(): Promise<boolean>;
@@ -297,8 +302,42 @@ interface OperatorRepairOptions {
 declare function runOperatorSetup(options: OperatorSetupOptions): Promise<OperatorSetupReport>;
 declare function runOperatorConfigReview(options: OperatorConfigReviewOptions): Promise<OperatorConfigReviewReport>;
 declare function runOperatorDoctor(options: OperatorDoctorOptions): Promise<OperatorDoctorReport>;
+/**
+ * Count memories that pre-date the Memory Worth counters introduced in issue
+ * #560 — i.e., neither `mw_success` nor `mw_fail` is set on the frontmatter.
+ *
+ * Only memories whose category is eligible for Memory Worth (see
+ * `MEMORY_WORTH_ELIGIBLE_CATEGORIES`) are considered. Procedures, corrections,
+ * and other kinds that are not instrumented are excluded entirely — they're
+ * neither "legacy" nor "instrumented" for the purposes of this audit. The
+ * total in the returned details reflects only eligible memories.
+ *
+ * Returned as an `ok` check regardless of count, since legacy memories are
+ * fully functional (readers treat missing counters as zero observations). The
+ * numbers are informational for operators following the #560 rollout.
+ *
+ * Exported so unit tests can exercise the classification logic without
+ * booting a full orchestrator.
+ */
+declare function summarizeMemoryWorthLegacyCounters(storage: StorageManager): Promise<OperatorDoctorCheck>;
+/**
+ * Summarize the recent buffer-surprise telemetry distribution for the
+ * Doctor report (issue #563 PR 3).
+ *
+ * Reports mean/median/p90 surprise scores and the triggered-flush rate
+ * over the most recent window of ledger rows. An empty ledger is the
+ * expected state until `bufferSurpriseTriggerEnabled` is turned on — the
+ * check never escalates beyond `ok` / `warn` (ledger unreadable).
+ *
+ * Exported so tests can exercise the formatting without booting a real
+ * orchestrator.
+ */
+declare function summarizeBufferSurpriseDistribution(storage: StorageManager, config: PluginConfig): Promise<OperatorDoctorCheck>;
+declare function summarizeConsolidationProvenance(storage: StorageManager, config: Pick<PluginConfig, "memoryDir"> & {
+    versioningSidecarDir?: string;
+}): Promise<OperatorDoctorCheck>;
 declare function runOperatorInventory(options: OperatorInventoryOptions): Promise<OperatorInventoryReport>;
 declare function runBenchmarkRecall(options: BenchmarkRecallOptions): Promise<BenchmarkRecallReport>;
 declare function runOperatorRepair(options: OperatorRepairOptions): Promise<OperatorRepairReport>;
 
-export { type BenchmarkRecallOptions, type BenchmarkRecallReport, type OperatorConfigLoadResult, type OperatorConfigReviewFinding, type OperatorConfigReviewOptions, type OperatorConfigReviewReport, type OperatorDoctorCheck, type OperatorDoctorOptions, type OperatorDoctorReport, type OperatorInventoryNamespaceSummary, type OperatorInventoryOptions, type OperatorInventoryReport, type OperatorRepairOptions, type OperatorRepairReport, type OperatorSetupOptions, type OperatorSetupReport, type OperatorToolkitOrchestrator, runBenchmarkRecall, runOperatorConfigReview, runOperatorDoctor, runOperatorInventory, runOperatorRepair, runOperatorSetup };
+export { type BenchmarkRecallOptions, type BenchmarkRecallReport, type OperatorConfigLoadResult, type OperatorConfigReviewFinding, type OperatorConfigReviewOptions, type OperatorConfigReviewReport, type OperatorDoctorCheck, type OperatorDoctorOptions, type OperatorDoctorReport, type OperatorInventoryNamespaceSummary, type OperatorInventoryOptions, type OperatorInventoryReport, type OperatorRepairOptions, type OperatorRepairReport, type OperatorSetupOptions, type OperatorSetupReport, type OperatorToolkitOrchestrator, runBenchmarkRecall, runOperatorConfigReview, runOperatorDoctor, runOperatorInventory, runOperatorRepair, runOperatorSetup, summarizeBufferSurpriseDistribution, summarizeConsolidationProvenance, summarizeMemoryWorthLegacyCounters };

package/dist/operator-toolkit.js

@@ -4,42 +4,52 @@ import {
   runOperatorDoctor,
   runOperatorInventory,
   runOperatorRepair,
-  runOperatorSetup
-} from "./chunk-X4WESCKA.js";
-import "./chunk-HITJFT7E.js";
+  runOperatorSetup,
+  summarizeBufferSurpriseDistribution,
+  summarizeConsolidationProvenance,
+  summarizeMemoryWorthLegacyCounters
+} from "./chunk-B5WXLVDY.js";
+import "./chunk-ULYOGL6R.js";
+import "./chunk-ASAITVLA.js";
+import "./chunk-7I7FKFZH.js";
 import "./chunk-YRMVARQP.js";
+import "./chunk-YNQKWQT4.js";
 import "./chunk-U66YHYC7.js";
-import "./chunk-7PA4OZEU.js";
+import "./chunk-LK6SGL53.js";
 import "./chunk-7SEAZFFB.js";
 import "./chunk-K6WK37A6.js";
-import "./chunk-LK6SGL53.js";
-import "./chunk-OJFGVJS6.js";
+import "./chunk-BK2EFTE2.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-C2EFFULQ.js";
+import "./chunk-PVGDJXVK.js";
 import "./chunk-MARWOCVP.js";
-import "./chunk-POBPGDWI.js";
-import "./chunk-QNJMBKFK.js";
+import "./chunk-3OGMS3PE.js";
+import "./chunk-2LGMW3DJ.js";
 import "./chunk-TBBDFYXW.js";
-import "./chunk-LPSF4OQH.js";
-import "./chunk-POMSFKTB.js";
-import "./chunk-U2IQTSBY.js";
+import "./chunk-F5VP6YCB.js";
+import "./chunk-LTCGGW2D.js";
 import "./chunk-4KAN3GZ3.js";
-import "./chunk-6ZH4TU6I.js";
 import "./chunk-6PFRXT4K.js";
 import "./chunk-TP4FZJIZ.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-BOUYNNYD.js";
-import "./chunk-QSVPYQPG.js";
 import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
 import "./chunk-M62O4P4T.js";
 import "./chunk-4DJQYKMN.js";
+import "./chunk-X6GF3FX2.js";
+import "./chunk-FAAFWE4G.js";
 import "./chunk-2ODBA7MQ.js";
+import "./chunk-LPSF4OQH.js";
 export {
   runBenchmarkRecall,
   runOperatorConfigReview,
   runOperatorDoctor,
   runOperatorInventory,
   runOperatorRepair,
-  runOperatorSetup
+  runOperatorSetup,
+  summarizeBufferSurpriseDistribution,
+  summarizeConsolidationProvenance,
+  summarizeMemoryWorthLegacyCounters
 };
 //# sourceMappingURL=operator-toolkit.js.map

package/dist/{orchestrator-B9kwlCep.d.ts → orchestrator-CmJ-NTdJ.d.ts}

@@ -1,21 +1,91 @@
 import { SmartBuffer } from './buffer.js';
-import { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions } from './port-C1GZFv8h.js';
+import { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions } from './port-BADbLZU5.js';
 import { StorageManager } from './storage.js';
 import { TranscriptManager } from './transcript.js';
 import { HourlySummarizer } from './summarizer.js';
 import { LocalLlmClient } from './local-llm.js';
+import { FallbackLlmClient } from './fallback-llm.js';
 import { ModelRegistry } from './model-registry.js';
 import { RelevanceStore } from './relevance.js';
 import { NegativeExampleStore } from './negative.js';
 import { LastRecallStore, TierMigrationStatusStore, GraphRecallExpandedEntry, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallSnapshot } from './recall-state.js';
+import { RecallXraySnapshot } from './recall-xray.js';
 import { SessionObserverState } from './session-observer-state.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
-import { PluginConfig, QmdSearchResult, BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, ConsolidationObservation, MemoryFile, DaySummaryResult, MemoryActionEvent, RecallPlanMode, MemoryIntent, EntityTimelineEntry, ExtractionResult, MemoryFrontmatter, IdentityInjectionMode } from './types.js';
-import { S as SemanticConsolidationResult } from './semantic-consolidation-DrvSYRdB.js';
+import { PluginConfig, CodingContext, QmdSearchResult, BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, ConsolidationObservation, MemoryFile, DaySummaryResult, MemoryActionEvent, RecallPlanMode, MemoryIntent, EntityTimelineEntry, ExtractionResult, MemoryFrontmatter, IdentityInjectionMode } from './types.js';
+import { S as SemanticConsolidationResult } from './semantic-consolidation-CxJU6MJk.js';
 import { z } from 'zod';
 import { RuntimePolicyValues } from './policy-runtime.js';
 import { ProfilingCollector } from './profiling.js';
 
+/**
+ * @remnic/core — Write-time semantic dedup guard
+ *
+ * Complements the exact content-hash check in the orchestrator's write path
+ * by detecting near-duplicate candidate facts via embedding cosine similarity.
+ *
+ * The module intentionally has no dependency on the EmbeddingFallback or QMD
+ * classes directly — callers pass in a `lookup` function that returns the
+ * top-K nearest neighbors with their cosine scores. This keeps the decision
+ * logic pure and trivially testable with synthetic fixtures, and lets the
+ * orchestrator reuse whichever backend it already has wired up.
+ *
+ * Related issue: joshuaswarren/remnic#373
+ */
+/** A single nearest-neighbor hit from the embedding backend. */
+interface SemanticDedupHit {
+    /** Memory id of the existing neighbor. */
+    id: string;
+    /** Cosine similarity score in [0, 1]. */
+    score: number;
+    /** Optional source path, purely informational. */
+    path?: string;
+}
+/**
+ * Lookup function passed by the caller. Must return an array of hits sorted
+ * descending by score. Implementations should return an empty array (never
+ * throw) when the embedding backend is unavailable — the decision function
+ * treats that as "no near duplicate" (fail-open).
+ */
+type SemanticDedupLookup = (content: string, limit: number) => Promise<SemanticDedupHit[]>;
+interface SemanticDedupOptions {
+    /** Master switch. When false, `decideSemanticDedup` always returns `keep`. */
+    enabled: boolean;
+    /** Cosine similarity threshold (0-1). ≥ threshold ⇒ treat as duplicate. */
+    threshold: number;
+    /** How many nearest neighbors to compare against. */
+    candidates: number;
+}
+type SemanticDedupDecision = {
+    action: "keep";
+    reason: "disabled" | "backend_unavailable" | "no_candidates" | "no_near_duplicate";
+    topScore?: number;
+    topId?: string;
+} | {
+    action: "skip";
+    reason: "near_duplicate";
+    topScore: number;
+    topId: string;
+    topPath?: string;
+};
+/**
+ * Pure decision function: given a lookup callback and options, decide whether
+ * the candidate content should be written or skipped as a near-duplicate.
+ *
+ * Contract:
+ *   - When `options.enabled` is false → always keep, reason="disabled".
+ *   - When the lookup throws (provider down / network error) → keep,
+ *     reason="backend_unavailable". Fail-open: a lookup failure must not block
+ *     writes.
+ *   - When the lookup succeeds but returns 0 hits (empty index or no
+ *     neighbors above the score floor) → keep, reason="no_candidates".
+ *     This is distinct from backend_unavailable so telemetry dashboards can
+ *     correctly distinguish "provider is down" from "index is empty".
+ *   - When the top hit's score ≥ threshold → skip with reason="near_duplicate".
+ *   - Otherwise → keep with reason="no_near_duplicate".
+ */
+declare function decideSemanticDedup(content: string, lookup: SemanticDedupLookup, options: SemanticDedupOptions): Promise<SemanticDedupDecision>;
+
 type ReplaySource = "openclaw" | "claude" | "chatgpt";
 type ReplayRole = "user" | "assistant";
 interface ReplayTurn {
@@ -239,12 +309,12 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     agent: string;
     date: string;
     reason: string;
-    confidence?: number | undefined;
+    workflow?: string | undefined;
     tags?: string[] | undefined;
+    confidence?: number | undefined;
     severity?: "low" | "medium" | "high" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
-    workflow?: string | undefined;
     learning?: string | undefined;
     evidenceWindowStart?: string | undefined;
     evidenceWindowEnd?: string | undefined;
@@ -253,12 +323,12 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     agent: string;
     date: string;
     reason: string;
-    confidence?: number | undefined;
+    workflow?: string | undefined;
     tags?: string[] | undefined;
+    confidence?: number | undefined;
     severity?: "low" | "medium" | "high" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
-    workflow?: string | undefined;
     learning?: string | undefined;
     evidenceWindowStart?: string | undefined;
     evidenceWindowEnd?: string | undefined;
@@ -635,6 +705,35 @@ interface RecallInvocationOptions {
     topK?: number;
     mode?: RecallPlanMode;
     abortSignal?: AbortSignal;
+    /**
+     * Capture a `RecallXraySnapshot` for this recall (issue #570).  When
+     * `true`, the orchestrator builds a snapshot from the data it has
+     * already gathered and stashes it in memory, accessible via
+     * `getLastXraySnapshot()`.  When `false` or absent, nothing is
+     * captured and recall behavior is unchanged (schema-only slice).
+     */
+    xrayCapture?: boolean;
+    /**
+     * Per-invocation override for `recallBudgetChars` (issue #570 PR 3/4).
+     * Flows through `getRecallBudgetChars()` for this recall only — no
+     * shared config mutation, so concurrent recalls on the same
+     * orchestrator are not affected (CLAUDE.md rule 47: no shared
+     * mutable state across async boundaries).  Must be a non-negative
+     * finite integer; non-conforming values are ignored and the
+     * configured budget is used.
+     */
+    budgetCharsOverride?: number;
+    /**
+     * Per-invocation principal override (issue #570 PR 4).  When set,
+     * the orchestrator uses this principal for ACL / namespace checks
+     * instead of `resolvePrincipal(sessionKey, config)`.  This is the
+     * escape hatch for access surfaces (HTTP / MCP) that have already
+     * authenticated the caller upstream — threading an unmapped
+     * principal through the session-key-based resolver would otherwise
+     * collapse it to `"default"` and produce false denials in
+     * namespace-enabled deployments (CLAUDE.md rule 42).
+     */
+    principalOverride?: string;
 }
 /** Default workspace directory when no per-agent or config workspace is available. */
 declare function defaultWorkspaceDir(): string;
@@ -751,12 +850,37 @@ declare class Orchestrator {
     readonly localLlm: LocalLlmClient;
     readonly fastLlm: LocalLlmClient;
     private readonly judgeVerdictCache;
-    private readonly fastGatewayLlm;
+    /**
+     * Per-orchestrator defer-counter map (issue #562, PR 2). Tracks how many
+     * times the judge has returned `"defer"` for a given candidate content
+     * hash so the defer cap can be enforced.
+     */
+    private readonly judgeDeferCounts;
+    /**
+     * Side-channel: number of facts deferred in the most recent
+     * `persistExtraction` call (issue #562, PR 2). The caller reads this after
+     * `persistExtraction` returns to decide whether to retain buffer turns for
+     * the next extraction pass. Not part of the return signature because many
+     * callers already destructure `persistedIds` by position.
+     */
+    private lastPersistExtractionDeferredCount;
+    private readonly _fastGatewayLlm;
+    get fastGatewayLlm(): FallbackLlmClient | null;
     readonly modelRegistry: ModelRegistry;
     readonly relevance: RelevanceStore;
     readonly negatives: NegativeExampleStore;
     readonly lastRecall: LastRecallStore;
     readonly tierMigrationStatus: TierMigrationStatusStore;
+    /**
+     * In-memory X-ray snapshot from the most recent `recall()` call that
+     * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
+     * per-process; later slices add CLI/HTTP/MCP surfaces that consume
+     * this via the shared renderer.  `null` until the first capture, and
+     * NEVER overwritten by a recall that did not request capture —
+     * requests without the flag leave prior captures intact so the
+     * capturing caller can still read their snapshot back.
+     */
+    private lastXraySnapshot;
     readonly embeddingFallback: EmbeddingFallback;
     private readonly conversationIndexDir;
     private readonly extraction;
@@ -772,6 +896,16 @@ declare class Orchestrator {
     /** Lossless Context Management engine — proactive session archive + DAG summarization. */
     readonly lcmEngine: LcmEngine | null;
     private readonly rerankCache;
+    /**
+     * Short-TTL cache for Memory Worth counter lookups so interactive recall
+     * doesn't trigger a full `readAllMemories` scan per query. Keyed by
+     * namespace; the filter unions across namespaces at query time. The TTL
+     * is intentionally short (seconds, not minutes) because counters are
+     * mutated by `recordMemoryOutcome` asynchronously and we'd rather serve
+     * a 30-second-stale worth score than a stable-but-wrong one.
+     */
+    private readonly memoryWorthCounterCache;
+    private static readonly MEMORY_WORTH_CACHE_TTL_MS;
     /**
      * Per-session workspace overrides keyed by sessionKey.
      * Set by the before_agent_start hook so recall() uses the correct
@@ -779,6 +913,14 @@ declare class Orchestrator {
      * Using a Map prevents concurrent sessions from overwriting each other.
      */
     private _recallWorkspaceOverrides;
+    /**
+     * Per-session coding-agent context (issue #569). Populated by connectors at
+     * session-start (PRs 5/6/7) via `setCodingContextForSession`. Used by both
+     * the recall path and the write path so that memory routing respects the
+     * project/branch scope a session is operating in (rule 42 — read + write
+     * through the same namespace layer).
+     */
+    private readonly _codingContextBySession;
     private routingRulesStore;
     private contentHashIndex;
     private readonly artifactSourceStatusCache;
@@ -808,6 +950,7 @@ declare class Orchestrator {
     private runtimePolicyValues;
     private utilityRuntimeValues;
     private evalShadowWriteChain;
+    private directAnswerObservationChain;
     private initPromise;
     private resolveInit;
     /**
@@ -840,12 +983,76 @@ declare class Orchestrator {
      * promptly on shutdown. Safe to call multiple times or before init.
      */
     abortDeferredInit(): void;
+    private disposeSearchBackendIfNeeded;
     /** Set per-session workspace for the next recall() call (compaction reset). @internal */
     setRecallWorkspaceOverride(sessionKey: string, dir: string): void;
     /** Remove a per-session workspace override (cleanup on error or early return). @internal */
     clearRecallWorkspaceOverride(sessionKey: string): void;
     resolvePrincipal(sessionKey?: string): string;
     resolveSelfNamespace(sessionKey?: string): string;
+    /**
+     * Attach a coding-agent context to a session (issue #569). Called by the
+     * Claude Code / Codex / Cursor connectors at session start after
+     * `resolveGitContext(cwd)`. The context is consulted by the recall path
+     * and the write path so that memories route to a project- (and optionally
+     * branch-) scoped namespace.
+     *
+     * Pass `null` to clear.
+     */
+    setCodingContextForSession(sessionKey: string, codingContext: CodingContext | null): void;
+    /**
+     * Read-only accessor for the coding context attached to a session. Returns
+     * `null` when none is set. Used by `remnic doctor` and by tests.
+     *
+     * Defensive `_codingContextBySession` lookup — legacy orchestrator-flush
+     * tests use `Object.create(Orchestrator.prototype)` which does not run
+     * class-field initializers, so the Map may be undefined on stubs.
+     */
+    getCodingContextForSession(sessionKey: string | undefined): CodingContext | null;
+    /**
+     * Shared helper used by both the recall path and the write path (rule 42).
+     *
+     * Given a base namespace computed from the principal, returns the overlaid
+     * coding namespace when the session has a coding context AND
+     * `codingMode.projectScope` is true AND `namespacesEnabled` is true.
+     * Otherwise returns `baseNamespace` unchanged — CLAUDE.md #30 escape hatch.
+     *
+     * Principal isolation (CLAUDE.md rule 42): the overlay is COMBINED with
+     * the principal-derived `baseNamespace` rather than replacing it, so two
+     * principals working in the same repository do not share memories through
+     * a common `project-*` namespace.
+     *
+     * Namespaces-disabled gate: when `namespacesEnabled` is false, the
+     * storage router maps every namespace to the same `memoryDir`. Returning
+     * `project-*` in that mode would create apparent route separation with
+     * no actual storage isolation — a false-isolation trap. In that mode we
+     * return `baseNamespace` unchanged so coding mode degrades to the existing
+     * unscoped behavior.
+     *
+     * @internal
+     */
+    applyCodingNamespaceOverlay(sessionKey: string | undefined, baseNamespace: string): string;
+    /**
+     * Read-side overlay: returns the list of namespaces a session should read
+     * from, including any read fallbacks (branch → project asymmetry lands in
+     * PR 3; PR 2 returns an empty fallbacks list).
+     *
+     * Returns `null` when:
+     *   - `namespacesEnabled` is false (overlay would create false isolation)
+     *   - no context attached to the session
+     *   - `codingMode.projectScope` is false (CLAUDE.md #30 escape hatch)
+     *
+     * The returned `namespace` / `readFallbacks` are RAW overlay fragments
+     * (e.g. `project-origin-ab12`). Callers MUST combine them with the
+     * principal-derived base through `combineNamespaces()` before passing to
+     * storage, so principal isolation is preserved (rule 42).
+     *
+     * @internal
+     */
+    applyCodingRecallOverlay(sessionKey: string | undefined): {
+        namespace: string;
+        readFallbacks: string[];
+    } | null;
     getStorageForNamespace(namespace?: string): Promise<StorageManager>;
     private configuredNamespaces;
     private buildConfiguredQmdSearchOptions;
@@ -917,6 +1124,7 @@ declare class Orchestrator {
     private autoRegisterDaySummaryCron;
     private autoRegisterNightlyGovernanceCron;
     private autoRegisterProceduralMiningCron;
+    private autoRegisterContradictionScanCron;
     applyBehaviorRuntimePolicy(state: BehaviorLoopPolicyState): Promise<{
         applied: boolean;
         rolledBack: boolean;
@@ -1041,6 +1249,23 @@ declare class Orchestrator {
      */
     private validateLocalLlmModel;
     recall(prompt: string, sessionKey?: string, options?: RecallInvocationOptions): Promise<string>;
+    /**
+     * Return the most recent X-ray snapshot captured during a
+     * `recall()` call that passed `xrayCapture: true` (issue #570 PR 1).
+     * Returns `null` when no such capture has occurred on this
+     * orchestrator instance.  Returned snapshot is a deep copy so
+     * caller mutation cannot tear the stored value.
+     */
+    getLastXraySnapshot(): RecallXraySnapshot | null;
+    /** Clear the captured X-ray snapshot.  Exposed for tests / explicit reset. */
+    clearLastXraySnapshot(): void;
+    /**
+     * Await the in-flight observation-mode direct-answer annotation chain.
+     * Resolves to true when settled, false on timeout.
+     */
+    waitForDirectAnswerObservationIdle(timeoutMs?: number): Promise<boolean>;
+    private enqueueDirectAnswerObservation;
+    private annotateDirectAnswerTier;
     private logRecallFailure;
     private artifactTypeForCategory;
     private truncateArtifactForRecall;
@@ -1153,6 +1378,24 @@ declare class Orchestrator {
      * Called automatically when items are queued.
      */
     private processQueue;
+    /**
+     * Classify + log a failure from either the per-task catch inside
+     * `processQueue()` or the outer `processQueue().catch(...)` in
+     * `queueBufferedExtraction()`.  Issue #549: `throwIfRecallAborted`
+     * (used throughout `runExtraction`) raises an Error whose `name` is
+     * `"AbortError"`.  That path fires when `before_reset` aborts a
+     * queued task to avoid duplicate extraction — it is intentional
+     * cancellation, not a failure.  Downgrading the log to debug
+     * prevents spurious `error`-level lines that routinely appear
+     * right next to a successful `persisted: N facts, M entities` log
+     * and that confuse operators into thinking extraction is broken.
+     * Genuine extraction failures (network, parse, I/O) still log at
+     * `error`.
+     *
+     * Source differentiates the two call sites so the log message
+     * names the right layer (`task` vs `processor`).
+     */
+    private logExtractionQueueFailure;
     private runExtraction;
     private recordProcessedExtractionFingerprint;
     private runTierMigrationCycle;
@@ -1259,6 +1502,7 @@ declare class Orchestrator {
      *
      * Callers must pass the full candidate pool (post-rerank, pre-slice).
      */
+    private applyMemoryWorthRerank;
     private diversifyAndLimitRecallResults;
     /**
      * Apply Maximal Marginal Relevance to a section's ordered candidate list.
@@ -1286,7 +1530,7 @@ declare class Orchestrator {
      * path prefix (and, for the legacy default-namespace layout at
      * `memoryDir` root, an exclusion list for `namespaces/*`).
      */
-    private semanticDedupLookup;
+    semanticDedupLookup(content: string, limit: number, targetStorage: StorageManager): Promise<SemanticDedupHit[]>;
     /**
      * Resolve the namespace-scoped filter to pass into
      * `EmbeddingFallback.search()` for semantic dedup. Returns an empty
@@ -1346,4 +1590,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-export { deriveTopicsFromExtraction as A, type BulkImportSource as B, type CompoundingPromotionReport as C, filterRecallCandidates as D, formatCompressionGuidelinesForRecall as E, graphPathRelativeToStorage as F, type GraphRecallSnapshot as G, hasIdentityRecoveryIntent as H, type IntentDebugSnapshot as I, isArtifactMemoryPath as J, lifecycleRecallScoreAdjustment as K, mergeArtifactRecallCandidates as L, mergeGraphExpandedResults as M, resolveEffectiveIdentityInjectionMode as N, Orchestrator as O, resolveEffectiveRecallMode as P, type QmdRecallSnapshot as Q, type ReplaySource as R, resolvePersistedMemoryRelativePath as S, resolveRecallModeDecision as T, resolveRecentThreadMemoryPaths as U, shouldFilterLifecycleRecallCandidate as V, summarizeGraphShadowComparison as W, type ReplayWarning as a, type ImportTurn as b, type BulkImportOptions as c, type BulkImportResult as d, type ReplayTurn as e, type BulkImportSourceAdapter as f, type BulkImportError as g, type ImportSourceRole as h, type ImportTurnValidationIssue as i, defaultWorkspaceDir as j, isImportRole as k, type GraphRecallRankedResult as l, type GraphRecallShadowComparison as m, type RecallInvocationOptions as n, type RecallModeDecision as o, parseIsoTimestamp as p, appendMemoryToGraphContext as q, blendGraphExpandedRecallScore as r, sanitizeSessionKeyForFilename as s, buildCompressionGuidelinesMarkdown as t, buildMemoryPathById as u, validateImportTurn as v, computeArtifactCandidateFetchLimit as w, computeArtifactRecallLimit as x, computeQmdHybridFetchLimit as y, dedupeEntitySynthesisEvidenceEntries as z };
+export { summarizeGraphShadowComparison as $, computeArtifactCandidateFetchLimit as A, type BulkImportSource as B, type CompoundingPromotionReport as C, computeArtifactRecallLimit as D, computeQmdHybridFetchLimit as E, dedupeEntitySynthesisEvidenceEntries as F, type GraphRecallSnapshot as G, deriveTopicsFromExtraction as H, type IntentDebugSnapshot as I, filterRecallCandidates as J, formatCompressionGuidelinesForRecall as K, graphPathRelativeToStorage as L, hasIdentityRecoveryIntent as M, isArtifactMemoryPath as N, Orchestrator as O, lifecycleRecallScoreAdjustment as P, type QmdRecallSnapshot as Q, type ReplaySource as R, type SemanticDedupLookup as S, mergeArtifactRecallCandidates as T, mergeGraphExpandedResults as U, resolveEffectiveIdentityInjectionMode as V, resolveEffectiveRecallMode as W, resolvePersistedMemoryRelativePath as X, resolveRecallModeDecision as Y, resolveRecentThreadMemoryPaths as Z, shouldFilterLifecycleRecallCandidate as _, type ReplayWarning as a, type ImportTurn as b, type BulkImportOptions as c, type BulkImportResult as d, type ReplayTurn as e, type BulkImportSourceAdapter as f, type BulkImportError as g, type ImportSourceRole as h, type ImportTurnValidationIssue as i, type SemanticDedupDecision as j, type SemanticDedupHit as k, type SemanticDedupOptions as l, decideSemanticDedup as m, defaultWorkspaceDir as n, isImportRole as o, parseIsoTimestamp as p, type GraphRecallRankedResult as q, type GraphRecallShadowComparison as r, sanitizeSessionKeyForFilename as s, type RecallInvocationOptions as t, type RecallModeDecision as u, validateImportTurn as v, appendMemoryToGraphContext as w, blendGraphExpandedRecallScore as x, buildCompressionGuidelinesMarkdown as y, buildMemoryPathById as z };

package/dist/orchestrator.d.ts

@@ -1,21 +1,24 @@
 import './buffer.js';
-import './port-C1GZFv8h.js';
+import './port-BADbLZU5.js';
 import './storage.js';
 import './transcript.js';
 import './summarizer.js';
 import './local-llm.js';
+import './fallback-llm.js';
 import './model-registry.js';
 import './relevance.js';
 import './negative.js';
 import './recall-state.js';
+import './recall-xray.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
-export { l as GraphRecallRankedResult, m as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, n as RecallInvocationOptions, o as RecallModeDecision, q as appendMemoryToGraphContext, r as blendGraphExpandedRecallScore, t as buildCompressionGuidelinesMarkdown, u as buildMemoryPathById, w as computeArtifactCandidateFetchLimit, x as computeArtifactRecallLimit, y as computeQmdHybridFetchLimit, z as dedupeEntitySynthesisEvidenceEntries, j as defaultWorkspaceDir, A as deriveTopicsFromExtraction, D as filterRecallCandidates, E as formatCompressionGuidelinesForRecall, F as graphPathRelativeToStorage, H as hasIdentityRecoveryIntent, J as isArtifactMemoryPath, K as lifecycleRecallScoreAdjustment, L as mergeArtifactRecallCandidates, M as mergeGraphExpandedResults, N as resolveEffectiveIdentityInjectionMode, P as resolveEffectiveRecallMode, S as resolvePersistedMemoryRelativePath, T as resolveRecallModeDecision, U as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, V as shouldFilterLifecycleRecallCandidate, W as summarizeGraphShadowComparison } from './orchestrator-B9kwlCep.js';
+export { q as GraphRecallRankedResult, r as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, t as RecallInvocationOptions, u as RecallModeDecision, w as appendMemoryToGraphContext, x as blendGraphExpandedRecallScore, y as buildCompressionGuidelinesMarkdown, z as buildMemoryPathById, A as computeArtifactCandidateFetchLimit, D as computeArtifactRecallLimit, E as computeQmdHybridFetchLimit, F as dedupeEntitySynthesisEvidenceEntries, n as defaultWorkspaceDir, H as deriveTopicsFromExtraction, J as filterRecallCandidates, K as formatCompressionGuidelinesForRecall, L as graphPathRelativeToStorage, M as hasIdentityRecoveryIntent, N as isArtifactMemoryPath, P as lifecycleRecallScoreAdjustment, T as mergeArtifactRecallCandidates, U as mergeGraphExpandedResults, V as resolveEffectiveIdentityInjectionMode, W as resolveEffectiveRecallMode, X as resolvePersistedMemoryRelativePath, Y as resolveRecallModeDecision, Z as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, _ as shouldFilterLifecycleRecallCandidate, $ as summarizeGraphShadowComparison } from './orchestrator-CmJ-NTdJ.js';
 import './types.js';
-import './semantic-consolidation-DrvSYRdB.js';
+import './semantic-consolidation-CxJU6MJk.js';
 import './policy-runtime.js';
 import './profiling.js';
 import './page-versioning.js';
+import './consolidation-operator.js';
 import './memory-projection-store-DeSXPh1j.js';
 import 'better-sqlite3';
 import './session-integrity.js';