@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-PU63GXWS.js

@@ -0,0 +1,174 @@
+import {
+  createSearchBackend
+} from "./chunk-6RVI47ZR.js";
+
+// src/namespaces/search.ts
+function namespaceCollectionName(baseCollection, namespace, options) {
+  const trimmed = namespace.trim();
+  const defaultNamespace = options?.defaultNamespace?.trim() || "default";
+  if (options?.useLegacyDefaultCollection === true && trimmed === defaultNamespace) {
+    return baseCollection;
+  }
+  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+  let start = 0;
+  let end = normalized.length;
+  while (start < end && normalized[start] === "-") start += 1;
+  while (end > start && normalized[end - 1] === "-") end -= 1;
+  const token = normalized.slice(start, end) || defaultNamespace;
+  return `${baseCollection}--ns--${token}`;
+}
+var NamespaceSearchRouter = class {
+  constructor(config, storageRouter, createBackend = createSearchBackend) {
+    this.config = config;
+    this.storageRouter = storageRouter;
+    this.createBackend = createBackend;
+  }
+  config;
+  storageRouter;
+  createBackend;
+  cache = /* @__PURE__ */ new Map();
+  async collectionForNamespace(namespace) {
+    return (await this.backendRecordFor(namespace)).collection;
+  }
+  async searchAcrossNamespaces(options) {
+    const query = options.query.trim();
+    if (!query) return [];
+    const maxResults = Math.max(0, Math.floor(options.maxResults ?? this.config.qmdMaxResults));
+    if (maxResults === 0) return [];
+    const method = options.mode ?? "search";
+    const namespaces = Array.from(new Set(options.namespaces.map((value) => value.trim()).filter(Boolean)));
+    if (namespaces.length === 0) return [];
+    const resultsByNamespace = await Promise.all(
+      namespaces.map(async (namespace) => {
+        const record = await this.backendRecordFor(namespace);
+        if (!record.available || record.collectionState === "missing") return [];
+        switch (method) {
+          case "hybrid":
+            return await record.backend.hybridSearch(query, void 0, maxResults, options.execution);
+          case "bm25":
+            return await record.backend.bm25Search(query, void 0, maxResults, options.execution);
+          case "vector":
+            return await record.backend.vectorSearch(query, void 0, maxResults, options.execution);
+          default:
+            return await record.backend.search(
+              query,
+              void 0,
+              maxResults,
+              options.searchOptions,
+              options.execution
+            );
+        }
+      })
+    );
+    return mergeNamespaceSearchResults(resultsByNamespace, maxResults);
+  }
+  /**
+   * Update all namespace backends.
+   * Returns the number of backends for which an update was attempted
+   * (i.e., available and collection present).  Callers can treat 0 as a
+   * signal that no backend was eligible — useful for success-verification in
+   * startup-sync when namespacesEnabled is true.
+   */
+  async updateNamespaces(namespaces, execution) {
+    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
+    const eligible = (await Promise.all(
+      unique.map(async (namespace) => {
+        const record = await this.backendRecordFor(namespace);
+        return record.available && record.collectionState !== "missing" ? record : null;
+      })
+    )).filter((record) => record !== null);
+    const globalRecord = eligible.find((record) => record.backend.updatesAllCollections?.() === true);
+    const scopedRecords = globalRecord ? eligible.filter((record) => record.backend.updatesAllCollections?.() !== true) : eligible;
+    await Promise.all([
+      globalRecord ? globalRecord.backend.update(execution) : Promise.resolve(),
+      ...scopedRecords.map((record) => record.backend.update(execution))
+    ]);
+    return (globalRecord ? 1 : 0) + scopedRecords.length;
+  }
+  async embedNamespaces(namespaces) {
+    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
+    await Promise.all(
+      unique.map(async (namespace) => {
+        const record = await this.backendRecordFor(namespace);
+        if (!record.available || record.collectionState === "missing") return;
+        await record.backend.embed();
+      })
+    );
+  }
+  async ensureNamespaceCollection(namespace) {
+    const record = await this.backendRecordFor(namespace);
+    return record.collectionState;
+  }
+  /** Clear cached backend records so the next access re-probes availability. */
+  clearCache() {
+    this.cache.clear();
+  }
+  /** Release any per-namespace backend handles held by cached records. */
+  async dispose() {
+    const pendingRecords = Array.from(this.cache.values());
+    this.cache.clear();
+    const settled = await Promise.allSettled(pendingRecords);
+    await Promise.allSettled(
+      settled.flatMap((entry) => {
+        if (entry.status !== "fulfilled") return [];
+        const dispose = entry.value.backend.dispose;
+        return dispose ? [dispose.call(entry.value.backend)] : [];
+      })
+    );
+  }
+  async backendRecordFor(namespace) {
+    const key = namespace.trim() || this.config.defaultNamespace;
+    const existing = this.cache.get(key);
+    if (existing) return await existing;
+    const pending = (async () => {
+      const storage = await this.storageRouter.storageFor(key);
+      const useLegacyDefaultCollection = key === this.config.defaultNamespace && storage.dir === this.config.memoryDir;
+      const scopedConfig = {
+        ...this.config,
+        memoryDir: storage.dir,
+        qmdCollection: namespaceCollectionName(this.config.qmdCollection, key, {
+          defaultNamespace: this.config.defaultNamespace,
+          useLegacyDefaultCollection
+        })
+      };
+      const backend = this.createBackend(scopedConfig);
+      const available = await backend.probe().catch(() => false);
+      const collectionState = available ? await backend.ensureCollection(storage.dir).catch(() => "unknown") : "unknown";
+      return {
+        backend,
+        collection: scopedConfig.qmdCollection,
+        memoryDir: storage.dir,
+        available,
+        collectionState
+      };
+    })();
+    this.cache.set(key, pending);
+    return await pending;
+  }
+};
+function mergeNamespaceSearchResults(lists, maxResults) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const result of list) {
+      const key = result.path || result.docid;
+      const existing = merged.get(key);
+      if (!existing) {
+        merged.set(key, result);
+        continue;
+      }
+      if (result.score > existing.score) {
+        merged.set(key, {
+          ...result,
+          snippet: existing.snippet || result.snippet || ""
+        });
+      }
+    }
+  }
+  return [...merged.values()].sort((a, b) => b.score - a.score).slice(0, maxResults);
+}
+
+export {
+  namespaceCollectionName,
+  NamespaceSearchRouter
+};
+//# sourceMappingURL=chunk-PU63GXWS.js.map

package/dist/chunk-PU63GXWS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/search.ts"],"sourcesContent":["import type { PluginConfig, QmdSearchResult } from \"../types.js\";\nimport type { SearchBackend, SearchExecutionOptions, SearchQueryOptions } from \"../search/port.js\";\nimport { createSearchBackend } from \"../search/factory.js\";\n\nexport function namespaceCollectionName(\n  baseCollection: string,\n  namespace: string,\n  options?: {\n    defaultNamespace?: string;\n    useLegacyDefaultCollection?: boolean;\n  },\n): string {\n  const trimmed = namespace.trim();\n  const defaultNamespace = options?.defaultNamespace?.trim() || \"default\";\n  if (\n    options?.useLegacyDefaultCollection === true &&\n    trimmed === defaultNamespace\n  ) {\n    return baseCollection;\n  }\n\n  const normalized = trimmed\n    .toLowerCase()\n    .replace(/[^a-z0-9._-]+/g, \"-\");\n  let start = 0;\n  let end = normalized.length;\n  while (start < end && normalized[start] === \"-\") start += 1;\n  while (end > start && normalized[end - 1] === \"-\") end -= 1;\n  const token = normalized.slice(start, end) || defaultNamespace;\n  return `${baseCollection}--ns--${token}`;\n}\n\ntype StorageRouterLike = {\n  storageFor(namespace: string): Promise<{ dir: string }>;\n};\n\ntype NamespaceBackendRecord = {\n  backend: SearchBackend;\n  collection: string;\n  memoryDir: string;\n  available: boolean;\n  collectionState: \"present\" | \"missing\" | \"unknown\" | \"skipped\";\n};\n\nexport class NamespaceSearchRouter {\n  private readonly cache = new Map<string, Promise<NamespaceBackendRecord>>();\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storageRouter: StorageRouterLike,\n    private readonly createBackend: (config: PluginConfig) => SearchBackend = createSearchBackend,\n  ) {}\n\n  async collectionForNamespace(namespace: string): Promise<string> {\n    return (await this.backendRecordFor(namespace)).collection;\n  }\n\n  async searchAcrossNamespaces(options: {\n    query: string;\n    namespaces: string[];\n    maxResults?: number;\n    mode?: \"search\" | \"hybrid\" | \"bm25\" | \"vector\";\n    searchOptions?: SearchQueryOptions;\n    execution?: SearchExecutionOptions;\n  }): Promise<QmdSearchResult[]> {\n    const query = options.query.trim();\n    if (!query) return [];\n    const maxResults = Math.max(0, Math.floor(options.maxResults ?? this.config.qmdMaxResults));\n    if (maxResults === 0) return [];\n\n    const method = options.mode ?? \"search\";\n    const namespaces = Array.from(new Set(options.namespaces.map((value) => value.trim()).filter(Boolean)));\n    if (namespaces.length === 0) return [];\n\n    const resultsByNamespace = await Promise.all(\n      namespaces.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") return [] as QmdSearchResult[];\n        switch (method) {\n          case \"hybrid\":\n            return await record.backend.hybridSearch(query, undefined, maxResults, options.execution);\n          case \"bm25\":\n            return await record.backend.bm25Search(query, undefined, maxResults, options.execution);\n          case \"vector\":\n            return await record.backend.vectorSearch(query, undefined, maxResults, options.execution);\n          default:\n            return await record.backend.search(\n              query,\n              undefined,\n              maxResults,\n              options.searchOptions,\n              options.execution,\n            );\n        }\n      }),\n    );\n\n    return mergeNamespaceSearchResults(resultsByNamespace, maxResults);\n  }\n\n  /**\n   * Update all namespace backends.\n   * Returns the number of backends for which an update was attempted\n   * (i.e., available and collection present).  Callers can treat 0 as a\n   * signal that no backend was eligible — useful for success-verification in\n   * startup-sync when namespacesEnabled is true.\n   */\n  async updateNamespaces(\n    namespaces: string[],\n    execution?: SearchExecutionOptions,\n  ): Promise<number> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    const eligible = (await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        return record.available && record.collectionState !== \"missing\"\n          ? record\n          : null;\n      }),\n    )).filter((record): record is NamespaceBackendRecord => record !== null);\n\n    const globalRecord = eligible.find((record) => record.backend.updatesAllCollections?.() === true);\n    const scopedRecords = globalRecord\n      ? eligible.filter((record) => record.backend.updatesAllCollections?.() !== true)\n      : eligible;\n\n    await Promise.all([\n      globalRecord ? globalRecord.backend.update(execution) : Promise.resolve(),\n      ...scopedRecords.map((record) => record.backend.update(execution)),\n    ]);\n\n    return (globalRecord ? 1 : 0) + scopedRecords.length;\n  }\n\n  async embedNamespaces(namespaces: string[]): Promise<void> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") return;\n        await record.backend.embed();\n      }),\n    );\n  }\n\n  async ensureNamespaceCollection(namespace: string): Promise<\"present\" | \"missing\" | \"unknown\" | \"skipped\"> {\n    const record = await this.backendRecordFor(namespace);\n    return record.collectionState;\n  }\n\n  /** Clear cached backend records so the next access re-probes availability. */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /** Release any per-namespace backend handles held by cached records. */\n  async dispose(): Promise<void> {\n    const pendingRecords = Array.from(this.cache.values());\n    this.cache.clear();\n    const settled = await Promise.allSettled(pendingRecords);\n    await Promise.allSettled(\n      settled.flatMap((entry) => {\n        if (entry.status !== \"fulfilled\") return [];\n        const dispose = (entry.value.backend as { dispose?: () => void | Promise<void> }).dispose;\n        return dispose ? [dispose.call(entry.value.backend)] : [];\n      }),\n    );\n  }\n\n  private async backendRecordFor(namespace: string): Promise<NamespaceBackendRecord> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const existing = this.cache.get(key);\n    if (existing) return await existing;\n\n    const pending = (async (): Promise<NamespaceBackendRecord> => {\n      const storage = await this.storageRouter.storageFor(key);\n      const useLegacyDefaultCollection =\n        key === this.config.defaultNamespace && storage.dir === this.config.memoryDir;\n      const scopedConfig: PluginConfig = {\n        ...this.config,\n        memoryDir: storage.dir,\n        qmdCollection: namespaceCollectionName(this.config.qmdCollection, key, {\n          defaultNamespace: this.config.defaultNamespace,\n          useLegacyDefaultCollection,\n        }),\n      };\n\n      const backend = this.createBackend(scopedConfig);\n      const available = await backend.probe().catch(() => false);\n      const collectionState = available\n        ? await backend.ensureCollection(storage.dir).catch(() => \"unknown\" as const)\n        : \"unknown\";\n      return {\n        backend,\n        collection: scopedConfig.qmdCollection,\n        memoryDir: storage.dir,\n        available,\n        collectionState,\n      };\n    })();\n\n    this.cache.set(key, pending);\n    return await pending;\n  }\n}\n\nfunction mergeNamespaceSearchResults(\n  lists: QmdSearchResult[][],\n  maxResults: number,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n\n  for (const list of lists) {\n    for (const result of list) {\n      const key = result.path || result.docid;\n      const existing = merged.get(key);\n      if (!existing) {\n        merged.set(key, result);\n        continue;\n      }\n      if (result.score > existing.score) {\n        merged.set(key, {\n          ...result,\n          snippet: existing.snippet || result.snippet || \"\",\n        });\n      }\n    }\n  }\n\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PZIAX57I.js

@@ -0,0 +1,124 @@
+import {
+  backupAndWriteRebuiltObservations,
+  toHourBucketIso
+} from "./chunk-LT3NLYSI.js";
+
+// src/maintenance/rebuild-observations.ts
+import path from "path";
+import { readdir, readFile } from "fs/promises";
+function toSortableKey(sessionKey, hour) {
+  return `${sessionKey}\0${hour}`;
+}
+async function listTranscriptFiles(root) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code && code === "ENOENT") return out;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (entry.name === "." || entry.name === "..") continue;
+    if (entry.isSymbolicLink()) continue;
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listTranscriptFiles(full));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      out.push(full);
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+function buildLedgerRows(linesByFile) {
+  const byKey = /* @__PURE__ */ new Map();
+  let parsedTurns = 0;
+  let malformedLines = 0;
+  for (const rawFile of linesByFile) {
+    for (const line of rawFile.split("\n")) {
+      if (!line.trim()) continue;
+      let parsed;
+      try {
+        const candidate = JSON.parse(line);
+        if (candidate == null || typeof candidate !== "object" || Array.isArray(candidate)) {
+          malformedLines += 1;
+          continue;
+        }
+        parsed = candidate;
+      } catch {
+        malformedLines += 1;
+        continue;
+      }
+      if (typeof parsed.sessionKey !== "string" || parsed.sessionKey.length === 0) continue;
+      if (parsed.role !== "user" && parsed.role !== "assistant") continue;
+      if (typeof parsed.timestamp !== "string") continue;
+      const hour = toHourBucketIso(parsed.timestamp);
+      if (!hour) continue;
+      const key = toSortableKey(parsed.sessionKey, hour);
+      const existing = byKey.get(key) ?? {
+        sessionKey: parsed.sessionKey,
+        hour,
+        turnCount: 0,
+        userTurns: 0,
+        assistantTurns: 0
+      };
+      existing.turnCount += 1;
+      if (parsed.role === "user") existing.userTurns += 1;
+      if (parsed.role === "assistant") existing.assistantTurns += 1;
+      byKey.set(key, existing);
+      parsedTurns += 1;
+    }
+  }
+  const aggregates = Array.from(byKey.values()).sort((a, b) => {
+    if (a.sessionKey !== b.sessionKey) return a.sessionKey.localeCompare(b.sessionKey);
+    return a.hour.localeCompare(b.hour);
+  });
+  return { aggregates, parsedTurns, malformedLines };
+}
+async function rebuildObservations(options) {
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const transcriptsRoot = path.join(options.memoryDir, "transcripts");
+  const outputPath = path.join(
+    options.memoryDir,
+    "state",
+    "observation-ledger",
+    "rebuilt-observations.jsonl"
+  );
+  const transcriptFiles = await listTranscriptFiles(transcriptsRoot);
+  const contents = [];
+  for (const file of transcriptFiles) {
+    try {
+      contents.push(await readFile(file, "utf-8"));
+    } catch {
+    }
+  }
+  const { aggregates, parsedTurns, malformedLines } = buildLedgerRows(contents);
+  let backupPath;
+  if (!dryRun) {
+    backupPath = await backupAndWriteRebuiltObservations({
+      memoryDir: options.memoryDir,
+      outputPath,
+      rows: aggregates,
+      now
+    });
+  }
+  return {
+    dryRun,
+    scannedFiles: transcriptFiles.length,
+    parsedTurns,
+    malformedLines,
+    rebuiltRows: aggregates.length,
+    outputPath,
+    backupPath
+  };
+}
+
+export {
+  rebuildObservations
+};
+//# sourceMappingURL=chunk-PZIAX57I.js.map

package/dist/chunk-PZIAX57I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/rebuild-observations.ts"],"sourcesContent":["import path from \"node:path\";\nimport { readdir, readFile } from \"node:fs/promises\";\nimport {\n  backupAndWriteRebuiltObservations,\n  toHourBucketIso,\n} from \"./observation-ledger-utils.js\";\n\ninterface TranscriptLikeEntry {\n  timestamp?: string;\n  role?: string;\n  sessionKey?: string;\n}\n\ninterface ObservationAggregate {\n  sessionKey: string;\n  hour: string;\n  turnCount: number;\n  userTurns: number;\n  assistantTurns: number;\n}\n\nexport interface RebuildObservationsOptions {\n  memoryDir: string;\n  dryRun?: boolean;\n  now?: Date;\n}\n\nexport interface RebuildObservationsResult {\n  dryRun: boolean;\n  scannedFiles: number;\n  parsedTurns: number;\n  malformedLines: number;\n  rebuiltRows: number;\n  outputPath: string;\n  backupPath?: string;\n}\n\nfunction toSortableKey(sessionKey: string, hour: string): string {\n  return `${sessionKey}\\u0000${hour}`;\n}\n\nasync function listTranscriptFiles(root: string): Promise<string[]> {\n  const out: string[] = [];\n  let entries: Array<{\n    name: string;\n    isDirectory(): boolean;\n    isFile(): boolean;\n    isSymbolicLink(): boolean;\n  }>;\n  try {\n    entries = (await readdir(root, { withFileTypes: true })) as Array<{\n      name: string;\n      isDirectory(): boolean;\n      isFile(): boolean;\n      isSymbolicLink(): boolean;\n    }>;\n  } catch (err) {\n    const code = (err as NodeJS.ErrnoException).code;\n    if (code && code === \"ENOENT\") return out;\n    throw err;\n  }\n\n  for (const entry of entries) {\n    if (entry.name === \".\" || entry.name === \"..\") continue;\n    if (entry.isSymbolicLink()) continue;\n    const full = path.join(root, entry.name);\n    if (entry.isDirectory()) {\n      out.push(...(await listTranscriptFiles(full)));\n      continue;\n    }\n    if (entry.isFile() && entry.name.endsWith(\".jsonl\")) {\n      out.push(full);\n    }\n  }\n\n  out.sort((a, b) => a.localeCompare(b));\n  return out;\n}\n\nfunction buildLedgerRows(linesByFile: string[]): {\n  aggregates: ObservationAggregate[];\n  parsedTurns: number;\n  malformedLines: number;\n} {\n  const byKey = new Map<string, ObservationAggregate>();\n  let parsedTurns = 0;\n  let malformedLines = 0;\n\n  for (const rawFile of linesByFile) {\n    for (const line of rawFile.split(\"\\n\")) {\n      if (!line.trim()) continue;\n      let parsed: TranscriptLikeEntry;\n      try {\n        const candidate = JSON.parse(line);\n        if (candidate == null || typeof candidate !== \"object\" || Array.isArray(candidate)) {\n          malformedLines += 1;\n          continue;\n        }\n        parsed = candidate as TranscriptLikeEntry;\n      } catch {\n        malformedLines += 1;\n        continue;\n      }\n\n      if (typeof parsed.sessionKey !== \"string\" || parsed.sessionKey.length === 0) continue;\n      if (parsed.role !== \"user\" && parsed.role !== \"assistant\") continue;\n      if (typeof parsed.timestamp !== \"string\") continue;\n      const hour = toHourBucketIso(parsed.timestamp);\n      if (!hour) continue;\n\n      const key = toSortableKey(parsed.sessionKey, hour);\n      const existing = byKey.get(key) ?? {\n        sessionKey: parsed.sessionKey,\n        hour,\n        turnCount: 0,\n        userTurns: 0,\n        assistantTurns: 0,\n      };\n      existing.turnCount += 1;\n      if (parsed.role === \"user\") existing.userTurns += 1;\n      if (parsed.role === \"assistant\") existing.assistantTurns += 1;\n      byKey.set(key, existing);\n      parsedTurns += 1;\n    }\n  }\n\n  const aggregates = Array.from(byKey.values()).sort((a, b) => {\n    if (a.sessionKey !== b.sessionKey) return a.sessionKey.localeCompare(b.sessionKey);\n    return a.hour.localeCompare(b.hour);\n  });\n\n  return { aggregates, parsedTurns, malformedLines };\n}\n\nexport async function rebuildObservations(\n  options: RebuildObservationsOptions,\n): Promise<RebuildObservationsResult> {\n  const dryRun = options.dryRun !== false;\n  const now = options.now ?? new Date();\n  const transcriptsRoot = path.join(options.memoryDir, \"transcripts\");\n  const outputPath = path.join(\n    options.memoryDir,\n    \"state\",\n    \"observation-ledger\",\n    \"rebuilt-observations.jsonl\",\n  );\n\n  const transcriptFiles = await listTranscriptFiles(transcriptsRoot);\n  const contents: string[] = [];\n  for (const file of transcriptFiles) {\n    try {\n      contents.push(await readFile(file, \"utf-8\"));\n    } catch {\n      // Fail-open: skip unreadable shards and continue rebuilding from healthy files.\n    }\n  }\n  const { aggregates, parsedTurns, malformedLines } = buildLedgerRows(contents);\n\n  let backupPath: string | undefined;\n  if (!dryRun) {\n    backupPath = await backupAndWriteRebuiltObservations({\n      memoryDir: options.memoryDir,\n      outputPath,\n      rows: aggregates,\n      now,\n    });\n  }\n\n  return {\n    dryRun,\n    scannedFiles: transcriptFiles.length,\n    parsedTurns,\n    malformedLines,\n    rebuiltRows: aggregates.length,\n    outputPath,\n    backupPath,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-Q7P4WJDP.js

@@ -0,0 +1,26 @@
+// src/types.ts
+var RECALL_DISCLOSURE_LEVELS = [
+  "chunk",
+  "section",
+  "raw"
+];
+var DEFAULT_RECALL_DISCLOSURE = "chunk";
+function isRecallDisclosure(value) {
+  return typeof value === "string" && RECALL_DISCLOSURE_LEVELS.includes(value);
+}
+function confidenceTier(score) {
+  if (score >= 0.95) return "explicit";
+  if (score >= 0.7) return "implied";
+  if (score >= 0.4) return "inferred";
+  return "speculative";
+}
+var SPECULATIVE_TTL_DAYS = 30;
+
+export {
+  RECALL_DISCLOSURE_LEVELS,
+  DEFAULT_RECALL_DISCLOSURE,
+  isRecallDisclosure,
+  confidenceTier,
+  SPECULATIVE_TTL_DAYS
+};
+//# sourceMappingURL=chunk-Q7P4WJDP.js.map