@remnic/core 1.0.2 → 1.1.0

package/dist/intent.d.ts

@@ -1,8 +1,9 @@
 import { MemoryIntent, RecallPlanMode } from './types.js';
 
 declare function inferIntentFromText(text: string): MemoryIntent;
+declare function isTaskInitiationIntent(intent: MemoryIntent): boolean;
 declare function intentCompatibilityScore(queryIntent: MemoryIntent, memoryIntent: MemoryIntent): number;
 declare function planRecallMode(prompt: string): RecallPlanMode;
 declare function hasBroadGraphIntent(prompt: string): boolean;
 
-export { hasBroadGraphIntent, inferIntentFromText, intentCompatibilityScore, planRecallMode };
+export { hasBroadGraphIntent, inferIntentFromText, intentCompatibilityScore, isTaskInitiationIntent, planRecallMode };

package/dist/intent.js

@@ -2,12 +2,14 @@ import {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
+  isTaskInitiationIntent,
   planRecallMode
-} from "./chunk-WWIQTB2Y.js";
+} from "./chunk-GGD5W7TB.js";
 export {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
+  isTaskInitiationIntent,
   planRecallMode
 };
 //# sourceMappingURL=intent.js.map

package/dist/lifecycle.js

@@ -7,7 +7,7 @@ import {
   daysSince,
   decideLifecycleTransition,
   resolveLifecycleState
-} from "./chunk-QCCCQT3O.js";
+} from "./chunk-TBBDFYXW.js";
 export {
   clamp01,
   clampLifecycleThreshold,

package/dist/local-llm.d.ts

@@ -52,9 +52,16 @@ declare class LocalLlmClient {
     private static readonly LMS_CACHE_INTERVAL_MS;
     constructor(config: PluginConfig, modelRegistry?: ModelRegistry);
     /**
-     * Disable thinking/reasoning mode for models that support it (e.g. Qwen 3.5).
-     * When enabled, adds chat_template_kwargs to suppress chain-of-thought,
-     * reducing latency for fast-tier operations.
+     * Request thinking/reasoning suppression on the next chat completion.
+     *
+     * When `true`, the client will inject
+     * `chat_template_kwargs: { enable_thinking: false }` into the request
+     * body — **but only when the detected backend is known to support it**
+     * (LM Studio, vLLM; see `THINKING_COMPATIBLE_BACKENDS`).  Strict
+     * OpenAI-compat backends reject unknown fields with 400; on those the
+     * client fails open (thinking runs normally).  This is the safe
+     * default for Remnic extraction / consolidation: measurable latency
+     * win on thinking-capable backends, zero risk on others.  Issue #548.
      */
     set disableThinking(value: boolean);
     private resolveHomeDir;

package/dist/local-llm.js

@@ -1,9 +1,9 @@
 import {
   LocalLlmClient
-} from "./chunk-MDDAA2AO.js";
+} from "./chunk-JL2PU6AI.js";
 import "./chunk-LK6SGL53.js";
 import "./chunk-MARWOCVP.js";
-import "./chunk-KWBU5S5U.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   LocalLlmClient
 };

package/dist/logger.d.ts

@@ -4,7 +4,7 @@ interface LoggerBackend {
     error(msg: string, ...args: unknown[]): void;
     debug?(msg: string, ...args: unknown[]): void;
 }
-declare function initLogger(backend: LoggerBackend, debug: boolean): void;
+declare function initLogger(backend?: LoggerBackend, debug?: boolean): void;
 declare const log: {
     info(msg: string, ...args: unknown[]): void;
     warn(msg: string, ...args: unknown[]): void;

package/dist/logger.js

@@ -1,7 +1,7 @@
 import {
   initLogger,
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 export {
   initLogger,
   log

package/dist/memory-cache.d.ts

@@ -6,8 +6,8 @@ declare function updateCacheOnWrite(baseDir: string, memory: MemoryFile): void;
 declare function updateCacheOnDelete(baseDir: string, filePath: string): void;
 declare function getCachedArchivedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null;
 declare function setCachedArchivedMemories(baseDir: string, memories: MemoryFile[], version: number): void;
-declare function getCachedEntities(baseDir: string, currentVersion: number): EntityFile[] | null;
-declare function setCachedEntities(baseDir: string, entities: EntityFile[], version: number): void;
+declare function getCachedEntities(baseDir: string, currentVersion: number, schemaKey?: string): EntityFile[] | null;
+declare function setCachedEntities(baseDir: string, entities: EntityFile[], version: number, schemaKey?: string): void;
 /** Get a pre-filtered Map of episode memories (keyed by ID). Derived from hot cache. */
 declare function getCachedEpisodeMap(baseDir: string, currentVersion: number): Map<string, MemoryFile> | null;
 /** Build and cache the episode memory map from the full memory list. */

package/dist/memory-cache.js

@@ -15,7 +15,7 @@ import {
   setCachedRuleMemories,
   updateCacheOnDelete,
   updateCacheOnWrite
-} from "./chunk-ESSMF2FR.js";
+} from "./chunk-6PFRXT4K.js";
 export {
   clearMemoryCache,
   getCachedArchivedMemories,

package/dist/{memory-projection-store-NxMkbocT.d.ts → memory-projection-store-DeSXPh1j.d.ts}

@@ -218,4 +218,4 @@ declare function readProjectedGovernanceRecord(memoryDir: string): {
     report: string;
 } | null;
 
-export { readProjectedMemoryState as A, readProjectedMemoryTimeline as B, readProjectedNativeKnowledgeChunks as C, type MemoryGovernanceRunResult as M, type ProjectedMemoryBrowseOptions as P, type RestoreMemoryGovernanceRunResult as R, type MemoryGovernanceSummary as a, type MemoryGovernanceMetrics as b, type MemoryGovernanceQualityScore as c, type MemoryGovernanceReviewQueueEntry as d, type MemoryGovernanceAppliedAction as e, type MemoryGovernanceTransitionReport as f, type MemoryGovernanceManifest as g, type MemoryGovernanceRestoreManifest as h, type ProjectedMemoryBrowsePage as i, readProjectedGovernanceRecord as j, MEMORY_PROJECTION_SCHEMA_VERSION as k, type MemoryProjectionGovernanceAppliedActionRow as l, type MemoryProjectionGovernanceReviewQueueRow as m, type ProjectedEntityMentionRow as n, type ProjectedMemoryBrowseRow as o, type ProjectedNativeKnowledgeChunkRow as p, type ProjectedReviewQueueSnapshot as q, readMemoryGovernanceRunArtifact as r, getMemoryProjectionPath as s, initializeMemoryProjectionDb as t, memoryCurrentSelectExpressions as u, parseCurrentRow as v, parseTimelineRows as w, readProjectedEntityMentions as x, readProjectedLatestReviewQueue as y, readProjectedMemoryBrowse as z };
+export { readProjectedMemoryState as A, readProjectedMemoryTimeline as B, readProjectedNativeKnowledgeChunks as C, type MemoryGovernanceRunResult as M, type ProjectedMemoryBrowseOptions as P, type RestoreMemoryGovernanceRunResult as R, type ProjectedMemoryBrowsePage as a, readProjectedGovernanceRecord as b, type MemoryGovernanceSummary as c, type MemoryGovernanceMetrics as d, type MemoryGovernanceQualityScore as e, type MemoryGovernanceReviewQueueEntry as f, type MemoryGovernanceAppliedAction as g, type MemoryGovernanceTransitionReport as h, type MemoryGovernanceManifest as i, type MemoryGovernanceRestoreManifest as j, MEMORY_PROJECTION_SCHEMA_VERSION as k, type MemoryProjectionGovernanceAppliedActionRow as l, type MemoryProjectionGovernanceReviewQueueRow as m, type ProjectedEntityMentionRow as n, type ProjectedMemoryBrowseRow as o, type ProjectedNativeKnowledgeChunkRow as p, type ProjectedReviewQueueSnapshot as q, readMemoryGovernanceRunArtifact as r, getMemoryProjectionPath as s, initializeMemoryProjectionDb as t, memoryCurrentSelectExpressions as u, parseCurrentRow as v, parseTimelineRows as w, readProjectedEntityMentions as x, readProjectedLatestReviewQueue as y, readProjectedMemoryBrowse as z };

package/dist/memory-projection-store.d.ts

@@ -1,3 +1,3 @@
-export { k as MEMORY_PROJECTION_SCHEMA_VERSION, l as MemoryProjectionGovernanceAppliedActionRow, m as MemoryProjectionGovernanceReviewQueueRow, n as ProjectedEntityMentionRow, P as ProjectedMemoryBrowseOptions, i as ProjectedMemoryBrowsePage, o as ProjectedMemoryBrowseRow, p as ProjectedNativeKnowledgeChunkRow, q as ProjectedReviewQueueSnapshot, s as getMemoryProjectionPath, t as initializeMemoryProjectionDb, u as memoryCurrentSelectExpressions, v as parseCurrentRow, w as parseTimelineRows, x as readProjectedEntityMentions, j as readProjectedGovernanceRecord, y as readProjectedLatestReviewQueue, z as readProjectedMemoryBrowse, A as readProjectedMemoryState, B as readProjectedMemoryTimeline, C as readProjectedNativeKnowledgeChunks } from './memory-projection-store-NxMkbocT.js';
+export { k as MEMORY_PROJECTION_SCHEMA_VERSION, l as MemoryProjectionGovernanceAppliedActionRow, m as MemoryProjectionGovernanceReviewQueueRow, n as ProjectedEntityMentionRow, P as ProjectedMemoryBrowseOptions, a as ProjectedMemoryBrowsePage, o as ProjectedMemoryBrowseRow, p as ProjectedNativeKnowledgeChunkRow, q as ProjectedReviewQueueSnapshot, s as getMemoryProjectionPath, t as initializeMemoryProjectionDb, u as memoryCurrentSelectExpressions, v as parseCurrentRow, w as parseTimelineRows, x as readProjectedEntityMentions, b as readProjectedGovernanceRecord, y as readProjectedLatestReviewQueue, z as readProjectedMemoryBrowse, A as readProjectedMemoryState, B as readProjectedMemoryTimeline, C as readProjectedNativeKnowledgeChunks } from './memory-projection-store-DeSXPh1j.js';
 import './types.js';
 import 'better-sqlite3';

package/dist/model-registry.js

@@ -1,7 +1,7 @@
 import {
   ModelRegistry
-} from "./chunk-ONRU4L2N.js";
-import "./chunk-KWBU5S5U.js";
+} from "./chunk-FEMOX5AD.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   ModelRegistry
 };

package/dist/models-json.js

@@ -2,8 +2,8 @@ import {
   __setModelsJsonForTest,
   clearModelsJsonCache,
   loadModelsJsonProviders
-} from "./chunk-OOSWAUYB.js";
-import "./chunk-KWBU5S5U.js";
+} from "./chunk-ODWDQNRE.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   __setModelsJsonForTest,
   clearModelsJsonCache,

package/dist/native-knowledge.js

@@ -9,8 +9,8 @@ import {
   syncCuratedIncludeFiles,
   syncObsidianVaults,
   syncOpenClawWorkspaceArtifacts
-} from "./chunk-Q6FETXJA.js";
-import "./chunk-KWBU5S5U.js";
+} from "./chunk-7SEAZFFB.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,

package/dist/negative.js

@@ -1,7 +1,7 @@
 import {
   NegativeExampleStore
-} from "./chunk-GJR6D6KC.js";
-import "./chunk-KWBU5S5U.js";
+} from "./chunk-D654IBA6.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   NegativeExampleStore
 };

package/dist/operator-toolkit.js

@@ -5,31 +5,36 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-QDOSNLB4.js";
-import "./chunk-IZME7KW2.js";
+} from "./chunk-3QHL5ABG.js";
+import "./chunk-ZVBB3T7V.js";
 import "./chunk-YRMVARQP.js";
-import "./chunk-TVVVQQAK.js";
+import "./chunk-BLKTA7MM.js";
+import "./chunk-U66YHYC7.js";
 import "./chunk-LK6SGL53.js";
-import "./chunk-Q6FETXJA.js";
+import "./chunk-7SEAZFFB.js";
 import "./chunk-K6WK37A6.js";
-import "./chunk-SCHEKPYH.js";
-import "./chunk-ISY75RLM.js";
+import "./chunk-MBJHSA7F.js";
 import "./chunk-Z5LAYHGJ.js";
+import "./chunk-C2EFFULQ.js";
+import "./chunk-PVGDJXVK.js";
 import "./chunk-MARWOCVP.js";
-import "./chunk-J3BT33K7.js";
-import "./chunk-QWUUMMIK.js";
-import "./chunk-U4PV25RD.js";
-import "./chunk-ESSMF2FR.js";
-import "./chunk-TP4FZJIZ.js";
+import "./chunk-ITRLGI2T.js";
+import "./chunk-QNJMBKFK.js";
+import "./chunk-TBBDFYXW.js";
+import "./chunk-LPSF4OQH.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-HLXVTBF3.js";
 import "./chunk-M62O4P4T.js";
-import "./chunk-KWBU5S5U.js";
-import "./chunk-LPSF4OQH.js";
-import "./chunk-QCCCQT3O.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-2ODBA7MQ.js";
 export {
   runBenchmarkRecall,
   runOperatorConfigReview,

package/dist/{orchestrator-zTa-Qo-1.d.ts → orchestrator-DRYA6_lW.d.ts}

@@ -10,8 +10,8 @@ import { NegativeExampleStore } from './negative.js';
 import { LastRecallStore, TierMigrationStatusStore, GraphRecallExpandedEntry, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallSnapshot } from './recall-state.js';
 import { SessionObserverState } from './session-observer-state.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
-import { PluginConfig, QmdSearchResult, BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, MemoryFile, DaySummaryResult, MemoryActionEvent, RecallPlanMode, MemoryIntent, ExtractionResult, MemoryFrontmatter, IdentityInjectionMode } from './types.js';
-import { SemanticConsolidationResult } from './semantic-consolidation.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 { z } from 'zod';
 import { RuntimePolicyValues } from './policy-runtime.js';
 import { ProfilingCollector } from './profiling.js';
@@ -33,6 +33,74 @@ interface ReplayWarning {
     index?: number;
 }
 
+interface BulkImportSource {
+    turns: ImportTurn[];
+    metadata: {
+        source: string;
+        exportDate: string;
+        messageCount: number;
+        dateRange: {
+            from: string;
+            to: string;
+        };
+    };
+}
+interface ImportTurn {
+    role: "user" | "assistant" | "other";
+    content: string;
+    timestamp: string;
+    participantId?: string;
+    participantName?: string;
+    replyToId?: string;
+}
+interface BulkImportOptions {
+    batchSize?: number;
+    dryRun?: boolean;
+    dedup?: boolean;
+    trustLevel?: "import";
+    namespace?: string;
+}
+type ImportSourceRole = ImportTurn["role"];
+interface BulkImportResult {
+    memoriesCreated: number;
+    duplicatesSkipped: number;
+    entitiesCreated: number;
+    turnsProcessed: number;
+    batchesProcessed: number;
+    errors: BulkImportError[];
+}
+interface BulkImportError {
+    batchIndex: number;
+    message: string;
+}
+interface BulkImportSourceAdapter {
+    name: string;
+    parse(input: unknown, options?: {
+        strict?: boolean;
+        platform?: string;
+    }): Promise<BulkImportSource> | BulkImportSource;
+}
+interface ImportTurnValidationIssue {
+    code: string;
+    message: string;
+    index?: number;
+}
+declare function isImportRole(value: unknown): value is ImportSourceRole;
+/**
+ * Parse an ISO-8601 / RFC 3339 timestamp used by bulk-import adapters.
+ *
+ * Accepts variable-precision fractional seconds and either a `Z` suffix or a
+ * `[+-]HH:MM` timezone offset, so adapters may preserve their source
+ * timestamps verbatim. Returns milliseconds since epoch, or `null` if the
+ * string is not a well-formed timestamp (including overflowed calendar dates
+ * or out-of-range offsets).
+ *
+ * Delegates to the shared parser in `utils/iso-timestamp.ts` — do not
+ * reimplement locally; extend that helper instead.
+ */
+declare function parseIsoTimestamp(value: string): number | null;
+declare function validateImportTurn(turn: ImportTurn, index?: number): ImportTurnValidationIssue[];
+
 type SummarizeFn = (text: string, targetTokens: number, aggressive: boolean) => Promise<string | null>;
 
 declare class LcmEngine {
@@ -168,29 +236,29 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     decision: "rejected" | "approved" | "approved_with_feedback";
-    reason: string;
     agent: string;
     date: string;
+    reason: string;
     confidence?: number | undefined;
+    workflow?: string | undefined;
     tags?: string[] | undefined;
     severity?: "low" | "medium" | "high" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
-    workflow?: string | undefined;
     learning?: string | undefined;
     evidenceWindowStart?: string | undefined;
     evidenceWindowEnd?: string | undefined;
 }, {
     decision: "rejected" | "approved" | "approved_with_feedback";
-    reason: string;
     agent: string;
     date: string;
+    reason: string;
     confidence?: number | undefined;
+    workflow?: string | undefined;
     tags?: string[] | undefined;
     severity?: "low" | "medium" | "high" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
-    workflow?: string | undefined;
     learning?: string | undefined;
     evidenceWindowStart?: string | undefined;
     evidenceWindowEnd?: string | undefined;
@@ -486,6 +554,7 @@ declare class CompoundingEngine {
     private readContinuityAuditReferences;
 }
 
+declare function dedupeEntitySynthesisEvidenceEntries(entries: EntityTimelineEntry[]): EntityTimelineEntry[];
 interface GraphRecallSnapshot {
     recordedAt: string;
     mode: RecallPlanMode | string;
@@ -681,6 +750,7 @@ declare class Orchestrator {
     readonly summarizer: HourlySummarizer;
     readonly localLlm: LocalLlmClient;
     readonly fastLlm: LocalLlmClient;
+    private readonly judgeVerdictCache;
     private readonly fastGatewayLlm;
     readonly modelRegistry: ModelRegistry;
     readonly relevance: RelevanceStore;
@@ -721,6 +791,7 @@ declare class Orchestrator {
     private nonZeroExtractionsSinceConsolidation;
     private lastConsolidationRunAtMs;
     private consolidationInFlight;
+    private readonly consolidationObservers;
     private qmdMaintenanceTimer;
     private qmdMaintenancePending;
     private qmdMaintenanceInFlight;
@@ -739,6 +810,36 @@ declare class Orchestrator {
     private evalShadowWriteChain;
     private initPromise;
     private resolveInit;
+    /**
+     * Resolves when deferred initialization (QMD probe, warmup, caches, cron)
+     * completes. CLI and http-serve callers that need `qmd.isAvailable()` to
+     * reflect reality should `await orchestrator.deferredReady` after
+     * `initialize()`. Gateway callers can ignore it — recall() degrades
+     * gracefully when QMD isn't ready yet.
+     *
+     * Also resolves (without error) when `initialize()` throws before reaching
+     * the deferred-init phase, so callers never hang on a permanently-pending
+     * promise.
+     *
+     * Host adapters that need to tie deferred init to their stop() lifecycle
+     * should `await orchestrator.deferredReady` before proceeding with teardown
+     * to prevent background QMD/warmup/cron tasks from racing with shutdown.
+     */
+    deferredReady: Promise<void>;
+    private resolveDeferredReady;
+    private deferredInitAbort;
+    /**
+     * Whether the deferred init's QMD startup sync completed successfully.
+     * When false after deferredReady resolves, the server retry loop should
+     * attempt startupSearchSync() even if `qmd.isAvailable()` is true —
+     * availability only means probe succeeded, not that the index is current.
+     */
+    deferredSyncSucceeded: boolean;
+    /**
+     * Abort deferred initialization so background QMD sync/warmup stops
+     * promptly on shutdown. Safe to call multiple times or before init.
+     */
+    abortDeferredInit(): void;
     /** 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 */
@@ -794,12 +895,29 @@ declare class Orchestrator {
         } | null>;
     };
     initialize(): Promise<void>;
+    private deferredInitialize;
+    /**
+     * Namespace-aware startup search sync. Re-probes QMD, ensures collections
+     * (namespace-aware when namespacesEnabled), runs update, and warms up search.
+     * Designed for server retry paths that run after the deferred init completes
+     * when QMD was not available during initial startup.
+     *
+     * Accepts an optional AbortSignal so callers can interrupt the sync during
+     * shutdown. The signal is checked between phases and forwarded into the QMD
+     * update and warmup search calls so a long-running `qmd update` subprocess
+     * is killed promptly rather than left in flight after `httpServer.stop()`.
+     *
+     * Returns true if the sync succeeded (QMD now available), false otherwise.
+     */
+    startupSearchSync(signal?: AbortSignal): Promise<boolean>;
     /**
      * Auto-register the engram-day-summary cron job in OpenClaw if it doesn't exist.
      * Fire-and-forget — never blocks init or crashes on failure.
      */
     private autoRegisterDaySummaryCron;
     private autoRegisterNightlyGovernanceCron;
+    private autoRegisterProceduralMiningCron;
+    private autoRegisterContradictionScanCron;
     applyBehaviorRuntimePolicy(state: BehaviorLoopPolicyState): Promise<{
         applied: boolean;
         rolledBack: boolean;
@@ -814,6 +932,10 @@ declare class Orchestrator {
         merged: number;
         invalidated: number;
     }>;
+    reindexMemoryById(id: string, options?: {
+        storage?: StorageManager;
+    }): Promise<void>;
+    registerConsolidationObserver(observer: (observation: ConsolidationObservation) => Promise<void> | void): () => void;
     runSemanticConsolidationNow(options?: {
         dryRun?: boolean;
         thresholdOverride?: number;
@@ -822,6 +944,7 @@ declare class Orchestrator {
     waitForExtractionIdle(timeoutMs?: number): Promise<boolean>;
     waitForConsolidationIdle(timeoutMs?: number): Promise<boolean>;
     getStorage(namespace?: string): Promise<StorageManager>;
+    processEntitySynthesisQueue(namespace?: string, maxEntities?: number): Promise<number>;
     generateDaySummary(memories: string | MemoryFile[]): Promise<DaySummaryResult | null>;
     /**
      * Auto-gather today's facts and hourly summaries from storage, then generate a day summary.
@@ -947,12 +1070,83 @@ declare class Orchestrator {
     private getRecallBudgetChars;
     private assembleRecallSections;
     private recallInternal;
-    processTurn(role: "user" | "assistant", content: string, sessionKey?: string): Promise<void>;
+    processTurn(role: "user" | "assistant", content: string, sessionKey?: string, options?: {
+        bufferKey?: string;
+        logicalSessionKey?: string;
+        providerThreadId?: string | null;
+        turnFingerprint?: string;
+        persistProcessedFingerprint?: boolean;
+    }): Promise<void>;
+    flushSession(sessionKey: string, options: {
+        reason: string;
+        abortSignal?: AbortSignal;
+        bufferKey?: string;
+    }): Promise<void>;
     ingestReplayBatch(turns: ReplayTurn[], options?: {
         deadlineMs?: number;
     }): Promise<void>;
-    observeSessionHeartbeat(sessionKey: string): Promise<void>;
+    /**
+     * Return the namespace that `ingestBulkImportBatch` writes into (#460).
+     *
+     * Exposed so host CLIs can snapshot the same storage root that extraction
+     * actually writes to, avoiding the "CLI counts files at namespace A while
+     * writes land in namespace B" footgun that a naïve
+     * `config.defaultNamespace` snapshot could hit when a namespace policy
+     * named `"default"` also exists.
+     *
+     * Today bulk-import is pinned to `config.defaultNamespace`; future
+     * per-invocation namespace routing would thread an explicit target here
+     * and through `ingestBulkImportBatch`.
+     */
+    bulkImportWriteNamespace(): string;
+    /**
+     * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
+     * normalizes user/assistant turns into the extraction buffer and awaits
+     * settlement, but it intentionally bypasses the captureMode="explicit"
+     * gate because bulk-import is itself an explicit user action — the user
+     * ran `bulk-import --source <name> --file ...` and would be surprised to
+     * see the command silently no-op when capture is otherwise restricted.
+     *
+     * Turns with role="other" are skipped (not supported by the extraction
+     * pipeline).
+     *
+     * Two design decisions worth calling out:
+     *
+     * - **sessionKey is truthy and per-batch-unique.**
+     *   `ThreadingManager.shouldStartNewThread` only applies the session-key
+     *   boundary check when `turn.sessionKey` is truthy (threading.ts:82);
+     *   with an empty string, imported turns could attach to the current
+     *   live thread or merge across unrelated import batches. A unique
+     *   `bulk-import:batch:<timestamp>-<rand>` key forces a fresh thread per
+     *   batch without matching common prefix/map rules in
+     *   `principalFromSessionKeyRules`. (Catch-all regex rules could still
+     *   remap the principal, but that only affects metadata provenance —
+     *   see the next point for why write routing is unaffected.)
+     *
+     * - **writeNamespaceOverride pins the storage target.**
+     *   We pass `writeNamespaceOverride: this.bulkImportWriteNamespace()` to
+     *   `queueBufferedExtraction`, which tells `runExtraction` to skip
+     *   `defaultNamespaceForPrincipal` and write directly into the
+     *   orchestrator's declared bulk-import write namespace. This keeps
+     *   writes deterministic even when namespace policies named `"default"`
+     *   exist alongside a different `config.defaultNamespace`, and also
+     *   guards against regex-catch-all principal rules steering bulk-import
+     *   into an unexpected tenant.
+     *
+     * Per-invocation namespace routing (letting callers target a namespace
+     * other than `bulkImportWriteNamespace()`) is a separate feature tracked
+     * as a follow-up — the hook is the `writeNamespaceOverride` option, but
+     * the CLI surface does not yet expose a `--namespace` flag.
+     */
+    ingestBulkImportBatch(turns: ImportTurn[], options?: {
+        deadlineMs?: number;
+    }): Promise<void>;
+    observeSessionHeartbeat(sessionKey: string, options?: {
+        bufferKey?: string;
+    }): Promise<void>;
     private queueBufferedExtraction;
+    private normalizeExtractionFingerprintTurns;
+    private buildExtractionFingerprint;
     private shouldQueueExtraction;
     /**
      * Background serial queue processor.
@@ -960,7 +1154,26 @@ 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;
     getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot>;
     runTierMigrationNow(options?: {
@@ -1055,8 +1268,59 @@ declare class Orchestrator {
     private emitTrace;
     private queueEvalShadowRecall;
     private publishRecallResults;
+    /**
+     * Apply MMR over the pre-truncation recall candidate pool and then slice
+     * the result to `limit`. This is the single place in the pipeline where
+     * MMR runs, and it must be called *before* callers throw away candidates
+     * that would otherwise sit below the final cutoff. Running MMR post-slice
+     * is a no-op in the cases we care about — diverse candidates just below
+     * the cutoff are already gone and can never be promoted.
+     *
+     * Callers must pass the full candidate pool (post-rerank, pre-slice).
+     */
+    private diversifyAndLimitRecallResults;
+    /**
+     * Apply Maximal Marginal Relevance to a section's ordered candidate list.
+     *
+     * Operates per-section so one redundant cluster cannot dominate a section,
+     * and so one section's MMR pass cannot starve other sections. Returns the
+     * input unchanged when disabled, when there are fewer than 2 candidates, or
+     * when no budget information is available.
+     */
+    private applyMmrToQmdResults;
     private buildLastRecallBudgetSummary;
     private collectLastRecallSources;
+    /**
+     * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
+     * guard. Returns the top-K embedding hits against the currently indexed
+     * memories, or an empty array when the embedding backend is unavailable.
+     * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
+     * and "error" outcomes as fail-open (keep the candidate).
+     *
+     * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
+     * to the SAME namespace as the fact being written. Otherwise a
+     * high-similarity memory from another namespace can suppress a write in
+     * the target namespace — cross-tenant data loss. Callers pass the target
+     * storage so we can translate its root directory into the correct index
+     * path prefix (and, for the legacy default-namespace layout at
+     * `memoryDir` root, an exclusion list for `namespaces/*`).
+     */
+    private semanticDedupLookup;
+    /**
+     * Resolve the namespace-scoped filter to pass into
+     * `EmbeddingFallback.search()` for semantic dedup. Returns an empty
+     * object (no filter) when namespaces are disabled, preserving the
+     * pre-PR #399 behavior for single-tenant installs.
+     *
+     * Index entries are stored as paths relative to `config.memoryDir`, so:
+     *   - A non-default namespace `ns` lives under `namespaces/<ns>/…` and
+     *     we include exactly that prefix.
+     *   - The default namespace may live at `memoryDir` root (legacy) or at
+     *     `memoryDir/namespaces/<default>/…` (migrated). When it lives at
+     *     root we include everything but EXCLUDE all `namespaces/…` entries
+     *     so facts from non-default namespaces can't cross-match.
+     */
+    private semanticDedupScopeFor;
     private searchEmbeddingFallback;
     /**
      * Long-term fallback retrieval.
@@ -1101,4 +1365,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-export { resolvePersistedMemoryRelativePath as A, resolveRecallModeDecision as B, type CompoundingPromotionReport as C, resolveRecentThreadMemoryPaths as D, shouldFilterLifecycleRecallCandidate as E, summarizeGraphShadowComparison as F, type GraphRecallSnapshot as G, type IntentDebugSnapshot as I, Orchestrator as O, type QmdRecallSnapshot as Q, type ReplaySource as R, type ReplayWarning as a, type ReplayTurn as b, type GraphRecallRankedResult as c, defaultWorkspaceDir as d, type GraphRecallShadowComparison as e, type RecallInvocationOptions as f, type RecallModeDecision as g, appendMemoryToGraphContext as h, blendGraphExpandedRecallScore as i, buildCompressionGuidelinesMarkdown as j, buildMemoryPathById as k, computeArtifactCandidateFetchLimit as l, computeArtifactRecallLimit as m, computeQmdHybridFetchLimit as n, deriveTopicsFromExtraction as o, filterRecallCandidates as p, formatCompressionGuidelinesForRecall as q, graphPathRelativeToStorage as r, sanitizeSessionKeyForFilename as s, hasIdentityRecoveryIntent as t, isArtifactMemoryPath as u, lifecycleRecallScoreAdjustment as v, mergeArtifactRecallCandidates as w, mergeGraphExpandedResults as x, resolveEffectiveIdentityInjectionMode as y, resolveEffectiveRecallMode as z };
+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 };