@remnic/core 1.1.31 → 9.3.516

package/dist/fallback-llm.d.ts

@@ -1,4 +1,6 @@
 import { GatewayConfig } from './types.js';
+import { GetRuntimeAuthForModelFn, ResolveApiKeyFn } from './resolve-provider-secret.js';
+import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 
 interface FallbackLlmOptions {
@@ -22,8 +24,16 @@ interface FallbackLlmResponse {
 }
 interface FallbackLlmRuntimeContext {
     agentDir?: string;
+    getRuntimeAuthForModel?: GetRuntimeAuthForModelFn | null;
+    resolveApiKeyForProvider?: ResolveApiKeyFn | null;
     workspaceDir?: string;
 }
+declare function fallbackLlmRuntimeContextFromConfig(config: Pick<GatewayBackedRuntimeConfig, "providerApiKeyResolver" | "runtimeAuthForModelResolver" | "workspaceDir">, overrides?: FallbackLlmRuntimeContext): FallbackLlmRuntimeContext;
+type GatewayBackedRuntimeConfig = {
+    providerApiKeyResolver?: ResolveApiKeyFn | null;
+    runtimeAuthForModelResolver?: GetRuntimeAuthForModelFn | null;
+    workspaceDir?: string;
+};
 /**
  * Generic fallback LLM client that uses the gateway's default AI configuration
  * and walks through the full fallback chain (primary + fallbacks).
@@ -132,4 +142,4 @@ declare class FallbackLlmClient {
     private callAnthropic;
 }
 
-export { FallbackLlmClient, type FallbackLlmOptions, type FallbackLlmResponse, type FallbackLlmRuntimeContext };
+export { FallbackLlmClient, type FallbackLlmOptions, type FallbackLlmResponse, type FallbackLlmRuntimeContext, fallbackLlmRuntimeContextFromConfig };

package/dist/fallback-llm.js

@@ -1,16 +1,18 @@
 import {
-  FallbackLlmClient
-} from "./chunk-DINWEURR.js";
-import "./chunk-FLTNHQK6.js";
+  FallbackLlmClient,
+  fallbackLlmRuntimeContextFromConfig
+} from "./chunk-CSKLPDN6.js";
+import "./chunk-B5XMS73R.js";
 import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-UZB5KHKX.js";
 import "./chunk-RK6F44Y6.js";
-import "./chunk-QRNI5JBH.js";
-import "./chunk-XIG5PDM7.js";
+import "./chunk-EYIEWJNI.js";
+import "./chunk-JUC24CTX.js";
 import "./chunk-2ODBA7MQ.js";
 import "./chunk-PZ5AY32C.js";
 export {
-  FallbackLlmClient
+  FallbackLlmClient,
+  fallbackLlmRuntimeContextFromConfig
 };
 //# sourceMappingURL=fallback-llm.js.map

package/dist/{first-start-migration-4MHQEOSD.js → first-start-migration-CKTCTCQI.js}

@@ -1,17 +1,17 @@
 import {
   applyUtilityPromotionRuntimePolicy,
   loadUtilityRuntimeValues
-} from "./chunk-FSFEQI74.js";
+} from "./chunk-W7L6HXUC.js";
 import {
   TierMigrationExecutor
 } from "./chunk-Z5AAYHUC.js";
 import {
   decideTierTransition
 } from "./chunk-S75M5ZRK.js";
-import "./chunk-PYXS46O7.js";
-import "./chunk-3QKK7QOS.js";
+import "./chunk-3BP57I6J.js";
+import "./chunk-TERNBNJB.js";
 import "./chunk-TBBDFYXW.js";
-import "./chunk-DGXUHMOV.js";
+import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
 import "./chunk-PZ5AY32C.js";
 
@@ -260,4 +260,4 @@ export {
   LIFECYCLE_INIT_DONE_MARKER,
   runFirstStartMigration
 };
-//# sourceMappingURL=first-start-migration-4MHQEOSD.js.map
+//# sourceMappingURL=first-start-migration-CKTCTCQI.js.map

package/dist/graph-dashboard-diff.d.ts

@@ -6,6 +6,10 @@ interface GraphPatch {
     removedNodes: string[];
     addedEdges: GraphEdge[];
     removedEdges: GraphEdge[];
+    updatedEdges: Array<{
+        previous: GraphEdge;
+        next: GraphEdge;
+    }>;
 }
 declare function diffGraphSnapshots(previous: GraphSnapshot, next: GraphSnapshot): GraphPatch;
 

package/dist/graph-dashboard-diff.js

@@ -1,6 +1,6 @@
 import {
   diffGraphSnapshots
-} from "./chunk-3SLRNYNG.js";
+} from "./chunk-AUDJPF4N.js";
 import "./chunk-Y4Z4I6WK.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/graph-dashboard-parser.js

@@ -1,6 +1,6 @@
 import {
   graphSnapshotFromMemoryDir
-} from "./chunk-LIRZNNUP.js";
+} from "./chunk-44442YCH.js";
 import "./chunk-Y4Z4I6WK.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/{graph-edge-decay-5DI5GUNL.js → graph-edge-decay-MUP5J7CC.js}

@@ -1,12 +1,9 @@
-import {
-  isSafeRouteNamespace
-} from "./chunk-U3PN77QT.js";
 import {
   graphFilePath,
   graphsDir,
   readEdgesStrict,
   withGraphWriteLock
-} from "./chunk-RK2Y4XOM.js";
+} from "./chunk-4JRRISLU.js";
 import {
   DEFAULT_DECAY_FLOOR,
   DEFAULT_DECAY_PER_WINDOW,
@@ -14,7 +11,10 @@ import {
   decayEdgeConfidence,
   readEdgeConfidence
 } from "./chunk-2LSZVONP.js";
-import "./chunk-WIICJPET.js";
+import "./chunk-DEUNUKTD.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-U3PN77QT.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/maintenance/graph-edge-decay.ts
@@ -204,4 +204,4 @@ export {
   runGraphEdgeDecayMaintenance,
   runGraphEdgeDecayMaintenanceAcrossNamespaces
 };
-//# sourceMappingURL=graph-edge-decay-5DI5GUNL.js.map
+//# sourceMappingURL=graph-edge-decay-MUP5J7CC.js.map

package/dist/graph-events.js

@@ -3,7 +3,7 @@ import {
   emitGraphEvent,
   getGraphEventBus,
   subscribeGraphEvents
-} from "./chunk-WIICJPET.js";
+} from "./chunk-DEUNUKTD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   destroyGraphEventBus,

package/dist/graph-snapshot.js

@@ -4,10 +4,10 @@ import {
   buildGraphSnapshot,
   normalizeGraphSnapshotLimit,
   parseGraphSnapshotSince
-} from "./chunk-PCUKNJAZ.js";
-import "./chunk-RK2Y4XOM.js";
+} from "./chunk-JKV57BTN.js";
+import "./chunk-4JRRISLU.js";
 import "./chunk-2LSZVONP.js";
-import "./chunk-WIICJPET.js";
+import "./chunk-DEUNUKTD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   GRAPH_SNAPSHOT_DEFAULT_LIMIT,

package/dist/graph.js

@@ -17,9 +17,9 @@ import {
   readEdges,
   readEdgesStrict,
   withGraphWriteLock
-} from "./chunk-RK2Y4XOM.js";
+} from "./chunk-4JRRISLU.js";
 import "./chunk-2LSZVONP.js";
-import "./chunk-WIICJPET.js";
+import "./chunk-DEUNUKTD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   CAUSAL_PHRASES,

package/dist/harmonic-retrieval.js

@@ -1,11 +1,11 @@
 import {
   searchHarmonicRetrieval
-} from "./chunk-HMDCOMYU.js";
-import "./chunk-C6QPK5GG.js";
+} from "./chunk-SKGV326D.js";
+import "./chunk-FZZ2QTJI.js";
 import "./chunk-PVGDJXVK.js";
-import "./chunk-NGAVDO7E.js";
+import "./chunk-OADWQ5CR.js";
 import "./chunk-DT5TVLJE.js";
-import "./chunk-DGXUHMOV.js";
+import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/identity-continuity.d.ts

@@ -1,4 +1,5 @@
 import { ContinuityIncidentRecord, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityImprovementLoop, ContinuityLoopReviewInput, ContinuityLoopUpsertInput } from './types.js';
+import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 
 declare function serializeContinuityIncident(incident: ContinuityIncidentRecord): string;

package/dist/importance.d.ts

@@ -1,4 +1,5 @@
 import { ImportanceLevel, MemoryFile, ImportanceScore, MemoryCategory } from './types.js';
+import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 
 /**

package/dist/importers/index.d.ts

@@ -0,0 +1,244 @@
+import { I as ImportTurn } from '../types-BliCnURB.js';
+import '../index-DJ9QWMw-.js';
+
+/**
+ * A single imported memory record with provenance.
+ *
+ * Every importer MUST attach a truthful `sourceLabel` (e.g. `"chatgpt"`,
+ * `"claude"`, `"gemini"`, `"mem0"`) and MAY attach the export's origin path or
+ * URL in `importedFromPath`. `importedAt` is always set by `runImporter` so
+ * adapters do not need to timestamp records themselves.
+ */
+interface ImportedMemory {
+    /**
+     * The user-facing memory content. This is the string that will eventually
+     * land in the memory store (after extraction / orchestrator processing).
+     */
+    content: string;
+    /**
+     * Source-specific identifier for idempotent re-imports. Optional — when
+     * present, adapters SHOULD use the source's stable id (e.g. ChatGPT memory
+     * uuid); when absent, the orchestrator's own content hashing provides dedup.
+     */
+    sourceId?: string;
+    /**
+     * Source-specific timestamp at which the memory was originally created or
+     * last updated. ISO 8601. Optional — adapters fall back to `importedAt`
+     * when the source does not expose a creation timestamp.
+     */
+    sourceTimestamp?: string;
+    /**
+     * Human-readable short label identifying the origin platform
+     * (`"chatgpt"`, `"claude"`, `"gemini"`, `"mem0"`). Required so the
+     * orchestrator can attribute recalled memories correctly.
+     */
+    sourceLabel: string;
+    /**
+     * Path to the export file the memory was parsed from, OR the endpoint URL
+     * for API-based imports. Optional but strongly recommended so users can
+     * trace a memory back to the file they imported.
+     */
+    importedFromPath?: string;
+    /**
+     * ISO 8601 timestamp set by `runImporter` immediately before writeTo().
+     * Adapters MAY populate this themselves; `runImporter` will fill in the
+     * current wall-clock time when absent.
+     */
+    importedAt?: string;
+    /**
+     * Adapter-specific raw metadata preserved for debugging / future rehydration
+     * (e.g. conversation id, thread id, tags). Must be JSON-serializable;
+     * adapters MUST NOT stash functions or circular references here.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options threaded through every importer run. Adapters receive this object
+ * from `runImporter`; the top-level CLI populates it from `--dry-run`,
+ * `--batch-size`, and `--rate-limit` flags.
+ */
+interface RunImportOptions {
+    /**
+     * When true, parse + transform but skip writeTo(). `runImporter` prints a
+     * summary of what WOULD have been imported and returns early.
+     */
+    dryRun?: boolean;
+    /**
+     * Target batch size for writeTo(). Adapters that chunk memories into
+     * smaller orchestrator calls should honor this. Defaults to
+     * `DEFAULT_IMPORT_BATCH_SIZE` when undefined. Values outside the valid
+     * range throw from `validateImportBatchSize`.
+     */
+    batchSize?: number;
+    /**
+     * Optional rate limit for API-backed importers (mem0). Expressed as
+     * requests-per-second. Adapters that do not hit an external API may ignore
+     * this. When provided, `validateImportRateLimit` enforces the positive-
+     * finite contract.
+     */
+    rateLimit?: number;
+    /**
+     * Invoked after every chunk of memories is processed. `total` is the full
+     * count of memories produced by `transform`; `processed` counts memories
+     * already ingested (or skipped in dry-run mode). Adapters SHOULD call this
+     * incrementally — `runImporter` itself calls it once per batch.
+     */
+    onProgress?: (progress: ImportProgress) => void;
+}
+interface ImportProgress {
+    processed: number;
+    total: number;
+    /** Current phase for human-readable logging. */
+    phase: "parse" | "transform" | "write" | "dry-run";
+}
+/**
+ * Interface every importer package implements.
+ *
+ * The three-method surface intentionally mirrors the issue #568 spec:
+ *
+ *   - `parse(input)`: raw payload → intermediate representation.
+ *   - `transform(parsed)`: intermediate representation → `ImportedMemory[]`.
+ *   - `writeTo(target, memories, options)`: actually commit to the
+ *     orchestrator (or whatever target the host provides).
+ *
+ * Adapters MAY keep `parse` and `transform` separate (e.g. ChatGPT conversions
+ * that need to split saved-memories from conversation summaries) or collapse
+ * them into a single operation — what matters is that the combined pipeline
+ * produces an array of `ImportedMemory` records with correct provenance.
+ *
+ * `Parsed` is generic so strongly-typed intermediate shapes survive through
+ * the adapter's own code without leaking to callers of `runImporter`.
+ */
+interface ImporterAdapter<Parsed = unknown> {
+    /** Short stable name used by `remnic import --adapter <name>`. */
+    name: string;
+    /** Human-readable label surfaced in CLI output and source attribution. */
+    sourceLabel: string;
+    /**
+     * Parse a raw payload (file contents, API response, etc.) into the adapter
+     * intermediate representation. Pure — MUST NOT call the orchestrator.
+     */
+    parse(input: unknown, options?: ImporterParseOptions): Parsed | Promise<Parsed>;
+    /**
+     * Flatten parsed input into an array of importable memories. Pure — MUST
+     * NOT call the orchestrator. Provenance fields (`sourceLabel`,
+     * `importedFromPath`) should be populated here.
+     */
+    transform(parsed: Parsed, options?: ImporterTransformOptions): ImportedMemory[] | Promise<ImportedMemory[]>;
+    /**
+     * Commit the transformed memories to the orchestrator (or equivalent
+     * target). `runImporter` only invokes this when dryRun is false.
+     *
+     * Adapters typically call `orchestrator.ingestBulkImportBatch` once per
+     * batch after converting `ImportedMemory` records into `ImportTurn` shapes.
+     */
+    writeTo(target: ImporterWriteTarget, memories: ImportedMemory[], options: RunImportOptions): Promise<ImporterWriteResult>;
+}
+/**
+ * Shape of the "target" passed to `writeTo`.
+ *
+ * This is intentionally narrower than the full `Orchestrator` class: importer
+ * adapters only need to push `ImportTurn[]` batches and read the active
+ * bulk-import namespace. Narrowing keeps test doubles simple (the slice-1
+ * integration test uses a pure in-memory mock) and prevents adapters from
+ * reaching into orchestrator internals that would make them harder to move
+ * between host environments.
+ */
+interface ImporterWriteTarget {
+    ingestBulkImportBatch(turns: ImportTurn[], options?: {
+        deadlineMs?: number;
+    }): Promise<void>;
+    bulkImportWriteNamespace?(): string;
+}
+interface ImporterWriteResult {
+    memoriesIngested: number;
+    /** Optional: adapter-surfaced duplicates or skipped entries. */
+    skipped?: number;
+}
+/** Options forwarded to `parse`. Adapter-specific; additive by design. */
+interface ImporterParseOptions {
+    strict?: boolean;
+    /** Source path passed through for provenance. */
+    filePath?: string;
+    /**
+     * Requests-per-second throttle, forwarded from the top-level
+     * `RunImportOptions.rateLimit`. Only meaningful for API-backed importers
+     * (mem0) — file-based adapters ignore it. `runImporter` copies this
+     * through automatically so CLI users never have to stash it on
+     * `parseOptions` themselves. Cursor review on PR #602.
+     */
+    rateLimit?: number;
+}
+/** Options forwarded to `transform`. */
+interface ImporterTransformOptions {
+    /** When true, adapters that normally skip bulk conversations should include them. */
+    includeConversations?: boolean;
+    /** Maximum number of memories to emit. Primarily for tests. */
+    maxMemories?: number;
+    /** Adapter-specific minimum source text length for importers that filter tiny prompts. */
+    minPromptLength?: number;
+}
+declare const DEFAULT_IMPORT_BATCH_SIZE = 25;
+/**
+ * Coerce and validate the caller-supplied batch size. CLAUDE.md rule 14/51:
+ * reject invalid CLI input rather than silently defaulting.
+ */
+declare function validateImportBatchSize(value: number | undefined): number;
+/**
+ * Validate the `--rate-limit` (requests per second) value used by API
+ * importers. Zero / negative / non-finite values throw — the CLI must reject
+ * them rather than silently import at unlimited speed.
+ */
+declare function validateImportRateLimit(value: number | undefined): number | undefined;
+/**
+ * Convert an `ImportedMemory` into an `ImportTurn` suitable for
+ * `orchestrator.ingestBulkImportBatch`. The resulting turn is always
+ * `role="user"` because every downstream source (saved memories, personal
+ * context, mem0 entries) represents a first-person statement rather than an
+ * assistant response.
+ *
+ * Keeps provenance on the turn via `participantName` so the extraction
+ * pipeline's transcript renderer labels the speaker with the source platform.
+ */
+declare function importedMemoryToTurn(memory: ImportedMemory): ImportTurn;
+interface RunImporterResult {
+    adapter: string;
+    sourceLabel: string;
+    /**
+     * Total memories produced by `transform`. In dry-run mode this is the same
+     * as the number of memories that WOULD have been written.
+     */
+    memoriesPlanned: number;
+    /**
+     * Number of memories actually handed to writeTo(). Always zero in dry-run
+     * mode.
+     */
+    memoriesWritten: number;
+    batchesProcessed: number;
+    dryRun: boolean;
+    /** Mirrors the importedAt stamped on every memory. */
+    importedAt: string;
+}
+/**
+ * Orchestrate `parse → transform → writeTo` for an adapter. This is the
+ * default pipeline used by the CLI; adapters are free to implement their own
+ * orchestration when they need per-record rate-limiting or streaming parses
+ * that would not fit in the "produce full array before writing" shape.
+ *
+ * Mutates the supplied memory records by filling in `importedAt` when the
+ * adapter did not set it (CLAUDE.md rule 38: records are written in insertion
+ * order to keep the provenance log stable).
+ */
+declare function runImporter<Parsed>(adapter: ImporterAdapter<Parsed>, input: unknown, target: ImporterWriteTarget, options?: RunImportOptions & {
+    parseOptions?: ImporterParseOptions;
+    transformOptions?: ImporterTransformOptions;
+}): Promise<RunImporterResult>;
+/**
+ * Default `writeTo` implementation for importers that want to hand every
+ * memory to `orchestrator.ingestBulkImportBatch` without custom routing.
+ * Adapters that need per-record rate-limiting or conversation-thread linking
+ * are free to implement their own `writeTo`.
+ */
+declare function defaultWriteMemoriesToOrchestrator(target: ImporterWriteTarget, memories: ImportedMemory[]): Promise<ImporterWriteResult>;
+
+export { DEFAULT_IMPORT_BATCH_SIZE, type ImportProgress, type ImportedMemory, type ImporterAdapter, type ImporterParseOptions, type ImporterTransformOptions, type ImporterWriteResult, type ImporterWriteTarget, type RunImportOptions, type RunImporterResult, defaultWriteMemoriesToOrchestrator, importedMemoryToTurn, runImporter, validateImportBatchSize, validateImportRateLimit };

package/dist/importers/index.js

@@ -0,0 +1,20 @@
+import {
+  DEFAULT_IMPORT_BATCH_SIZE,
+  defaultWriteMemoriesToOrchestrator,
+  importedMemoryToTurn,
+  runImporter,
+  validateImportBatchSize,
+  validateImportRateLimit
+} from "../chunk-LUDUFZTV.js";
+import "../chunk-PU44GBL4.js";
+import "../chunk-P7FMDTKL.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  DEFAULT_IMPORT_BATCH_SIZE,
+  defaultWriteMemoriesToOrchestrator,
+  importedMemoryToTurn,
+  runImporter,
+  validateImportBatchSize,
+  validateImportRateLimit
+};
+//# sourceMappingURL=index.js.map