@remnic/core 9.69.27 → 9.69.29

package/dist/{chunk-RBCQVOVJ.js → chunk-PV36INNL.js}

@@ -1,9 +1,9 @@
 import {
   NamespaceStorageRouter
-} from "./chunk-E2P7TZTF.js";
+} from "./chunk-ROKKIMON.js";
 import {
   namespaceCollectionName
-} from "./chunk-2Z4GS5E6.js";
+} from "./chunk-FHQSPTPZ.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-PCXDUHQH.js";
@@ -213,4 +213,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-RBCQVOVJ.js.map
+//# sourceMappingURL=chunk-PV36INNL.js.map

package/dist/{chunk-E2P7TZTF.js → chunk-ROKKIMON.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-XSGUMQQQ.js";
+} from "./chunk-GVG3JYBI.js";
 import {
   MutationSerializer
 } from "./chunk-FFAZ2XFU.js";
@@ -412,4 +412,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-E2P7TZTF.js.map
+//# sourceMappingURL=chunk-ROKKIMON.js.map

package/dist/{chunk-OEYZXDQI.js → chunk-RSVEP77Y.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-XSGUMQQQ.js";
+} from "./chunk-GVG3JYBI.js";
 import {
   composeMemoryEnvelope
 } from "./chunk-3QQTXYZ6.js";
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-OEYZXDQI.js.map
+//# sourceMappingURL=chunk-RSVEP77Y.js.map

package/dist/{chunk-FQ7HAWWC.js → chunk-RZN4LQ5Y.js}

@@ -158,6 +158,20 @@ async function defaultWriteMemoriesToOrchestrator(target, memories) {
   await target.ingestBulkImportBatch(turns);
   return { memoriesIngested: memories.length };
 }
+function defineFileImporterAdapter(definition) {
+  return {
+    name: definition.name,
+    sourceLabel: definition.sourceLabel,
+    parse(input, options) {
+      return definition.parse(input, {
+        ...options?.strict !== void 0 ? { strict: options.strict } : {},
+        ...options?.filePath !== void 0 ? { filePath: options.filePath } : {}
+      });
+    },
+    transform: (parsed, options) => definition.transform(parsed, options),
+    writeTo: defaultWriteMemoriesToOrchestrator
+  };
+}
 
 export {
   DEFAULT_IMPORT_BATCH_SIZE,
@@ -165,6 +179,7 @@ export {
   validateImportRateLimit,
   importedMemoryToTurn,
   runImporter,
-  defaultWriteMemoriesToOrchestrator
+  defaultWriteMemoriesToOrchestrator,
+  defineFileImporterAdapter
 };
-//# sourceMappingURL=chunk-FQ7HAWWC.js.map
+//# sourceMappingURL=chunk-RZN4LQ5Y.js.map

package/dist/{chunk-FQ7HAWWC.js.map → chunk-RZN4LQ5Y.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/importers/base.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// Shared importer base (issue #568)\n// ---------------------------------------------------------------------------\n//\n// The importer adapters defined by issue #568 (`@remnic/import-chatgpt`,\n// `@remnic/import-claude`, `@remnic/import-gemini`, `@remnic/import-mem0`) all\n// follow the same three-step shape:\n//\n//   1. parse(input)          — turn a raw file / API payload into a\n//                              source-specific intermediate structure.\n//   2. transform(parsed)     — flatten that structure into a uniform list of\n//                              `ImportedMemory` records with provenance\n//                              attached (sourceLabel, importedFromPath,\n//                              importedAt).\n//   3. writeTo(orchestrator) — hand each memory to the orchestrator via\n//                              `ingestBulkImportBatch`. Dry-run mode stops\n//                              after transform() and never calls writeTo().\n//\n// This file defines the shared `ImporterAdapter` interface plus a thin\n// `runImporter` helper that handles batching, dry-run plan reporting, and\n// progress callbacks so every adapter does not reimplement the same loop.\n//\n// The existing lower-level `BulkImportSourceAdapter` (weclone-shaped: produces\n// turn-structured transcripts) remains untouched and continues to drive\n// `runBulkImportCliCommand`. Importer adapters are the higher-level surface\n// intended for the four memory sources in #568 — they emit *memories*\n// (intent-level content) rather than raw conversation turns.\n\nimport { validateImportTurn, type ImportTurn } from \"../bulk-import/types.js\";\n\n/**\n * A single imported memory record with provenance.\n *\n * Every importer MUST attach a truthful `sourceLabel` (e.g. `\"chatgpt\"`,\n * `\"claude\"`, `\"gemini\"`, `\"mem0\"`) and MAY attach the export's origin path or\n * URL in `importedFromPath`. `importedAt` is always set by `runImporter` so\n * adapters do not need to timestamp records themselves.\n */\nexport interface ImportedMemory {\n  /**\n   * The user-facing memory content. This is the string that will eventually\n   * land in the memory store (after extraction / orchestrator processing).\n   */\n  content: string;\n  /**\n   * Source-specific identifier for idempotent re-imports. Optional — when\n   * present, adapters SHOULD use the source's stable id (e.g. ChatGPT memory\n   * uuid); when absent, the orchestrator's own content hashing provides dedup.\n   */\n  sourceId?: string;\n  /**\n   * Source-specific timestamp at which the memory was originally created or\n   * last updated. ISO 8601. Optional — adapters fall back to `importedAt`\n   * when the source does not expose a creation timestamp.\n   */\n  sourceTimestamp?: string;\n  /**\n   * Human-readable short label identifying the origin platform\n   * (`\"chatgpt\"`, `\"claude\"`, `\"gemini\"`, `\"mem0\"`). Required so the\n   * orchestrator can attribute recalled memories correctly.\n   */\n  sourceLabel: string;\n  /**\n   * Path to the export file the memory was parsed from, OR the endpoint URL\n   * for API-based imports. Optional but strongly recommended so users can\n   * trace a memory back to the file they imported.\n   */\n  importedFromPath?: string;\n  /**\n   * ISO 8601 timestamp set by `runImporter` immediately before writeTo().\n   * Adapters MAY populate this themselves; `runImporter` will fill in the\n   * current wall-clock time when absent.\n   */\n  importedAt?: string;\n  /**\n   * Adapter-specific raw metadata preserved for debugging / future rehydration\n   * (e.g. conversation id, thread id, tags). Must be JSON-serializable;\n   * adapters MUST NOT stash functions or circular references here.\n   */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Options threaded through every importer run. Adapters receive this object\n * from `runImporter`; the top-level CLI populates it from `--dry-run`,\n * `--batch-size`, and `--rate-limit` flags.\n */\nexport interface RunImportOptions {\n  /**\n   * When true, parse + transform but skip writeTo(). `runImporter` prints a\n   * summary of what WOULD have been imported and returns early.\n   */\n  dryRun?: boolean;\n  /**\n   * Target batch size for writeTo(). Adapters that chunk memories into\n   * smaller orchestrator calls should honor this. Defaults to\n   * `DEFAULT_IMPORT_BATCH_SIZE` when undefined. Values outside the valid\n   * range throw from `validateImportBatchSize`.\n   */\n  batchSize?: number;\n  /**\n   * Optional rate limit for API-backed importers (mem0). Expressed as\n   * requests-per-second. Adapters that do not hit an external API may ignore\n   * this. When provided, `validateImportRateLimit` enforces the positive-\n   * finite contract.\n   */\n  rateLimit?: number;\n  /**\n   * Invoked after every chunk of memories is processed. `total` is the full\n   * count of memories produced by `transform`; `processed` counts memories\n   * already ingested (or skipped in dry-run mode). Adapters SHOULD call this\n   * incrementally — `runImporter` itself calls it once per batch.\n   */\n  onProgress?: (progress: ImportProgress) => void;\n}\n\nexport interface ImportProgress {\n  processed: number;\n  total: number;\n  /** Current phase for human-readable logging. */\n  phase: \"parse\" | \"transform\" | \"write\" | \"dry-run\";\n}\n\n/**\n * Interface every importer package implements.\n *\n * The three-method surface intentionally mirrors the issue #568 spec:\n *\n *   - `parse(input)`: raw payload → intermediate representation.\n *   - `transform(parsed)`: intermediate representation → `ImportedMemory[]`.\n *   - `writeTo(target, memories, options)`: actually commit to the\n *     orchestrator (or whatever target the host provides).\n *\n * Adapters MAY keep `parse` and `transform` separate (e.g. ChatGPT conversions\n * that need to split saved-memories from conversation summaries) or collapse\n * them into a single operation — what matters is that the combined pipeline\n * produces an array of `ImportedMemory` records with correct provenance.\n *\n * `Parsed` is generic so strongly-typed intermediate shapes survive through\n * the adapter's own code without leaking to callers of `runImporter`.\n */\nexport interface ImporterAdapter<Parsed = unknown> {\n  /** Short stable name used by `remnic import --adapter <name>`. */\n  name: string;\n  /** Human-readable label surfaced in CLI output and source attribution. */\n  sourceLabel: string;\n\n  /**\n   * Parse a raw payload (file contents, API response, etc.) into the adapter\n   * intermediate representation. Pure — MUST NOT call the orchestrator.\n   */\n  parse(input: unknown, options?: ImporterParseOptions): Parsed | Promise<Parsed>;\n\n  /**\n   * Flatten parsed input into an array of importable memories. Pure — MUST\n   * NOT call the orchestrator. Provenance fields (`sourceLabel`,\n   * `importedFromPath`) should be populated here.\n   */\n  transform(parsed: Parsed, options?: ImporterTransformOptions): ImportedMemory[] | Promise<ImportedMemory[]>;\n\n  /**\n   * Commit the transformed memories to the orchestrator (or equivalent\n   * target). `runImporter` only invokes this when dryRun is false.\n   *\n   * Adapters typically call `orchestrator.ingestBulkImportBatch` once per\n   * batch after converting `ImportedMemory` records into `ImportTurn` shapes.\n   */\n  writeTo(\n    target: ImporterWriteTarget,\n    memories: ImportedMemory[],\n    options: RunImportOptions,\n  ): Promise<ImporterWriteResult>;\n}\n\n/**\n * Shape of the \"target\" passed to `writeTo`.\n *\n * This is intentionally narrower than the full `Orchestrator` class: importer\n * adapters only need to push `ImportTurn[]` batches and read the active\n * bulk-import namespace. Narrowing keeps test doubles simple (the slice-1\n * integration test uses a pure in-memory mock) and prevents adapters from\n * reaching into orchestrator internals that would make them harder to move\n * between host environments.\n */\nexport interface ImporterWriteTarget {\n  ingestBulkImportBatch(\n    turns: ImportTurn[],\n    options?: { deadlineMs?: number },\n  ): Promise<unknown>;\n  bulkImportWriteNamespace?(): string;\n}\n\nexport interface ImporterWriteResult {\n  memoriesIngested: number;\n  /** Optional: adapter-surfaced duplicates or skipped entries. */\n  skipped?: number;\n}\n\n/** Options forwarded to `parse`. Adapter-specific; additive by design. */\nexport interface ImporterParseOptions {\n  strict?: boolean;\n  /** Source path passed through for provenance. */\n  filePath?: string;\n  /**\n   * Requests-per-second throttle, forwarded from the top-level\n   * `RunImportOptions.rateLimit`. Only meaningful for API-backed importers\n   * (mem0) — file-based adapters ignore it. `runImporter` copies this\n   * through automatically so CLI users never have to stash it on\n   * `parseOptions` themselves. Cursor review on PR #602.\n   */\n  rateLimit?: number;\n}\n\n/** Options forwarded to `transform`. */\nexport interface ImporterTransformOptions {\n  /** When true, adapters that normally skip bulk conversations should include them. */\n  includeConversations?: boolean;\n  /** Maximum number of memories to emit. Primarily for tests. */\n  maxMemories?: number;\n  /** Adapter-specific minimum source text length for importers that filter tiny prompts. */\n  minPromptLength?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Validation helpers\n// ---------------------------------------------------------------------------\n\nexport const DEFAULT_IMPORT_BATCH_SIZE = 25;\nconst MIN_IMPORT_BATCH_SIZE = 1;\nconst MAX_IMPORT_BATCH_SIZE = 500;\n\n/**\n * Coerce and validate the caller-supplied batch size. CLAUDE.md rule 14/51:\n * reject invalid CLI input rather than silently defaulting.\n */\nexport function validateImportBatchSize(value: number | undefined): number {\n  if (value === undefined) return DEFAULT_IMPORT_BATCH_SIZE;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\n      `batchSize must be a finite number, received ${String(value)}`,\n    );\n  }\n  if (!Number.isInteger(value)) {\n    throw new Error(`batchSize must be an integer, received ${value}`);\n  }\n  if (value < MIN_IMPORT_BATCH_SIZE || value > MAX_IMPORT_BATCH_SIZE) {\n    throw new Error(\n      `batchSize must be between ${MIN_IMPORT_BATCH_SIZE} and ${MAX_IMPORT_BATCH_SIZE}, ` +\n        `received ${value}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Validate the `--rate-limit` (requests per second) value used by API\n * importers. Zero / negative / non-finite values throw — the CLI must reject\n * them rather than silently import at unlimited speed.\n */\nexport function validateImportRateLimit(value: number | undefined): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\n      `rateLimit must be a finite number (requests per second), received ${String(value)}`,\n    );\n  }\n  if (value <= 0) {\n    throw new Error(\n      `rateLimit must be greater than 0 (requests per second), received ${value}`,\n    );\n  }\n  return value;\n}\n\n// ---------------------------------------------------------------------------\n// Orchestration helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Convert an `ImportedMemory` into an `ImportTurn` suitable for\n * `orchestrator.ingestBulkImportBatch`. The resulting turn is always\n * `role=\"user\"` because every downstream source (saved memories, personal\n * context, mem0 entries) represents a first-person statement rather than an\n * assistant response.\n *\n * Keeps provenance on the turn via `participantName` so the extraction\n * pipeline's transcript renderer labels the speaker with the source platform.\n */\nexport function importedMemoryToTurn(memory: ImportedMemory): ImportTurn {\n  const timestamp =\n    typeof memory.sourceTimestamp === \"string\" && memory.sourceTimestamp.length > 0\n      ? memory.sourceTimestamp\n      : (memory.importedAt ?? new Date().toISOString());\n  return {\n    role: \"user\",\n    content: memory.content,\n    timestamp,\n    participantName: memory.sourceLabel,\n    ...(memory.sourceId !== undefined ? { participantId: memory.sourceId } : {}),\n    importProvenance: {\n      sourceLabel: memory.sourceLabel,\n      ...(memory.sourceId !== undefined ? { sourceId: memory.sourceId } : {}),\n      ...(memory.sourceTimestamp !== undefined ? { sourceTimestamp: memory.sourceTimestamp } : {}),\n      ...(memory.importedFromPath !== undefined ? { importedFromPath: memory.importedFromPath } : {}),\n      ...(memory.importedAt !== undefined ? { importedAt: memory.importedAt } : {}),\n      ...(memory.metadata !== undefined ? { metadata: memory.metadata } : {}),\n    },\n  };\n}\n\nfunction invalidImportedMemoryError(\n  adapterName: string,\n  index: number,\n  issues: string[],\n): Error {\n  return new Error(\n    `Importer '${adapterName}' produced invalid memory at index ${index}: ${issues.join(\"; \")}`,\n  );\n}\n\nfunction validateImportedMemory(\n  memory: ImportedMemory,\n  adapterName: string,\n  index: number,\n): void {\n  const issues: string[] = [];\n  if (typeof memory.sourceLabel !== \"string\" || memory.sourceLabel.trim().length === 0) {\n    issues.push(\"sourceLabel must be a non-empty string\");\n  }\n  issues.push(\n    ...validateImportTurn(importedMemoryToTurn(memory), index).map(\n      (issue) => issue.message,\n    ),\n  );\n  if (issues.length > 0) {\n    throw invalidImportedMemoryError(adapterName, index, issues);\n  }\n}\n\nexport interface RunImporterResult {\n  adapter: string;\n  sourceLabel: string;\n  /**\n   * Total memories produced by `transform`. In dry-run mode this is the same\n   * as the number of memories that WOULD have been written.\n   */\n  memoriesPlanned: number;\n  /**\n   * Number of memories actually handed to writeTo(). Always zero in dry-run\n   * mode.\n   */\n  memoriesWritten: number;\n  batchesProcessed: number;\n  dryRun: boolean;\n  /** Mirrors the importedAt stamped on every memory. */\n  importedAt: string;\n}\n\n/**\n * Orchestrate `parse → transform → writeTo` for an adapter. This is the\n * default pipeline used by the CLI; adapters are free to implement their own\n * orchestration when they need per-record rate-limiting or streaming parses\n * that would not fit in the \"produce full array before writing\" shape.\n *\n * Mutates the supplied memory records by filling in `importedAt` when the\n * adapter did not set it (CLAUDE.md rule 38: records are written in insertion\n * order to keep the provenance log stable).\n */\nexport async function runImporter<Parsed>(\n  adapter: ImporterAdapter<Parsed>,\n  input: unknown,\n  target: ImporterWriteTarget,\n  options: RunImportOptions & {\n    parseOptions?: ImporterParseOptions;\n    transformOptions?: ImporterTransformOptions;\n  } = {},\n): Promise<RunImporterResult> {\n  const batchSize = validateImportBatchSize(options.batchSize);\n  validateImportRateLimit(options.rateLimit);\n\n  const importedAt = new Date().toISOString();\n  const dryRun = options.dryRun === true;\n  const onProgress = options.onProgress;\n\n  // Phase 1 — parse. Forward the validated rateLimit so API-backed adapters\n  // (mem0) can throttle their own fetches. Caller-supplied parseOptions\n  // takes precedence so tests can still override.\n  onProgress?.({ processed: 0, total: 0, phase: \"parse\" });\n  const parseOptions: ImporterParseOptions = {\n    ...(options.rateLimit !== undefined ? { rateLimit: options.rateLimit } : {}),\n    ...(options.parseOptions ?? {}),\n  };\n  const parsed = await adapter.parse(input, parseOptions);\n\n  // Phase 2 — transform\n  onProgress?.({ processed: 0, total: 0, phase: \"transform\" });\n  const memoriesRaw = await adapter.transform(parsed, options.transformOptions);\n  if (!Array.isArray(memoriesRaw)) {\n    throw new Error(\n      `Importer '${adapter.name}' transform() returned a non-array. ` +\n        \"Adapters must produce ImportedMemory[].\",\n    );\n  }\n  const memories = memoriesRaw.map((memory, index) => {\n    if (memory === null || typeof memory !== \"object\") {\n      throw invalidImportedMemoryError(adapter.name, index, [\n        \"memory must be an object\",\n      ]);\n    }\n    const record = memory as ImportedMemory;\n    const sourceLabel =\n      typeof record.sourceLabel === \"string\" && record.sourceLabel.trim().length > 0\n        ? record.sourceLabel.trim()\n        : adapter.sourceLabel.trim();\n    return {\n      ...record,\n      sourceLabel,\n      importedAt: record.importedAt ?? importedAt,\n    };\n  });\n  memories.forEach((memory, index) => validateImportedMemory(memory, adapter.name, index));\n\n  // Phase 3 — write (or dry-run plan)\n  if (dryRun) {\n    onProgress?.({\n      processed: memories.length,\n      total: memories.length,\n      phase: \"dry-run\",\n    });\n    return {\n      adapter: adapter.name,\n      sourceLabel: adapter.sourceLabel,\n      memoriesPlanned: memories.length,\n      memoriesWritten: 0,\n      batchesProcessed: 0,\n      dryRun: true,\n      importedAt,\n    };\n  }\n\n  let batchesProcessed = 0;\n  let memoriesWritten = 0;\n  for (let i = 0; i < memories.length; i += batchSize) {\n    const batch = memories.slice(i, i + batchSize);\n    const result = await adapter.writeTo(target, batch, options);\n    memoriesWritten += result.memoriesIngested;\n    batchesProcessed += 1;\n    onProgress?.({\n      processed: Math.min(i + batch.length, memories.length),\n      total: memories.length,\n      phase: \"write\",\n    });\n  }\n\n  return {\n    adapter: adapter.name,\n    sourceLabel: adapter.sourceLabel,\n    memoriesPlanned: memories.length,\n    memoriesWritten,\n    batchesProcessed,\n    dryRun: false,\n    importedAt,\n  };\n}\n\n/**\n * Default `writeTo` implementation for importers that want to hand every\n * memory to `orchestrator.ingestBulkImportBatch` without custom routing.\n * Adapters that need per-record rate-limiting or conversation-thread linking\n * are free to implement their own `writeTo`.\n */\nexport async function defaultWriteMemoriesToOrchestrator(\n  target: ImporterWriteTarget,\n  memories: ImportedMemory[],\n): Promise<ImporterWriteResult> {\n  if (memories.length === 0) {\n    return { memoriesIngested: 0 };\n  }\n  memories.forEach((memory, index) =>\n    validateImportedMemory(memory, \"defaultWriteMemoriesToOrchestrator\", index),\n  );\n  const turns = memories.map(importedMemoryToTurn);\n  await target.ingestBulkImportBatch(turns);\n  return { memoriesIngested: memories.length };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/importers/base.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// Shared importer base (issue #568)\n// ---------------------------------------------------------------------------\n//\n// The importer adapters defined by issue #568 (`@remnic/import-chatgpt`,\n// `@remnic/import-claude`, `@remnic/import-gemini`, `@remnic/import-mem0`) all\n// follow the same three-step shape:\n//\n//   1. parse(input)          — turn a raw file / API payload into a\n//                              source-specific intermediate structure.\n//   2. transform(parsed)     — flatten that structure into a uniform list of\n//                              `ImportedMemory` records with provenance\n//                              attached (sourceLabel, importedFromPath,\n//                              importedAt).\n//   3. writeTo(orchestrator) — hand each memory to the orchestrator via\n//                              `ingestBulkImportBatch`. Dry-run mode stops\n//                              after transform() and never calls writeTo().\n//\n// This file defines the shared `ImporterAdapter` interface plus a thin\n// `runImporter` helper that handles batching, dry-run plan reporting, and\n// progress callbacks so every adapter does not reimplement the same loop.\n//\n// The existing lower-level `BulkImportSourceAdapter` (weclone-shaped: produces\n// turn-structured transcripts) remains untouched and continues to drive\n// `runBulkImportCliCommand`. Importer adapters are the higher-level surface\n// intended for the four memory sources in #568 — they emit *memories*\n// (intent-level content) rather than raw conversation turns.\n\nimport { validateImportTurn, type ImportTurn } from \"../bulk-import/types.js\";\n\n/**\n * A single imported memory record with provenance.\n *\n * Every importer MUST attach a truthful `sourceLabel` (e.g. `\"chatgpt\"`,\n * `\"claude\"`, `\"gemini\"`, `\"mem0\"`) and MAY attach the export's origin path or\n * URL in `importedFromPath`. `importedAt` is always set by `runImporter` so\n * adapters do not need to timestamp records themselves.\n */\nexport interface ImportedMemory {\n  /**\n   * The user-facing memory content. This is the string that will eventually\n   * land in the memory store (after extraction / orchestrator processing).\n   */\n  content: string;\n  /**\n   * Source-specific identifier for idempotent re-imports. Optional — when\n   * present, adapters SHOULD use the source's stable id (e.g. ChatGPT memory\n   * uuid); when absent, the orchestrator's own content hashing provides dedup.\n   */\n  sourceId?: string;\n  /**\n   * Source-specific timestamp at which the memory was originally created or\n   * last updated. ISO 8601. Optional — adapters fall back to `importedAt`\n   * when the source does not expose a creation timestamp.\n   */\n  sourceTimestamp?: string;\n  /**\n   * Human-readable short label identifying the origin platform\n   * (`\"chatgpt\"`, `\"claude\"`, `\"gemini\"`, `\"mem0\"`). Required so the\n   * orchestrator can attribute recalled memories correctly.\n   */\n  sourceLabel: string;\n  /**\n   * Path to the export file the memory was parsed from, OR the endpoint URL\n   * for API-based imports. Optional but strongly recommended so users can\n   * trace a memory back to the file they imported.\n   */\n  importedFromPath?: string;\n  /**\n   * ISO 8601 timestamp set by `runImporter` immediately before writeTo().\n   * Adapters MAY populate this themselves; `runImporter` will fill in the\n   * current wall-clock time when absent.\n   */\n  importedAt?: string;\n  /**\n   * Adapter-specific raw metadata preserved for debugging / future rehydration\n   * (e.g. conversation id, thread id, tags). Must be JSON-serializable;\n   * adapters MUST NOT stash functions or circular references here.\n   */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Options threaded through every importer run. Adapters receive this object\n * from `runImporter`; the top-level CLI populates it from `--dry-run`,\n * `--batch-size`, and `--rate-limit` flags.\n */\nexport interface RunImportOptions {\n  /**\n   * When true, parse + transform but skip writeTo(). `runImporter` prints a\n   * summary of what WOULD have been imported and returns early.\n   */\n  dryRun?: boolean;\n  /**\n   * Target batch size for writeTo(). Adapters that chunk memories into\n   * smaller orchestrator calls should honor this. Defaults to\n   * `DEFAULT_IMPORT_BATCH_SIZE` when undefined. Values outside the valid\n   * range throw from `validateImportBatchSize`.\n   */\n  batchSize?: number;\n  /**\n   * Optional rate limit for API-backed importers (mem0). Expressed as\n   * requests-per-second. Adapters that do not hit an external API may ignore\n   * this. When provided, `validateImportRateLimit` enforces the positive-\n   * finite contract.\n   */\n  rateLimit?: number;\n  /**\n   * Invoked after every chunk of memories is processed. `total` is the full\n   * count of memories produced by `transform`; `processed` counts memories\n   * already ingested (or skipped in dry-run mode). Adapters SHOULD call this\n   * incrementally — `runImporter` itself calls it once per batch.\n   */\n  onProgress?: (progress: ImportProgress) => void;\n}\n\nexport interface ImportProgress {\n  processed: number;\n  total: number;\n  /** Current phase for human-readable logging. */\n  phase: \"parse\" | \"transform\" | \"write\" | \"dry-run\";\n}\n\n/**\n * Interface every importer package implements.\n *\n * The three-method surface intentionally mirrors the issue #568 spec:\n *\n *   - `parse(input)`: raw payload → intermediate representation.\n *   - `transform(parsed)`: intermediate representation → `ImportedMemory[]`.\n *   - `writeTo(target, memories, options)`: actually commit to the\n *     orchestrator (or whatever target the host provides).\n *\n * Adapters MAY keep `parse` and `transform` separate (e.g. ChatGPT conversions\n * that need to split saved-memories from conversation summaries) or collapse\n * them into a single operation — what matters is that the combined pipeline\n * produces an array of `ImportedMemory` records with correct provenance.\n *\n * `Parsed` is generic so strongly-typed intermediate shapes survive through\n * the adapter's own code without leaking to callers of `runImporter`.\n */\nexport interface ImporterAdapter<Parsed = unknown> {\n  /** Short stable name used by `remnic import --adapter <name>`. */\n  name: string;\n  /** Human-readable label surfaced in CLI output and source attribution. */\n  sourceLabel: string;\n\n  /**\n   * Parse a raw payload (file contents, API response, etc.) into the adapter\n   * intermediate representation. Pure — MUST NOT call the orchestrator.\n   */\n  parse(input: unknown, options?: ImporterParseOptions): Parsed | Promise<Parsed>;\n\n  /**\n   * Flatten parsed input into an array of importable memories. Pure — MUST\n   * NOT call the orchestrator. Provenance fields (`sourceLabel`,\n   * `importedFromPath`) should be populated here.\n   */\n  transform(parsed: Parsed, options?: ImporterTransformOptions): ImportedMemory[] | Promise<ImportedMemory[]>;\n\n  /**\n   * Commit the transformed memories to the orchestrator (or equivalent\n   * target). `runImporter` only invokes this when dryRun is false.\n   *\n   * Adapters typically call `orchestrator.ingestBulkImportBatch` once per\n   * batch after converting `ImportedMemory` records into `ImportTurn` shapes.\n   */\n  writeTo(\n    target: ImporterWriteTarget,\n    memories: ImportedMemory[],\n    options: RunImportOptions,\n  ): Promise<ImporterWriteResult>;\n}\n\n/**\n * Shape of the \"target\" passed to `writeTo`.\n *\n * This is intentionally narrower than the full `Orchestrator` class: importer\n * adapters only need to push `ImportTurn[]` batches and read the active\n * bulk-import namespace. Narrowing keeps test doubles simple (the slice-1\n * integration test uses a pure in-memory mock) and prevents adapters from\n * reaching into orchestrator internals that would make them harder to move\n * between host environments.\n */\nexport interface ImporterWriteTarget {\n  ingestBulkImportBatch(\n    turns: ImportTurn[],\n    options?: { deadlineMs?: number },\n  ): Promise<unknown>;\n  bulkImportWriteNamespace?(): string;\n}\n\nexport interface ImporterWriteResult {\n  memoriesIngested: number;\n  /** Optional: adapter-surfaced duplicates or skipped entries. */\n  skipped?: number;\n}\n\n/** Options forwarded to `parse`. Adapter-specific; additive by design. */\nexport interface ImporterParseOptions {\n  strict?: boolean;\n  /** Source path passed through for provenance. */\n  filePath?: string;\n  /**\n   * Requests-per-second throttle, forwarded from the top-level\n   * `RunImportOptions.rateLimit`. Only meaningful for API-backed importers\n   * (mem0) — file-based adapters ignore it. `runImporter` copies this\n   * through automatically so CLI users never have to stash it on\n   * `parseOptions` themselves. Cursor review on PR #602.\n   */\n  rateLimit?: number;\n}\n\n/** Options forwarded to `transform`. */\nexport interface ImporterTransformOptions {\n  /** When true, adapters that normally skip bulk conversations should include them. */\n  includeConversations?: boolean;\n  /** Maximum number of memories to emit. Primarily for tests. */\n  maxMemories?: number;\n  /** Adapter-specific minimum source text length for importers that filter tiny prompts. */\n  minPromptLength?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Validation helpers\n// ---------------------------------------------------------------------------\n\nexport const DEFAULT_IMPORT_BATCH_SIZE = 25;\nconst MIN_IMPORT_BATCH_SIZE = 1;\nconst MAX_IMPORT_BATCH_SIZE = 500;\n\n/**\n * Coerce and validate the caller-supplied batch size. CLAUDE.md rule 14/51:\n * reject invalid CLI input rather than silently defaulting.\n */\nexport function validateImportBatchSize(value: number | undefined): number {\n  if (value === undefined) return DEFAULT_IMPORT_BATCH_SIZE;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\n      `batchSize must be a finite number, received ${String(value)}`,\n    );\n  }\n  if (!Number.isInteger(value)) {\n    throw new Error(`batchSize must be an integer, received ${value}`);\n  }\n  if (value < MIN_IMPORT_BATCH_SIZE || value > MAX_IMPORT_BATCH_SIZE) {\n    throw new Error(\n      `batchSize must be between ${MIN_IMPORT_BATCH_SIZE} and ${MAX_IMPORT_BATCH_SIZE}, ` +\n        `received ${value}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Validate the `--rate-limit` (requests per second) value used by API\n * importers. Zero / negative / non-finite values throw — the CLI must reject\n * them rather than silently import at unlimited speed.\n */\nexport function validateImportRateLimit(value: number | undefined): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\n      `rateLimit must be a finite number (requests per second), received ${String(value)}`,\n    );\n  }\n  if (value <= 0) {\n    throw new Error(\n      `rateLimit must be greater than 0 (requests per second), received ${value}`,\n    );\n  }\n  return value;\n}\n\n// ---------------------------------------------------------------------------\n// Orchestration helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Convert an `ImportedMemory` into an `ImportTurn` suitable for\n * `orchestrator.ingestBulkImportBatch`. The resulting turn is always\n * `role=\"user\"` because every downstream source (saved memories, personal\n * context, mem0 entries) represents a first-person statement rather than an\n * assistant response.\n *\n * Keeps provenance on the turn via `participantName` so the extraction\n * pipeline's transcript renderer labels the speaker with the source platform.\n */\nexport function importedMemoryToTurn(memory: ImportedMemory): ImportTurn {\n  const timestamp =\n    typeof memory.sourceTimestamp === \"string\" && memory.sourceTimestamp.length > 0\n      ? memory.sourceTimestamp\n      : (memory.importedAt ?? new Date().toISOString());\n  return {\n    role: \"user\",\n    content: memory.content,\n    timestamp,\n    participantName: memory.sourceLabel,\n    ...(memory.sourceId !== undefined ? { participantId: memory.sourceId } : {}),\n    importProvenance: {\n      sourceLabel: memory.sourceLabel,\n      ...(memory.sourceId !== undefined ? { sourceId: memory.sourceId } : {}),\n      ...(memory.sourceTimestamp !== undefined ? { sourceTimestamp: memory.sourceTimestamp } : {}),\n      ...(memory.importedFromPath !== undefined ? { importedFromPath: memory.importedFromPath } : {}),\n      ...(memory.importedAt !== undefined ? { importedAt: memory.importedAt } : {}),\n      ...(memory.metadata !== undefined ? { metadata: memory.metadata } : {}),\n    },\n  };\n}\n\nfunction invalidImportedMemoryError(\n  adapterName: string,\n  index: number,\n  issues: string[],\n): Error {\n  return new Error(\n    `Importer '${adapterName}' produced invalid memory at index ${index}: ${issues.join(\"; \")}`,\n  );\n}\n\nfunction validateImportedMemory(\n  memory: ImportedMemory,\n  adapterName: string,\n  index: number,\n): void {\n  const issues: string[] = [];\n  if (typeof memory.sourceLabel !== \"string\" || memory.sourceLabel.trim().length === 0) {\n    issues.push(\"sourceLabel must be a non-empty string\");\n  }\n  issues.push(\n    ...validateImportTurn(importedMemoryToTurn(memory), index).map(\n      (issue) => issue.message,\n    ),\n  );\n  if (issues.length > 0) {\n    throw invalidImportedMemoryError(adapterName, index, issues);\n  }\n}\n\nexport interface RunImporterResult {\n  adapter: string;\n  sourceLabel: string;\n  /**\n   * Total memories produced by `transform`. In dry-run mode this is the same\n   * as the number of memories that WOULD have been written.\n   */\n  memoriesPlanned: number;\n  /**\n   * Number of memories actually handed to writeTo(). Always zero in dry-run\n   * mode.\n   */\n  memoriesWritten: number;\n  batchesProcessed: number;\n  dryRun: boolean;\n  /** Mirrors the importedAt stamped on every memory. */\n  importedAt: string;\n}\n\n/**\n * Orchestrate `parse → transform → writeTo` for an adapter. This is the\n * default pipeline used by the CLI; adapters are free to implement their own\n * orchestration when they need per-record rate-limiting or streaming parses\n * that would not fit in the \"produce full array before writing\" shape.\n *\n * Mutates the supplied memory records by filling in `importedAt` when the\n * adapter did not set it (CLAUDE.md rule 38: records are written in insertion\n * order to keep the provenance log stable).\n */\nexport async function runImporter<Parsed>(\n  adapter: ImporterAdapter<Parsed>,\n  input: unknown,\n  target: ImporterWriteTarget,\n  options: RunImportOptions & {\n    parseOptions?: ImporterParseOptions;\n    transformOptions?: ImporterTransformOptions;\n  } = {},\n): Promise<RunImporterResult> {\n  const batchSize = validateImportBatchSize(options.batchSize);\n  validateImportRateLimit(options.rateLimit);\n\n  const importedAt = new Date().toISOString();\n  const dryRun = options.dryRun === true;\n  const onProgress = options.onProgress;\n\n  // Phase 1 — parse. Forward the validated rateLimit so API-backed adapters\n  // (mem0) can throttle their own fetches. Caller-supplied parseOptions\n  // takes precedence so tests can still override.\n  onProgress?.({ processed: 0, total: 0, phase: \"parse\" });\n  const parseOptions: ImporterParseOptions = {\n    ...(options.rateLimit !== undefined ? { rateLimit: options.rateLimit } : {}),\n    ...(options.parseOptions ?? {}),\n  };\n  const parsed = await adapter.parse(input, parseOptions);\n\n  // Phase 2 — transform\n  onProgress?.({ processed: 0, total: 0, phase: \"transform\" });\n  const memoriesRaw = await adapter.transform(parsed, options.transformOptions);\n  if (!Array.isArray(memoriesRaw)) {\n    throw new Error(\n      `Importer '${adapter.name}' transform() returned a non-array. ` +\n        \"Adapters must produce ImportedMemory[].\",\n    );\n  }\n  const memories = memoriesRaw.map((memory, index) => {\n    if (memory === null || typeof memory !== \"object\") {\n      throw invalidImportedMemoryError(adapter.name, index, [\n        \"memory must be an object\",\n      ]);\n    }\n    const record = memory as ImportedMemory;\n    const sourceLabel =\n      typeof record.sourceLabel === \"string\" && record.sourceLabel.trim().length > 0\n        ? record.sourceLabel.trim()\n        : adapter.sourceLabel.trim();\n    return {\n      ...record,\n      sourceLabel,\n      importedAt: record.importedAt ?? importedAt,\n    };\n  });\n  memories.forEach((memory, index) => validateImportedMemory(memory, adapter.name, index));\n\n  // Phase 3 — write (or dry-run plan)\n  if (dryRun) {\n    onProgress?.({\n      processed: memories.length,\n      total: memories.length,\n      phase: \"dry-run\",\n    });\n    return {\n      adapter: adapter.name,\n      sourceLabel: adapter.sourceLabel,\n      memoriesPlanned: memories.length,\n      memoriesWritten: 0,\n      batchesProcessed: 0,\n      dryRun: true,\n      importedAt,\n    };\n  }\n\n  let batchesProcessed = 0;\n  let memoriesWritten = 0;\n  for (let i = 0; i < memories.length; i += batchSize) {\n    const batch = memories.slice(i, i + batchSize);\n    const result = await adapter.writeTo(target, batch, options);\n    memoriesWritten += result.memoriesIngested;\n    batchesProcessed += 1;\n    onProgress?.({\n      processed: Math.min(i + batch.length, memories.length),\n      total: memories.length,\n      phase: \"write\",\n    });\n  }\n\n  return {\n    adapter: adapter.name,\n    sourceLabel: adapter.sourceLabel,\n    memoriesPlanned: memories.length,\n    memoriesWritten,\n    batchesProcessed,\n    dryRun: false,\n    importedAt,\n  };\n}\n\n/**\n * Default `writeTo` implementation for importers that want to hand every\n * memory to `orchestrator.ingestBulkImportBatch` without custom routing.\n * Adapters that need per-record rate-limiting or conversation-thread linking\n * are free to implement their own `writeTo`.\n */\nexport async function defaultWriteMemoriesToOrchestrator(\n  target: ImporterWriteTarget,\n  memories: ImportedMemory[],\n): Promise<ImporterWriteResult> {\n  if (memories.length === 0) {\n    return { memoriesIngested: 0 };\n  }\n  memories.forEach((memory, index) =>\n    validateImportedMemory(memory, \"defaultWriteMemoriesToOrchestrator\", index),\n  );\n  const turns = memories.map(importedMemoryToTurn);\n  await target.ingestBulkImportBatch(turns);\n  return { memoriesIngested: memories.length };\n}\n\n// ---------------------------------------------------------------------------\n// File-importer factory (issue #2794)\n// ---------------------------------------------------------------------------\n\n/** Parse args `defineFileImporterAdapter` forwards — the keys file adapters use. */\nexport interface FileImporterParseArgs {\n  strict?: boolean;\n  filePath?: string;\n}\n\n/** Per-package config consumed by `defineFileImporterAdapter`. */\nexport interface FileImporterDefinition<Parsed> {\n  name: string;\n  sourceLabel: string;\n  /** Decode the raw export file. Receives only `strict` / `filePath`. */\n  parse(input: unknown, options: FileImporterParseArgs): Parsed | Promise<Parsed>;\n  /** Flatten the parsed export into `ImportedMemory[]` with provenance. */\n  transform(\n    parsed: Parsed,\n    options: ImporterTransformOptions | undefined,\n  ): ImportedMemory[] | Promise<ImportedMemory[]>;\n}\n\n/**\n * Build the standard file-importer `ImporterAdapter`: parse with the\n * `strict`/`filePath` spread, a package-specific `transform`, and `writeTo`\n * delegating to `defaultWriteMemoriesToOrchestrator` (issue #2794).\n */\nexport function defineFileImporterAdapter<Parsed>(\n  definition: FileImporterDefinition<Parsed>,\n): ImporterAdapter<Parsed> {\n  return {\n    name: definition.name,\n    sourceLabel: definition.sourceLabel,\n    parse(input, options) {\n      return definition.parse(input, {\n        ...(options?.strict !== undefined ? { strict: options.strict } : {}),\n        ...(options?.filePath !== undefined ? { filePath: options.filePath } : {}),\n      });\n    },\n    transform: (parsed, options) => definition.transform(parsed, options),\n    writeTo: defaultWriteMemoriesToOrchestrator,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-SV4Z2S67.js → chunk-S5G2LAL7.js}

@@ -1,12 +1,12 @@
+import {
+  rankDeepRecallFrontier
+} from "./chunk-HRATODNO.js";
 import {
   validateRefineRewrite
 } from "./chunk-WTWQA7BB.js";
 import {
   selectExpandNodeIds
 } from "./chunk-VZIAVM72.js";
-import {
-  rankDeepRecallFrontier
-} from "./chunk-HRATODNO.js";
 import {
   extractJsonCandidates,
   stripCodeFences
@@ -351,4 +351,4 @@ async function runBudgetedDeepRecall(deps, query) {
 export {
   runBudgetedDeepRecall
 };
-//# sourceMappingURL=chunk-SV4Z2S67.js.map
+//# sourceMappingURL=chunk-S5G2LAL7.js.map

package/dist/{chunk-AQ7SYDVO.js → chunk-S65WXHNK.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-RBCQVOVJ.js";
+} from "./chunk-PV36INNL.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -282,4 +282,4 @@ export {
   computeServiceCorpusWatermarks,
   computeServiceCorpusCensus
 };
-//# sourceMappingURL=chunk-AQ7SYDVO.js.map
+//# sourceMappingURL=chunk-S65WXHNK.js.map

package/dist/{chunk-6XL73HQ4.js → chunk-SB6PSOP7.js}

@@ -318,4 +318,4 @@ export {
   readProjectedHarmonicGraph,
   searchHarmonicRetrieval
 };
-//# sourceMappingURL=chunk-6XL73HQ4.js.map
+//# sourceMappingURL=chunk-SB6PSOP7.js.map

package/dist/{chunk-JALOAKSZ.js → chunk-TLPZ6MKZ.js}

@@ -1,7 +1,7 @@
 import {
   getGatewayRuntimeAuthForModel,
   resolveProviderApiKey
-} from "./chunk-QIEUU4UK.js";
+} from "./chunk-I55KAVET.js";
 import {
   buildChatCompletionTemperature,
   buildChatCompletionTokenLimit,
@@ -18,10 +18,10 @@ import {
 } from "./chunk-N7RWREIQ.js";
 import {
   expandTildePath
-} from "./chunk-EYIEWJNI.js";
+} from "./chunk-6KH5NLQS.js";
 import {
   resolveHomeDir
-} from "./chunk-JUC24CTX.js";
+} from "./chunk-P2QRMMVQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -788,4 +788,4 @@ export {
   fallbackLlmRuntimeContextFromConfig,
   FallbackLlmClient
 };
-//# sourceMappingURL=chunk-JALOAKSZ.js.map
+//# sourceMappingURL=chunk-TLPZ6MKZ.js.map

package/dist/{chunk-XTJC7CVX.js → chunk-TXMAF7FZ.js}

@@ -1,16 +1,16 @@
 import {
   applyExtractionSourceGrounding
-} from "./chunk-HMKPFW7R.js";
+} from "./chunk-MPAJFFP3.js";
 import {
   CONNECTOR_LABEL_MAX_LENGTH,
   knownConnectorIds
-} from "./chunk-3GCK6ONU.js";
+} from "./chunk-HK32G473.js";
 import {
   isValidConnectorId
-} from "./chunk-YSSAGB2O.js";
+} from "./chunk-CLLPJ6QT.js";
 import {
   deriveSourceConnector
-} from "./chunk-FHYVNJBN.js";
+} from "./chunk-VLLEWQIU.js";
 import {
   resolvePipelineProcessingCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -108,4 +108,4 @@ export {
   renderExtractionConversation,
   applyGroundingWithConnector
 };
-//# sourceMappingURL=chunk-XTJC7CVX.js.map
+//# sourceMappingURL=chunk-TXMAF7FZ.js.map

package/dist/{chunk-3NYTZE5G.js → chunk-UFDMVGUQ.js}

@@ -3,7 +3,7 @@ import {
   getOperation,
   operationRequiresAuthorizedNamespace,
   operationUsesPrincipalNamespace
-} from "./chunk-OU4K7IFP.js";
+} from "./chunk-K5DSKAVF.js";
 import {
   assertOperationAuthorizationAllowed
 } from "./chunk-MZWSOLMT.js";
@@ -60,4 +60,4 @@ export {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace
 };
-//# sourceMappingURL=chunk-3NYTZE5G.js.map
+//# sourceMappingURL=chunk-UFDMVGUQ.js.map

package/dist/{chunk-DFEODULB.js → chunk-V2HHAAPI.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-JUOZ62Y7.js";
 import {
   readEnvVar
-} from "./chunk-JUC24CTX.js";
+} from "./chunk-P2QRMMVQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -515,4 +515,4 @@ export {
   EmbeddingProviderUnavailableError,
   EmbeddingFallback
 };
-//# sourceMappingURL=chunk-DFEODULB.js.map
+//# sourceMappingURL=chunk-V2HHAAPI.js.map

package/dist/{chunk-KEF46KL2.js → chunk-V6EGNVUT.js}

@@ -13,11 +13,11 @@ import {
 } from "./chunk-C7HJ3NEI.js";
 import {
   expandTildePath
-} from "./chunk-EYIEWJNI.js";
+} from "./chunk-6KH5NLQS.js";
 import {
   readEnvVar,
   resolveHomeDir
-} from "./chunk-JUC24CTX.js";
+} from "./chunk-P2QRMMVQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -800,4 +800,4 @@ export {
   truncateToTokenBudget,
   describeMemoriesDir
 };
-//# sourceMappingURL=chunk-KEF46KL2.js.map
+//# sourceMappingURL=chunk-V6EGNVUT.js.map

package/dist/{chunk-ESNFSSO4.js → chunk-VGXM5B4H.js}

@@ -15,7 +15,7 @@ import {
 import {
   combineNamespaces,
   stableHash
-} from "./chunk-QBC33MPY.js";
+} from "./chunk-NZXEK3UF.js";
 
 // src/namespaces/scope-profiles.ts
 import { createHash } from "crypto";
@@ -338,4 +338,4 @@ export {
   resolveScopeProfilePlan,
   expandScopeProfileReadNamespaces
 };
-//# sourceMappingURL=chunk-ESNFSSO4.js.map
+//# sourceMappingURL=chunk-VGXM5B4H.js.map

package/dist/{chunk-FHYVNJBN.js → chunk-VLLEWQIU.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-OD4FM2U7.js";
 import {
   parseQmdExplain
-} from "./chunk-CEH2AFXG.js";
+} from "./chunk-DBQWVT2H.js";
 import {
   classifyOrigin
 } from "./chunk-6Q3ZTEF6.js";
@@ -19,7 +19,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   resolveScopeProfilePlan
-} from "./chunk-ESNFSSO4.js";
+} from "./chunk-VGXM5B4H.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -33,7 +33,7 @@ import {
 } from "./chunk-JUOZ62Y7.js";
 import {
   resolveCodingNamespaceOverlay
-} from "./chunk-QBC33MPY.js";
+} from "./chunk-NZXEK3UF.js";
 import {
   abortError,
   throwIfAborted
@@ -1712,4 +1712,4 @@ export {
   ExtractionDeadlineError,
   ExtractionRunCoordinator
 };
-//# sourceMappingURL=chunk-FHYVNJBN.js.map
+//# sourceMappingURL=chunk-VLLEWQIU.js.map

package/dist/{chunk-MJUCDM3C.js → chunk-VLXBE57O.js}

@@ -1,7 +1,7 @@
 import {
   projectTagProjectId,
   resolveGitContext
-} from "./chunk-QBC33MPY.js";
+} from "./chunk-NZXEK3UF.js";
 
 // src/access-coding-context-resolution.ts
 async function resolveCodingContextFromOptions(options) {
@@ -33,4 +33,4 @@ async function resolveCodingContextFromOptions(options) {
 export {
   resolveCodingContextFromOptions
 };
-//# sourceMappingURL=chunk-MJUCDM3C.js.map
+//# sourceMappingURL=chunk-VLXBE57O.js.map

package/dist/{chunk-4TKJGOCJ.js → chunk-VP67GZ7T.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   compareEntityTimestamps
-} from "./chunk-XSGUMQQQ.js";
+} from "./chunk-GVG3JYBI.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -918,4 +918,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-4TKJGOCJ.js.map
+//# sourceMappingURL=chunk-VP67GZ7T.js.map

package/dist/{chunk-RX3SC4C5.js → chunk-VT4MK674.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-OU4K7IFP.js";
+} from "./chunk-K5DSKAVF.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-RX3SC4C5.js.map
+//# sourceMappingURL=chunk-VT4MK674.js.map

package/dist/{chunk-GHTSNGBZ.js → chunk-VZWXFXLX.js}

@@ -1,6 +1,6 @@
 import {
   deepRecallRequestSchema
-} from "./chunk-N3ZOP7KC.js";
+} from "./chunk-JEIXTYVG.js";
 import {
   EngramAccessInputError
 } from "./chunk-2Z24E5W2.js";
@@ -39,4 +39,4 @@ async function respondDeepRecall(req, res, respondJson, readJsonBody, service, s
 export {
   respondDeepRecall
 };
-//# sourceMappingURL=chunk-GHTSNGBZ.js.map
+//# sourceMappingURL=chunk-VZWXFXLX.js.map

package/dist/{chunk-WJHGDE7X.js → chunk-W64HKJJM.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-XSGUMQQQ.js";
+} from "./chunk-GVG3JYBI.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -19,7 +19,7 @@ import {
 import {
   readEnvVar,
   resolveHomeDir
-} from "./chunk-JUC24CTX.js";
+} from "./chunk-P2QRMMVQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -957,4 +957,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-WJHGDE7X.js.map
+//# sourceMappingURL=chunk-W64HKJJM.js.map

package/dist/{chunk-Y2MZGBOY.js → chunk-W7SECYCQ.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-H3FZVNRN.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-FHYVNJBN.js";
+} from "./chunk-VLLEWQIU.js";
 import {
   resolvePrincipal
 } from "./chunk-MRV7VSQK.js";
@@ -798,4 +798,4 @@ var SmartBuffer = class {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-Y2MZGBOY.js.map
+//# sourceMappingURL=chunk-W7SECYCQ.js.map

package/dist/{chunk-2L5FSNPC.js → chunk-X2NFFBTO.js}

@@ -1,3 +1,9 @@
+import {
+  LcmWorkQueue
+} from "./chunk-TPDBFYEG.js";
+import {
+  assembleCompressedHistoryWithTrace
+} from "./chunk-UXPUUL3G.js";
 import {
   ensureLcmStateDir,
   openLcmDatabase
@@ -11,12 +17,6 @@ import {
 import {
   LcmDag
 } from "./chunk-7N4KAIGN.js";
-import {
-  LcmWorkQueue
-} from "./chunk-TPDBFYEG.js";
-import {
-  assembleCompressedHistoryWithTrace
-} from "./chunk-UXPUUL3G.js";
 import {
   nativeBindingRecoveryHint
 } from "./chunk-LD72P4YS.js";
@@ -573,4 +573,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-2L5FSNPC.js.map
+//# sourceMappingURL=chunk-X2NFFBTO.js.map

package/dist/{chunk-DQEMWVMT.js → chunk-X7Y7WX73.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-DQEMWVMT.js.map
+//# sourceMappingURL=chunk-X7Y7WX73.js.map

package/dist/{chunk-EGALNSZ4.js → chunk-XU6OEECT.js}

@@ -1,7 +1,7 @@
 import {
   expandScopeProfileReadNamespaces,
   resolveScopeProfilePlan
-} from "./chunk-ESNFSSO4.js";
+} from "./chunk-VGXM5B4H.js";
 import {
   canReadNamespace,
   canWriteNamespace,
@@ -22,7 +22,7 @@ import {
   combineNamespaces,
   lcmReadSessionIdsForNamespaces,
   resolveCodingNamespaceOverlay
-} from "./chunk-QBC33MPY.js";
+} from "./chunk-NZXEK3UF.js";
 
 // src/scopes/scope-plan.ts
 import path from "path";
@@ -204,4 +204,4 @@ export {
   resolveWritableNamespaceValue,
   resolveScopedWritableNamespaceValue
 };
-//# sourceMappingURL=chunk-EGALNSZ4.js.map
+//# sourceMappingURL=chunk-XU6OEECT.js.map