@remnic/core 1.1.30 → 9.3.515

package/dist/chunk-YR7XMOWK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contradiction/contradiction-judge.ts","../src/contradiction/contradiction-scan.ts"],"sourcesContent":["/**\n * Contradiction Judge — LLM-as-judge for semantic contradiction detection (issue #520).\n *\n * Pairs semantically-similar memories and classifies their relationship.\n * Reuses the extraction-judge adapter pattern but with a contradiction-specific\n * prompt and verdict taxonomy.\n *\n * Design constraints:\n *   - Default verdict on any failure is \"needs-user\" (rule 48: least-privileged default).\n *   - Never auto-resolve; all verdicts enter the review queue.\n *   - Content-hash caching avoids redundant LLM calls across runs.\n */\n\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\nimport { extractJsonCandidates } from \"../json-extract.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\nexport type ContradictionVerdict =\n  | \"contradicts\"\n  | \"independent\"\n  | \"duplicates\"\n  | \"needs-user\";\n\nexport interface ContradictionJudgeInput {\n  /** Memory ID of the first fact. */\n  memoryIdA: string;\n  /** Memory ID of the second fact. */\n  memoryIdB: string;\n  /** Content text of the first fact. */\n  textA: string;\n  /** Content text of the second fact. */\n  textB: string;\n  /** Category of the first fact (optional context). */\n  categoryA?: string;\n  /** Category of the second fact (optional context). */\n  categoryB?: string;\n}\n\nexport interface ContradictionJudgeResult {\n  /** Memory IDs of the pair. */\n  memoryIdA: string;\n  memoryIdB: string;\n  /** Verdict from the judge. */\n  verdict: ContradictionVerdict;\n  /** Human-readable rationale. */\n  rationale: string;\n  /** Confidence in [0, 1]. */\n  confidence: number;\n}\n\nexport interface ContradictionJudgeBatchResult {\n  /** Results keyed by pair key (\"idA:idB\"). */\n  results: Map<string, ContradictionJudgeResult>;\n  /** Number served from cache. */\n  cached: number;\n  /** Number produced by LLM call. */\n  judged: number;\n  /** Total wall-clock time in ms. */\n  elapsed: number;\n}\n\n// ── Prompt ─────────────────────────────────────────────────────────────────────\n\nconst CONTRADICTION_JUDGE_PROMPT = `You are a memory contradiction classifier. You will receive pairs of stored memories and must classify their semantic relationship.\n\nFor each pair, respond with a JSON array where each element has:\n- \"pairKey\": the pairKey provided in the input\n- \"verdict\": one of \"contradicts\", \"independent\", \"duplicates\", \"needs-user\"\n- \"rationale\": one sentence explaining why\n- \"confidence\": number between 0 and 1\n\nVERDICT DEFINITIONS:\n- \"contradicts\": The two memories make claims that cannot both be true. One must be wrong or outdated.\n- \"duplicates\": The two memories convey essentially the same information (near-paraphrase).\n- \"independent\": The memories are topically similar but do not conflict or duplicate.\n- \"needs-user\": Cannot determine with sufficient confidence; requires human review.\n\nIMPORTANT:\n- Be conservative. When in doubt, prefer \"needs-user\" over a wrong classification.\n- Two memories about the same entity/topic are NOT necessarily contradictory.\n- Temporal changes (\"Joshua uses pnpm\" vs \"Joshua switched to npm\") ARE contradictions.\n- Different aspects of the same entity (\"Joshua uses pnpm\" vs \"Joshua works on Remnic\") are \"independent\".`;\n\n// ── Cache ──────────────────────────────────────────────────────────────────────\n\n/** Module-level fallback cache — only used when caller does not supply one. */\nlet defaultVerdictCache: Map<string, ContradictionJudgeResult> = new Map();\nconst CACHE_MAX = 10_000;\n\nfunction pairKey(idA: string, idB: string): string {\n  const sorted = [idA, idB].sort();\n  return `${sorted[0]}:${sorted[1]}`;\n}\n\nfunction contentHash(a: ContradictionJudgeInput): string {\n  // Sort each side pair to be order-independent (matching pairKey behavior)\n  const sides = [\n    { text: a.textA.trim(), category: (a.categoryA ?? \"\").trim() },\n    { text: a.textB.trim(), category: (a.categoryB ?? \"\").trim() },\n  ].sort((left, right) => {\n    const leftKey = JSON.stringify(left);\n    const rightKey = JSON.stringify(right);\n    return leftKey.localeCompare(rightKey);\n  });\n  const normalized = JSON.stringify(sides);\n  return createHash(\"sha256\").update(normalized).digest(\"hex\").slice(0, 16);\n}\n\nexport function createVerdictCache(): Map<string, ContradictionJudgeResult> {\n  return new Map();\n}\n\nexport function clearVerdictCache(): void {\n  defaultVerdictCache.clear();\n}\n\nexport function verdictCacheSize(): number {\n  return defaultVerdictCache.size;\n}\n\n// ── Public API ──────────────────────────────────────────────────────────────────\n\n/**\n * Judge a batch of memory pairs for contradiction.\n *\n * Uses content-hash caching to skip pairs already judged in a prior run.\n * On any LLM failure, all unresolved pairs default to \"needs-user\".\n */\nexport async function judgeContradictionPairs(\n  pairs: ContradictionJudgeInput[],\n  config: PluginConfig,\n  localLlm: LocalLlmClient | null,\n  fallbackLlm: FallbackLlmClient | null,\n  cache?: Map<string, ContradictionJudgeResult>,\n): Promise<ContradictionJudgeBatchResult> {\n  const startTime = Date.now();\n  const results = new Map<string, ContradictionJudgeResult>();\n  const activeCache = cache ?? defaultVerdictCache;\n  let cached = 0;\n  let judged = 0;\n\n  // Partition into cached vs needs-judging\n  const toJudge: ContradictionJudgeInput[] = [];\n  for (const pair of pairs) {\n    const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n    const hash = contentHash(pair);\n    const cachedResult = activeCache.get(hash);\n    if (cachedResult) {\n      results.set(key, { ...cachedResult, memoryIdA: pair.memoryIdA, memoryIdB: pair.memoryIdB });\n      cached++;\n    } else {\n      toJudge.push(pair);\n    }\n  }\n\n  if (toJudge.length === 0) {\n    return { results, cached, judged, elapsed: Date.now() - startTime };\n  }\n\n  // Build the prompt with all pairs\n  const pairDescriptions = toJudge.map((p, i) => {\n    const pk = pairKey(p.memoryIdA, p.memoryIdB);\n    const catA = p.categoryA ? ` [${p.categoryA}]` : \"\";\n    const catB = p.categoryB ? ` [${p.categoryB}]` : \"\";\n    return `Pair ${i + 1} (pairKey: \"${pk}\"):${catA} \"${p.textA}\"${catB} \"${p.textB}\"`;\n  });\n\n  const userMessage = `Classify these ${toJudge.length} memory pair(s):\\n\\n${pairDescriptions.join(\"\\n\\n\")}`;\n\n  // Try LLM call\n  let llmResponse: string | null = null;\n\n  if (localLlm) {\n    try {\n      llmResponse = await callLlm(localLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] local LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  if (!llmResponse && fallbackLlm) {\n    try {\n      llmResponse = await callLlm(fallbackLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] fallback LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  // Parse response or default to needs-user\n  if (llmResponse) {\n    const candidates = extractJsonCandidates(llmResponse);\n    const parsed = parseJudgeResponse(candidates, toJudge);\n\n    for (const result of parsed) {\n      const key = pairKey(result.memoryIdA, result.memoryIdB);\n      results.set(key, result);\n\n      // Update cache\n      const input = toJudge.find(\n        (p) => pairKey(p.memoryIdA, p.memoryIdB) === key,\n      );\n      if (input) {\n        const hash = contentHash(input);\n        if (activeCache.size >= CACHE_MAX) {\n          const firstKey = activeCache.keys().next().value;\n          if (firstKey !== undefined) activeCache.delete(firstKey);\n        }\n        activeCache.set(hash, result);\n      }\n      judged++;\n    }\n  } else {\n    // All unresolved → needs-user (rule 48)\n    for (const pair of toJudge) {\n      const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n      const result: ContradictionJudgeResult = {\n        memoryIdA: pair.memoryIdA,\n        memoryIdB: pair.memoryIdB,\n        verdict: \"needs-user\",\n        rationale: \"LLM call failed; requires manual review\",\n        confidence: 0,\n      };\n      results.set(key, result);\n      judged++;\n    }\n  }\n\n  return { results, cached, judged, elapsed: Date.now() - startTime };\n}\n\n// ── Internals ──────────────────────────────────────────────────────────────────\n\nasync function callLlm(\n  client: LocalLlmClient | FallbackLlmClient,\n  config: PluginConfig,\n  userMessage: string,\n): Promise<string> {\n  const messages: Array<{ role: \"user\" | \"assistant\" | \"system\"; content: string }> = [\n    { role: \"system\", content: CONTRADICTION_JUDGE_PROMPT },\n    { role: \"user\", content: userMessage },\n  ];\n  if (\"chatCompletion\" in client && typeof client.chatCompletion === \"function\") {\n    const result = await client.chatCompletion(messages, {\n      temperature: 0.1,\n      maxTokens: 4096,\n      operation: \"contradiction-judge\",\n    });\n    return result?.content ?? \"\";\n  }\n  // FallbackLlmClient — try OpenAI-compatible chat completions\n  if (\"complete\" in client && typeof (client as Record<string, unknown>).complete === \"function\") {\n    const result = await (client as { complete: (msg: Array<{ role: string; content: string }>) => Promise<{ content: string }> }).complete(messages);\n    return result.content ?? \"\";\n  }\n  return \"\";\n}\n\nfunction parseJudgeResponse(\n  candidates: string[],\n  inputs: ContradictionJudgeInput[],\n): ContradictionJudgeResult[] {\n  const VALID_VERDICTS: ContradictionVerdict[] = [\"contradicts\", \"independent\", \"duplicates\", \"needs-user\"];\n  let conservativeFallback: ContradictionJudgeResult[] | null = null;\n\n  for (const candidate of candidates) {\n    try {\n      const parsed = JSON.parse(candidate);\n      const items = Array.isArray(parsed) ? parsed : [parsed];\n      const results: ContradictionJudgeResult[] = [];\n      const matchedKeys = new Set<string>();\n\n      for (const item of items) {\n        if (!item || typeof item !== \"object\") continue;\n\n        const verdict = typeof item.verdict === \"string\" && VALID_VERDICTS.includes(item.verdict as ContradictionVerdict)\n          ? (item.verdict as ContradictionVerdict)\n          : \"needs-user\";\n\n        const pairKeyVal = typeof item.pairKey === \"string\" && item.pairKey.length > 0\n          ? item.pairKey\n          : null;\n        const input = pairKeyVal\n          ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal)\n          : null;\n\n        if (!input) continue;\n\n        matchedKeys.add(pairKey(input.memoryIdA, input.memoryIdB));\n\n        const confidence = typeof item.confidence === \"number\"\n          ? Math.min(1, Math.max(0, item.confidence))\n          : 0.5;\n\n        results.push({\n          memoryIdA: input.memoryIdA,\n          memoryIdB: input.memoryIdB,\n          verdict,\n          rationale: typeof item.rationale === \"string\" ? item.rationale : \"No rationale provided\",\n          confidence,\n        });\n      }\n\n      // Backfill any inputs the LLM omitted with needs-user\n      for (const inp of inputs) {\n        const key = pairKey(inp.memoryIdA, inp.memoryIdB);\n        if (!matchedKeys.has(key)) {\n          results.push({\n            memoryIdA: inp.memoryIdA,\n            memoryIdB: inp.memoryIdB,\n            verdict: \"needs-user\",\n            rationale: \"LLM response omitted this pair\",\n            confidence: 0,\n          });\n        }\n      }\n\n      if (matchedKeys.size > 0) return results;\n      if (results.length > 0 && conservativeFallback === null) {\n        conservativeFallback = results;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  if (conservativeFallback !== null) return conservativeFallback;\n\n  // All parse attempts failed → needs-user for every input\n  return inputs.map((p) => ({\n    memoryIdA: p.memoryIdA,\n    memoryIdB: p.memoryIdB,\n    verdict: \"needs-user\" as ContradictionVerdict,\n    rationale: \"Failed to parse judge response\",\n    confidence: 0,\n  }));\n}\n\nexport { pairKey as _pairKey, contentHash as _contentHash };\n","/**\n * Contradiction Scan — pair generator + scan driver (issue #520).\n *\n * Nightly cron that pairs semantically-similar active memories within\n * the same namespace, sends candidate pairs to the LLM-as-judge\n * contradiction classifier, and drops contradicting pairs into a\n * review queue for user resolution.\n *\n * Pair generation (cheap pre-filter):\n *   1. Find candidate peers via embedding cosine >= similarityFloor.\n *   2. Restrict to pairs sharing at least one entityRef OR overlapping\n *      topic tokens >= topicOverlapFloor.\n *   3. Skip pairs already judged independent/both-valid within cooldown.\n *   4. Cap per-run work at maxPairsPerRun.\n */\n\nimport type { StorageManager } from \"../storage.js\";\nimport type { PluginConfig, MemoryFile, MemoryStatus } from \"../types.js\";\nimport type { SemanticDedupLookup } from \"../dedup/semantic.js\";\nimport { log } from \"../logger.js\";\nimport { judgeContradictionPairs, type ContradictionJudgeInput } from \"./contradiction-judge.js\";\nimport {\n  writePairs,\n  readPair,\n  isCoolingDown,\n  memoryHashesChanged,\n  computeMemoryContentHash,\n  computePairId,\n  migrateUnscopedPairsToNamespace,\n  type ContradictionPair,\n} from \"./contradiction-review.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\n/** The set of statuses that represent \"live\" memories eligible for scanning. */\nexport const ACTIVE_STATUSES: Set<MemoryStatus> = new Set([\"active\"]);\n\n/** High-value taxonomy buckets to scan. */\nconst SCAN_CATEGORIES = new Set([\n  \"decision\",\n  \"principle\",\n  \"rule\",\n  \"entity\",\n  \"fact\",\n  \"preference\",\n]);\n\nexport interface ScanResult {\n  /** Total active memories scanned. */\n  scanned: number;\n  /** Candidate pairs generated by the pre-filter. */\n  candidates: number;\n  /** Pairs sent to judge. */\n  judged: number;\n  /** Pairs written to review queue. */\n  queued: number;\n  /** Pairs skipped due to cooldown. */\n  cooledDown: number;\n  /** Total wall-clock time in ms. */\n  elapsedMs: number;\n}\n\nexport interface ScanStorageResolution {\n  storage: StorageManager;\n  namespace?: string;\n}\n\nexport interface ScanDependencies {\n  storage: StorageManager;\n  config: PluginConfig;\n  memoryDir: string;\n  /** Pre-built embedding lookup. When provided, used as-is for Strategy 3. */\n  embeddingLookup?: SemanticDedupLookup;\n  /**\n   * Factory to build a namespace-scoped embedding lookup.\n   * When provided, takes precedence over `embeddingLookup`.\n   * The scan driver passes its own `storage` so the lookup queries the correct index.\n   */\n  embeddingLookupFactory?: (storage: StorageManager) => SemanticDedupLookup | undefined;\n  /** Resolver for namespace-scoped storage. Required for scans when namespaces are enabled. */\n  storageForNamespace?: (\n    namespace: string | undefined,\n  ) => StorageManager | ScanStorageResolution | Promise<StorageManager | ScanStorageResolution>;\n  localLlm: LocalLlmClient | null;\n  fallbackLlm: FallbackLlmClient | null;\n  namespace?: string;\n}\n\n// ── Main scan driver ───────────────────────────────────────────────────────────\n\n/**\n * Run a contradiction scan over the memory corpus.\n *\n * This is the entry point called by the nightly cron and by the CLI.\n */\nexport async function runContradictionScan(deps: ScanDependencies): Promise<ScanResult> {\n  const startTime = Date.now();\n  const { config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm } = deps;\n  const requestedNamespace = normalizeScanNamespace(deps.namespace);\n  const scanConfig = config.contradictionScan;\n\n  if (!scanConfig.enabled) {\n    log.info(\"[contradiction-scan] disabled by config\");\n    return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };\n  }\n\n  const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);\n  if (config.namespacesEnabled && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {\n    const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });\n    if (migrated > 0) {\n      log.info(\"[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s\", migrated, namespace);\n    }\n  }\n\n  // Prefer the factory (which uses the scan's own storage for correct namespace scoping)\n  // over a pre-built lookup (which may use default-namespace storage).\n  const scopedEmbeddingLookup = embeddingLookupFactory\n    ? embeddingLookupFactory(scanStorage)\n    : embeddingLookup;\n\n  // 1. Load active memories in scan categories\n  const memories = await loadEligibleMemories(scanStorage);\n  log.info(\"[contradiction-scan] loaded %d eligible memories\", memories.length);\n\n  if (memories.length < 2) {\n    return { scanned: memories.length, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: Date.now() - startTime };\n  }\n\n  // 2. Prepare exact existing-pair lookup for cooldown checking.\n  // Pair IDs are deterministic, so lookup the candidate's file directly instead\n  // of paging through the review queue and risking a bounded-list miss.\n  const existingPairCache = new Map<string, ContradictionPair | undefined>();\n  const getExistingPair = (pairId: string): ContradictionPair | undefined => {\n    if (!existingPairCache.has(pairId)) {\n      existingPairCache.set(pairId, readPair(memoryDir, pairId) ?? undefined);\n    }\n    return existingPairCache.get(pairId);\n  };\n\n  // 3. Generate candidate pairs\n  const candidates = await generatePairs(memories, getExistingPair, scanConfig, namespace, scopedEmbeddingLookup);\n  const cooledDown = candidates.skipped;\n  log.info(\"[contradiction-scan] generated %d candidates (%d cooled down)\", candidates.pairs.length, cooledDown);\n\n  if (candidates.pairs.length === 0) {\n    return {\n      scanned: memories.length,\n      candidates: 0,\n      judged: 0,\n      queued: 0,\n      cooledDown,\n      elapsedMs: Date.now() - startTime,\n    };\n  }\n\n  // 4. Build judge inputs. Candidate generation already preserves strategy\n  // priority and caps work at maxPairsPerRun.\n  const judgeInputs: ContradictionJudgeInput[] = candidates.pairs.map((pair) => ({\n    memoryIdA: pair.idA,\n    memoryIdB: pair.idB,\n    textA: pair.textA,\n    textB: pair.textB,\n    categoryA: pair.categoryA,\n    categoryB: pair.categoryB,\n  }));\n\n  // 6. Send to judge (per-scan cache avoids module-level singleton leak)\n  const scanCache = new Map<string, import(\"./contradiction-judge.js\").ContradictionJudgeResult>();\n  const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm, scanCache);\n  log.info(\"[contradiction-scan] judge completed: %d judged, %d cached in %dms\", judgeResult.judged, judgeResult.cached, judgeResult.elapsed);\n\n  // 7. Write to review queue\n  const queueEntries: Array<Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] }> = [];\n  const currentMemoryHashes = memoryContentHashMap(memories);\n  for (const [key, result] of judgeResult.results) {\n    queueEntries.push({\n      memoryIds: [result.memoryIdA, result.memoryIdB],\n      verdict: result.verdict,\n      rationale: result.rationale,\n      confidence: result.confidence,\n      detectedAt: new Date().toISOString(),\n      // Set lastReviewedAt for non-actionable verdicts so cooldown prevents re-judging\n      lastReviewedAt: result.verdict === \"independent\" ? new Date().toISOString() : undefined,\n      memoryContentHashes: pairMemoryContentHashes(result.memoryIdA, result.memoryIdB, currentMemoryHashes),\n      namespace,\n    });\n  }\n\n  const written = writePairs(memoryDir, queueEntries, { cooldownDays: scanConfig.cooldownDays });\n  const elapsed = Date.now() - startTime;\n  log.info(\"[contradiction-scan] complete: %d queued in %dms\", written.length, elapsed);\n\n  return {\n    scanned: memories.length,\n    candidates: candidates.pairs.length,\n    judged: judgeResult.judged,\n    queued: written.length,\n    cooledDown,\n    elapsedMs: elapsed,\n  };\n}\n\n// ── Pair generation ────────────────────────────────────────────────────────────\n\ninterface CandidatePair {\n  idA: string;\n  idB: string;\n  textA: string;\n  textB: string;\n  categoryA?: string;\n  categoryB?: string;\n}\n\ninterface PairGenResult {\n  pairs: CandidatePair[];\n  skipped: number;\n}\n\nasync function generatePairs(\n  memories: MemoryFile[],\n  getExistingPair: (pairId: string) => ContradictionPair | undefined,\n  scanConfig: PluginConfig[\"contradictionScan\"],\n  namespace: string | undefined,\n  embeddingLookup?: SemanticDedupLookup,\n): Promise<PairGenResult> {\n  const pairs: CandidatePair[] = [];\n  let skipped = 0;\n  const seen = new Set<string>();\n  const maxPairs = Math.max(0, Math.floor(scanConfig.maxPairsPerRun));\n  if (maxPairs === 0) return { pairs, skipped };\n\n  const orderedMemories = [...memories].sort(compareMemoryId);\n  const currentMemoryHashes = memoryContentHashMap(orderedMemories);\n\n  const pushCandidate = (pair: CandidatePair): void => {\n    if (pairs.length < maxPairs) pairs.push(pair);\n  };\n\n  const hasCapacity = (): boolean => pairs.length < maxPairs;\n  const isSkippedByCooldown = (existing: ContradictionPair | undefined): boolean => {\n    if (!existing || !isCoolingDown(existing, scanConfig.cooldownDays)) return false;\n    return !memoryHashesChanged(\"\", existing, (memoryId) => currentMemoryHashes.get(memoryId) ?? null);\n  };\n\n  // Build index by entityRef for fast lookup\n  const byEntity = new Map<string, MemoryFile[]>();\n  for (const mem of orderedMemories) {\n    const entity = mem.frontmatter.entityRef;\n    if (entity) {\n      const existing = byEntity.get(entity) ?? [];\n      existing.push(mem);\n      byEntity.set(entity, existing);\n    }\n  }\n\n  // Strategy 1: Entity-ref based pairing (high precision)\n  entityPairs:\n  for (const entity of [...byEntity.keys()].sort()) {\n    const group = byEntity.get(entity) ?? [];\n    if (group.length < 2) continue;\n    for (let i = 0; i < group.length; i++) {\n      for (let j = i + 1; j < group.length; j++) {\n        if (!hasCapacity()) break entityPairs;\n        const a = group[i];\n        const b = group[j];\n        const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n\n        if (seen.has(pairId)) continue;\n        seen.add(pairId);\n\n        // Check cooldown\n        const existing = getExistingPair(pairId);\n        if (isSkippedByCooldown(existing)) {\n          skipped++;\n          continue;\n        }\n\n        pushCandidate({\n          idA: a.frontmatter.id!,\n          idB: b.frontmatter.id!,\n          textA: a.content,\n          textB: b.content,\n          categoryA: a.frontmatter.category as string | undefined,\n          categoryB: b.frontmatter.category as string | undefined,\n        });\n      }\n    }\n  }\n\n  // Strategy 2: Tag/topic overlap for memories without a shared entityRef\n  topicPairs:\n  for (let i = 0; i < orderedMemories.length; i++) {\n    for (let j = i + 1; j < orderedMemories.length; j++) {\n      if (!hasCapacity()) break topicPairs;\n      const a = orderedMemories[i];\n      const b = orderedMemories[j];\n      if (shareEntityRef(a, b)) continue;\n      const overlap = jaccardOverlap(\n        (a.frontmatter.tags as string[]) ?? [],\n        (b.frontmatter.tags as string[]) ?? [],\n      );\n\n      if (overlap < scanConfig.topicOverlapFloor) continue;\n\n      const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n      if (seen.has(pairId)) continue;\n      seen.add(pairId);\n\n      const existing = getExistingPair(pairId);\n      if (isSkippedByCooldown(existing)) {\n        skipped++;\n        continue;\n      }\n\n      pushCandidate({\n        idA: a.frontmatter.id!,\n        idB: b.frontmatter.id!,\n        textA: a.content,\n        textB: b.content,\n        categoryA: a.frontmatter.category as string | undefined,\n        categoryB: b.frontmatter.category as string | undefined,\n      });\n    }\n  }\n\n  // Strategy 3: Embedding cosine similarity (enforces similarityFloor config)\n  if (embeddingLookup && hasCapacity()) {\n    const memoryById = new Map(orderedMemories.map((m) => [m.frontmatter.id!, m]));\n    embeddingPairs:\n    for (const mem of orderedMemories) {\n      if (!hasCapacity()) break;\n      const id = mem.frontmatter.id!;\n      try {\n        const hits = (await embeddingLookup(mem.content, 20)).sort((a, b) =>\n          b.score - a.score || a.id.localeCompare(b.id),\n        );\n        for (const hit of hits) {\n          if (!hasCapacity()) break embeddingPairs;\n          if (hit.score < scanConfig.similarityFloor) continue;\n          if (hit.id === id) continue;\n          const peer = memoryById.get(hit.id);\n          if (!peer) continue;\n\n          const pairId = computePairId(id, hit.id, namespace);\n          if (seen.has(pairId)) continue;\n          seen.add(pairId);\n\n          const existing = getExistingPair(pairId);\n          if (isSkippedByCooldown(existing)) {\n            skipped++;\n            continue;\n          }\n\n          pushCandidate({\n            idA: id,\n            idB: hit.id,\n            textA: mem.content,\n            textB: peer.content,\n            categoryA: mem.frontmatter.category as string | undefined,\n            categoryB: peer.frontmatter.category as string | undefined,\n          });\n        }\n      } catch {\n        // Embedding backend unavailable — skip, entity-ref/tag strategies already covered\n      }\n    }\n  }\n\n  return { pairs, skipped };\n}\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nfunction normalizeScanNamespace(namespace: string | undefined): string | undefined {\n  const trimmed = namespace?.trim();\n  return trimmed ? trimmed : undefined;\n}\n\nasync function resolveScanStorage(\n  deps: ScanDependencies,\n  namespace: string | undefined,\n): Promise<ScanStorageResolution> {\n  if (!deps.config.namespacesEnabled) {\n    const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);\n    if (namespace && namespace !== defaultNamespace) {\n      throw new Error(`unsupported namespace: ${namespace}`);\n    }\n    return { storage: deps.storage, namespace: undefined };\n  }\n\n  if (deps.storageForNamespace) {\n    const resolved = await deps.storageForNamespace(namespace);\n    if (isScanStorageResolution(resolved)) {\n      return {\n        storage: resolved.storage,\n        namespace: normalizeScanNamespace(resolved.namespace) ?? fallbackResolvedNamespace(deps, namespace),\n      };\n    }\n    if (!isStorageManagerLike(resolved)) {\n      throw new Error(\"storageForNamespace must return a StorageManager or { storage: StorageManager, namespace?: string }\");\n    }\n    return {\n      storage: resolved,\n      namespace: fallbackResolvedNamespace(deps, namespace),\n    };\n  }\n\n  throw new Error(\n    \"contradiction scans require storageForNamespace when namespaces are enabled so callers can enforce namespace access\",\n  );\n}\n\nfunction isScanStorageResolution(value: StorageManager | ScanStorageResolution): value is ScanStorageResolution {\n  if (isStorageManagerLike(value)) return false;\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { storage?: unknown };\n  return isStorageManagerLike(candidate.storage);\n}\n\nfunction isStorageManagerLike(value: unknown): value is StorageManager {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { readAllMemories?: unknown };\n  return typeof candidate.readAllMemories === \"function\";\n}\n\nfunction fallbackResolvedNamespace(deps: ScanDependencies, namespace: string | undefined): string | undefined {\n  if (namespace) return namespace;\n  return deps.config.namespacesEnabled ? deps.config.defaultNamespace : undefined;\n}\n\nfunction isDefaultNamespaceScan(\n  config: PluginConfig,\n  requestedNamespace: string | undefined,\n  resolvedNamespace: string,\n): boolean {\n  if (requestedNamespace === undefined) return true;\n  return requestedNamespace === config.defaultNamespace || resolvedNamespace === config.defaultNamespace;\n}\n\nasync function loadEligibleMemories(storage: StorageManager): Promise<MemoryFile[]> {\n  let all: MemoryFile[];\n  try {\n    all = await storage.readAllMemories();\n  } catch {\n    return [];\n  }\n\n  return all.filter((mem) => {\n    const fm = mem.frontmatter;\n    // Only active memories (rule 53: explicit ACTIVE_STATUSES set)\n    const status = (fm.status as MemoryStatus) ?? \"active\";\n    if (!ACTIVE_STATUSES.has(status)) return false;\n\n    // Only scan high-value categories\n    const category = fm.category as string | undefined;\n    if (category && !SCAN_CATEGORIES.has(category)) return false;\n\n    // Must have content\n    if (!mem.content || mem.content.trim().length === 0) return false;\n\n    // Must have an ID\n    if (!fm.id) return false;\n\n    return true;\n  });\n}\n\nfunction jaccardOverlap(a: string[], b: string[]): number {\n  if (a.length === 0 && b.length === 0) return 0;\n  const setA = new Set(a.map((t) => t.toLowerCase()));\n  const setB = new Set(b.map((t) => t.toLowerCase()));\n  let intersection = 0;\n  for (const item of setA) {\n    if (setB.has(item)) intersection++;\n  }\n  const union = setA.size + setB.size - intersection;\n  return union === 0 ? 0 : intersection / union;\n}\n\nfunction shareEntityRef(a: MemoryFile, b: MemoryFile): boolean {\n  const entityA = a.frontmatter.entityRef?.trim();\n  const entityB = b.frontmatter.entityRef?.trim();\n  return Boolean(entityA && entityB && entityA === entityB);\n}\n\nfunction compareMemoryId(a: MemoryFile, b: MemoryFile): number {\n  return (a.frontmatter.id ?? \"\").localeCompare(b.frontmatter.id ?? \"\");\n}\n\nfunction memoryContentHashMap(memories: MemoryFile[]): Map<string, string> {\n  const hashes = new Map<string, string>();\n  for (const memory of memories) {\n    const id = memory.frontmatter.id;\n    if (!id) continue;\n    hashes.set(id, computeMemoryContentHash(memory.content, memory.frontmatter.category as string | undefined));\n  }\n  return hashes;\n}\n\nfunction pairMemoryContentHashes(\n  memoryIdA: string,\n  memoryIdB: string,\n  currentMemoryHashes: Map<string, string>,\n): Record<string, string> | undefined {\n  const hashA = currentMemoryHashes.get(memoryIdA);\n  const hashB = currentMemoryHashes.get(memoryIdB);\n  if (!hashA || !hashB) return undefined;\n  return {\n    [memoryIdA]: hashA,\n    [memoryIdB]: hashB,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ZFXCQPNO.js

@@ -0,0 +1,27 @@
+// src/namespaces/identity.ts
+function normalizeNamespaceIdentity(namespace) {
+  return namespace.trim();
+}
+function namespaceIdentityToken(namespace) {
+  const normalized = normalizeNamespaceIdentity(namespace);
+  const bytes = new TextEncoder().encode(normalized);
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `ns-${hex || "default"}`;
+}
+function namespaceIdentityFromToken(token) {
+  if (!token.startsWith("ns-")) return null;
+  const hex = token.slice(3);
+  if (hex === "default") return "";
+  if (hex.length === 0 || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex)) {
+    return null;
+  }
+  const decoded = Buffer.from(hex, "hex").toString("utf8");
+  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase() ? decoded : null;
+}
+
+export {
+  normalizeNamespaceIdentity,
+  namespaceIdentityToken,
+  namespaceIdentityFromToken
+};
+//# sourceMappingURL=chunk-ZFXCQPNO.js.map

package/dist/chunk-ZFXCQPNO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/identity.ts"],"sourcesContent":["export function normalizeNamespaceIdentity(namespace: string): string {\n  return namespace.trim();\n}\n\nexport function namespaceIdentityToken(namespace: string): string {\n  const normalized = normalizeNamespaceIdentity(namespace);\n  const bytes = new TextEncoder().encode(normalized);\n  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n  return `ns-${hex || \"default\"}`;\n}\n\nexport function namespaceIdentityFromToken(token: string): string | null {\n  if (!token.startsWith(\"ns-\")) return null;\n  const hex = token.slice(3);\n  if (hex === \"default\") return \"\";\n  if (hex.length === 0 || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex)) {\n    return null;\n  }\n  const decoded = Buffer.from(hex, \"hex\").toString(\"utf8\");\n  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase()\n    ? decoded\n    : null;\n}\n"],"mappings":";AAAO,SAAS,2BAA2B,WAA2B;AACpE,SAAO,UAAU,KAAK;AACxB;AAEO,SAAS,uBAAuB,WAA2B;AAChE,QAAM,aAAa,2BAA2B,SAAS;AACvD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,UAAU;AACjD,QAAM,MAAM,MAAM,KAAK,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AACnF,SAAO,MAAM,OAAO,SAAS;AAC/B;AAEO,SAAS,2BAA2B,OAA8B;AACvE,MAAI,CAAC,MAAM,WAAW,KAAK,EAAG,QAAO;AACrC,QAAM,MAAM,MAAM,MAAM,CAAC;AACzB,MAAI,QAAQ,UAAW,QAAO;AAC9B,MAAI,IAAI,WAAW,KAAK,IAAI,SAAS,MAAM,KAAK,CAAC,eAAe,KAAK,GAAG,GAAG;AACzE,WAAO;AAAA,EACT;AACA,QAAM,UAAU,OAAO,KAAK,KAAK,KAAK,EAAE,SAAS,MAAM;AACvD,SAAO,uBAAuB,OAAO,EAAE,YAAY,MAAM,MAAM,YAAY,IACvE,UACA;AACN;","names":[]}

package/dist/citations.js

@@ -3,7 +3,7 @@ import {
   formatOaiMemCitation,
   parseOaiMemCitation,
   sanitizeNoteForCitation
-} from "./chunk-IQT3XTKW.js";
+} from "./chunk-D24OXEPB.js";
 import "./chunk-PZ5AY32C.js";
 export {
   buildCitationGuidance,

package/dist/{cli-CJKI2JIe.d.ts → cli-X4NJoqSe.d.ts}

@@ -7,14 +7,16 @@ import { RebuildMemoryLifecycleLedgerResult } from './maintenance/rebuild-memory
 import { RebuildObservationsResult } from './maintenance/rebuild-observations.js';
 import { ArchiveObservationsResult } from './maintenance/archive-observations.js';
 import { Writable, Readable } from 'node:stream';
-import { I as ImportTurn, B as BulkImportSource, a as BulkImportOptions, b as BulkImportResult, O as Orchestrator } from './orchestrator-DuWl9Hwx.js';
+import { O as Orchestrator } from './orchestrator-Co9nxRLF.js';
 import { ReplayRunSummary } from './replay/runner.js';
 import { ReplaySource, ReplayTurn } from './replay/types.js';
+import { b as BulkImportResult } from './types-BliCnURB.js';
+import { P as ProcessBatchFn } from './pipeline-D18UAKlN.js';
 import { WorkProjectStatus, WorkTaskStatus, WorkTaskPriority } from './work/types.js';
 import { RoutePatternType } from './routing/engine.js';
 import { TailscaleSyncOptions } from './network/tailscale.js';
 import { DashboardStatus } from './dashboard-runtime.js';
-import { E as EngramAccessService } from './access-service-B5hgZPCN.js';
+import { E as EngramAccessService } from './access-service-qrrIrC-0.js';
 import { ResolveSecretRefFn } from './resolve-auth-token.js';
 import { CompatRunner, CompatReport } from './compat/types.js';
 import { EvalBaselineDeltaReport, EvalBaselineSnapshot, EvalCiGateReport, EvalBenchmarkPackSummary, EvalHarnessStatus, EvalStoredBaselineCiGateReport } from './evals.js';
@@ -36,34 +38,7 @@ import { TrustZoneDemoSeedResult, TrustZoneName, TrustZonePromotionResult, Trust
 import { SessionIntegrityReport, SessionRepairPlan, SessionRepairApplyResult } from './session-integrity.js';
 import { TierMigrationStatusSnapshot, TierMigrationCycleSummary } from './recall-state.js';
 import { RuntimePolicyValues } from './policy-runtime.js';
-import { C as ConnectorRunResult, a as ConnectorsOutputFormat } from './connectors-cli-CwbyjGR7.js';
-
-interface ProcessBatchResult {
-    memoriesCreated: number;
-    duplicatesSkipped: number;
-    /**
-     * Number of entities created by the batch. Optional so Phase-1 stubs that
-     * only count memories can omit it; when absent it is treated as 0.
-     */
-    entitiesCreated?: number;
-}
-interface ProcessBatchContext {
-    dedup: boolean;
-    trustLevel: "import";
-    namespace?: string;
-}
-type ProcessBatchFn = (turns: ImportTurn[], context: ProcessBatchContext) => Promise<ProcessBatchResult>;
-/**
- * Format a batch of turns into a conversation transcript string.
- */
-declare function formatBatchTranscript(turns: ImportTurn[]): string;
-/**
- * Run the bulk-import pipeline over a parsed source.
- *
- * Splits turns into batches and delegates each to `processBatch`.
- * In dryRun mode, validates and counts without calling `processBatch`.
- */
-declare function runBulkImportPipeline(source: BulkImportSource, options: BulkImportOptions | undefined, processBatch: ProcessBatchFn): Promise<BulkImportResult>;
+import { C as ConnectorRunResult, a as ConnectorsOutputFormat } from './connectors-cli-DbTPNj2H.js';
 
 /**
  * Parse a strict ISO 8601 date string, rejecting malformed inputs, calendar
@@ -487,11 +462,13 @@ interface DashboardStartCliCommandOptions {
     host?: string;
     port?: number;
     publicDir?: string;
+    authToken?: string;
     createServer?: (options: {
         memoryDir: string;
         host?: string;
         port?: number;
         publicDir?: string;
+        authToken?: string;
     }) => DashboardServerLike;
 }
 interface AccessHttpServeCliCommandOptions {
@@ -1133,4 +1110,4 @@ declare function resolveMemoryDirForNamespace(orchestrator: Orchestrator, namesp
 }): Promise<string>;
 declare function registerCli(api: CliApi, orchestrator: Orchestrator, registerOptions?: RegisterCliOptions): void;
 
-export { parseDurationToMs as $, type AccessHttpServeCliCommandOptions as A, type BulkImportCliCommandOptions as B, type CompatCliCommandOptions as C, type DashboardStartCliCommandOptions as D, type ExactDedupePlan as E, type RepairMemoryProjectionCliCommandOptions as F, type GraphHealthCliCommandOptions as G, type ReplayCliCommandOptions as H, type ReplayCliOrchestrator as I, type RouteCliCommandOptions as J, type SessionRepairCliCommandOptions as K, type TailscaleSyncCliCommandOptions as L, type MemoryActionAuditCliCommandOptions as M, type TierMigrationCliOrchestrator as N, type TrainingExportCliCommandOptions as O, type ProcessBatchFn as P, type WorkProjectCliCommandOptions as Q, type RebuildMemoryLifecycleLedgerCliCommandOptions as R, type SessionIntegrityCliCommandOptions as S, type TailscaleStatusCliCommandOptions as T, type WorkTaskCliCommandOptions as U, type VerifyMemoryProjectionCliCommandOptions as V, type WebDavServeCliCommandOptions as W, emitConnectorsRunCliResult as X, filterNormalMemorySearchResults as Y, hasDestructivePurgeFailures as Z, isNormalRetrievalVisibleMemory as _, type ProcessBatchResult as a, runTailscaleStatusCliCommand as a$, parseStrictCliDate as a0, planAggressiveDuplicateDeletions as a1, planExactDuplicateDeletions as a2, registerCli as a3, resolveAccessPrincipalOverride as a4, resolveMemoryDirForNamespace as a5, runAbstractionNodeStatusCliCommand as a6, runAccessHttpServeCliCommand as a7, runAccessHttpStatusCliCommand as a8, runAccessHttpStopCliCommand as a9, runMemoryGovernanceCliCommand as aA, runMemoryGovernanceReportCliCommand as aB, runMemoryGovernanceRestoreCliCommand as aC, runMemoryReviewDispositionCliCommand as aD, runMemoryTimelineCliCommand as aE, runMigrateNormalizeFrontmatterCliCommand as aF, runMigrateObservationsCliCommand as aG, runMigrateRechunkCliCommand as aH, runMigrateReextractCliCommand as aI, runMigrateRescoreImportanceCliCommand as aJ, runObjectiveStateStatusCliCommand as aK, runPolicyDiffCliCommand as aL, runPolicyRollbackCliCommand as aM, runPolicyStatusCliCommand as aN, runRebuildMemoryLifecycleLedgerCliCommand as aO, runRebuildMemoryProjectionCliCommand as aP, runRebuildObservationsCliCommand as aQ, runRepairMemoryProjectionCliCommand as aR, runReplayCliCommand as aS, runResumeBundleBuildCliCommand as aT, runResumeBundleRecordCliCommand as aU, runResumeBundleStatusCliCommand as aV, runRouteCliCommand as aW, runSemanticRulePromoteCliCommand as aX, runSemanticRuleVerifyCliCommand as aY, runSessionCheckCliCommand as aZ, runSessionRepairCliCommand as a_, runAccessMcpServeCliCommand as aa, runArchiveObservationsCliCommand as ab, runBenchmarkBaselineReportCliCommand as ac, runBenchmarkBaselineSnapshotCliCommand as ad, runBenchmarkCiGateCliCommand as ae, runBenchmarkImportCliCommand as af, runBenchmarkStatusCliCommand as ag, runBenchmarkStoredBaselineCiGateCliCommand as ah, runBenchmarkValidateCliCommand as ai, runCausalTrajectoryStatusCliCommand as aj, runCommitmentLifecycleCliCommand as ak, runCommitmentRecordCliCommand as al, runCommitmentSetStateCliCommand as am, runCommitmentStatusCliCommand as an, runCompatCliCommand as ao, runCompoundingPromoteCliCommand as ap, runConversationIndexHealthCliCommand as aq, runConversationIndexInspectCliCommand as ar, runConversationIndexRebuildCliCommand as as, runCueAnchorStatusCliCommand as at, runDashboardStartCliCommand as au, runDashboardStatusCliCommand as av, runDashboardStopCliCommand as aw, runGraphHealthCliCommand as ax, runHarmonicSearchCliCommand as ay, runMemoryActionAuditCliCommand as az, runBulkImportPipeline as b, runTailscaleSyncCliCommand as b0, runTierMigrateCliCommand as b1, runTierStatusCliCommand as b2, runTrainingExportCliCommand as b3, runTrustZoneDemoSeedCliCommand as b4, runTrustZonePromoteCliCommand as b5, runTrustZoneStatusCliCommand as b6, runUtilityLearningCliCommand as b7, runUtilityLearningStatusCliCommand as b8, runUtilityTelemetryRecordCliCommand as b9, runUtilityTelemetryStatusCliCommand as ba, runVerifiedRecallSearchCliCommand as bb, runVerifyMemoryProjectionCliCommand as bc, runWebDavServeCliCommand as bd, runWebDavStopCliCommand as be, runWorkProductRecallSearchCliCommand as bf, runWorkProductRecordCliCommand as bg, runWorkProductStatusCliCommand as bh, runWorkProjectCliCommand as bi, runWorkTaskCliCommand as bj, type ArchiveObservationsCliCommandOptions as c, type ConnectorsRunCliOutputOptions as d, type ConversationIndexHealthCliOrchestrator as e, formatBatchTranscript as f, type DedupeCandidate as g, type MemoryActionAuditCliNamespaceSummary as h, type MemoryActionAuditCliReport as i, type MemoryGovernanceCliCommandOptions as j, type MemoryGovernanceReportCliCommandOptions as k, type MemoryGovernanceRestoreCliCommandOptions as l, type MemoryReviewDispositionCliCommandOptions as m, type MemoryTimelineCliCommandOptions as n, type MigrateCliOrchestrator as o, parseStrictCliDate$1 as p, type MigrateCliReport as q, runBulkImportCliCommand as r, type MigrateObservationsCliCommandOptions as s, type PolicyDiffCliReport as t, type PolicyDiffEntry as u, type PolicyRollbackCliReport as v, type PolicyStatusCliReport as w, type PolicyTuningCliOrchestrator as x, type RebuildMemoryProjectionCliCommandOptions as y, type RebuildObservationsCliCommandOptions as z };
+export { registerCli as $, type AccessHttpServeCliCommandOptions as A, type BulkImportCliCommandOptions as B, type CompatCliCommandOptions as C, type DashboardStartCliCommandOptions as D, type ExactDedupePlan as E, type SessionRepairCliCommandOptions as F, type GraphHealthCliCommandOptions as G, type TailscaleSyncCliCommandOptions as H, type TierMigrationCliOrchestrator as I, type TrainingExportCliCommandOptions as J, type WorkProjectCliCommandOptions as K, type WorkTaskCliCommandOptions as L, type MemoryActionAuditCliCommandOptions as M, emitConnectorsRunCliResult as N, filterNormalMemorySearchResults as O, type PolicyDiffCliReport as P, hasDestructivePurgeFailures as Q, type RebuildMemoryLifecycleLedgerCliCommandOptions as R, type SessionIntegrityCliCommandOptions as S, type TailscaleStatusCliCommandOptions as T, isNormalRetrievalVisibleMemory as U, type VerifyMemoryProjectionCliCommandOptions as V, type WebDavServeCliCommandOptions as W, parseDurationToMs as X, parseStrictCliDate as Y, planAggressiveDuplicateDeletions as Z, planExactDuplicateDeletions as _, type ArchiveObservationsCliCommandOptions as a, runTrainingExportCliCommand as a$, resolveAccessPrincipalOverride as a0, resolveMemoryDirForNamespace as a1, runAbstractionNodeStatusCliCommand as a2, runAccessHttpServeCliCommand as a3, runAccessHttpStatusCliCommand as a4, runAccessHttpStopCliCommand as a5, runAccessMcpServeCliCommand as a6, runArchiveObservationsCliCommand as a7, runBenchmarkBaselineReportCliCommand as a8, runBenchmarkBaselineSnapshotCliCommand as a9, runMemoryTimelineCliCommand as aA, runMigrateNormalizeFrontmatterCliCommand as aB, runMigrateObservationsCliCommand as aC, runMigrateRechunkCliCommand as aD, runMigrateReextractCliCommand as aE, runMigrateRescoreImportanceCliCommand as aF, runObjectiveStateStatusCliCommand as aG, runPolicyDiffCliCommand as aH, runPolicyRollbackCliCommand as aI, runPolicyStatusCliCommand as aJ, runRebuildMemoryLifecycleLedgerCliCommand as aK, runRebuildMemoryProjectionCliCommand as aL, runRebuildObservationsCliCommand as aM, runRepairMemoryProjectionCliCommand as aN, runReplayCliCommand as aO, runResumeBundleBuildCliCommand as aP, runResumeBundleRecordCliCommand as aQ, runResumeBundleStatusCliCommand as aR, runRouteCliCommand as aS, runSemanticRulePromoteCliCommand as aT, runSemanticRuleVerifyCliCommand as aU, runSessionCheckCliCommand as aV, runSessionRepairCliCommand as aW, runTailscaleStatusCliCommand as aX, runTailscaleSyncCliCommand as aY, runTierMigrateCliCommand as aZ, runTierStatusCliCommand as a_, runBenchmarkCiGateCliCommand as aa, runBenchmarkImportCliCommand as ab, runBenchmarkStatusCliCommand as ac, runBenchmarkStoredBaselineCiGateCliCommand as ad, runBenchmarkValidateCliCommand as ae, runCausalTrajectoryStatusCliCommand as af, runCommitmentLifecycleCliCommand as ag, runCommitmentRecordCliCommand as ah, runCommitmentSetStateCliCommand as ai, runCommitmentStatusCliCommand as aj, runCompatCliCommand as ak, runCompoundingPromoteCliCommand as al, runConversationIndexHealthCliCommand as am, runConversationIndexInspectCliCommand as an, runConversationIndexRebuildCliCommand as ao, runCueAnchorStatusCliCommand as ap, runDashboardStartCliCommand as aq, runDashboardStatusCliCommand as ar, runDashboardStopCliCommand as as, runGraphHealthCliCommand as at, runHarmonicSearchCliCommand as au, runMemoryActionAuditCliCommand as av, runMemoryGovernanceCliCommand as aw, runMemoryGovernanceReportCliCommand as ax, runMemoryGovernanceRestoreCliCommand as ay, runMemoryReviewDispositionCliCommand as az, type ConnectorsRunCliOutputOptions as b, runTrustZoneDemoSeedCliCommand as b0, runTrustZonePromoteCliCommand as b1, runTrustZoneStatusCliCommand as b2, runUtilityLearningCliCommand as b3, runUtilityLearningStatusCliCommand as b4, runUtilityTelemetryRecordCliCommand as b5, runUtilityTelemetryStatusCliCommand as b6, runVerifiedRecallSearchCliCommand as b7, runVerifyMemoryProjectionCliCommand as b8, runWebDavServeCliCommand as b9, runWebDavStopCliCommand as ba, runWorkProductRecallSearchCliCommand as bb, runWorkProductRecordCliCommand as bc, runWorkProductStatusCliCommand as bd, runWorkProjectCliCommand as be, runWorkTaskCliCommand as bf, type ConversationIndexHealthCliOrchestrator as c, type DedupeCandidate as d, type MemoryActionAuditCliNamespaceSummary as e, type MemoryActionAuditCliReport as f, type MemoryGovernanceCliCommandOptions as g, type MemoryGovernanceReportCliCommandOptions as h, type MemoryGovernanceRestoreCliCommandOptions as i, type MemoryReviewDispositionCliCommandOptions as j, type MemoryTimelineCliCommandOptions as k, type MigrateCliOrchestrator as l, type MigrateCliReport as m, type MigrateObservationsCliCommandOptions as n, type PolicyDiffEntry as o, parseStrictCliDate$1 as p, type PolicyRollbackCliReport as q, runBulkImportCliCommand as r, type PolicyStatusCliReport as s, type PolicyTuningCliOrchestrator as t, type RebuildMemoryProjectionCliCommandOptions as u, type RebuildObservationsCliCommandOptions as v, type RepairMemoryProjectionCliCommandOptions as w, type ReplayCliCommandOptions as x, type ReplayCliOrchestrator as y, type RouteCliCommandOptions as z };

package/dist/cli.d.ts

@@ -7,15 +7,16 @@ import './maintenance/rebuild-memory-lifecycle-ledger.js';
 import './maintenance/rebuild-observations.js';
 import './maintenance/archive-observations.js';
 import 'node:stream';
-import './orchestrator-DuWl9Hwx.js';
+import './orchestrator-Co9nxRLF.js';
 import './replay/runner.js';
 import './replay/types.js';
-export { A as AccessHttpServeCliCommandOptions, c as ArchiveObservationsCliCommandOptions, B as BulkImportCliCommandOptions, C as CompatCliCommandOptions, d as ConnectorsRunCliOutputOptions, e as ConversationIndexHealthCliOrchestrator, D as DashboardStartCliCommandOptions, g as DedupeCandidate, E as ExactDedupePlan, G as GraphHealthCliCommandOptions, M as MemoryActionAuditCliCommandOptions, h as MemoryActionAuditCliNamespaceSummary, i as MemoryActionAuditCliReport, j as MemoryGovernanceCliCommandOptions, k as MemoryGovernanceReportCliCommandOptions, l as MemoryGovernanceRestoreCliCommandOptions, m as MemoryReviewDispositionCliCommandOptions, n as MemoryTimelineCliCommandOptions, o as MigrateCliOrchestrator, q as MigrateCliReport, s as MigrateObservationsCliCommandOptions, t as PolicyDiffCliReport, u as PolicyDiffEntry, v as PolicyRollbackCliReport, w as PolicyStatusCliReport, x as PolicyTuningCliOrchestrator, R as RebuildMemoryLifecycleLedgerCliCommandOptions, y as RebuildMemoryProjectionCliCommandOptions, z as RebuildObservationsCliCommandOptions, F as RepairMemoryProjectionCliCommandOptions, H as ReplayCliCommandOptions, I as ReplayCliOrchestrator, J as RouteCliCommandOptions, S as SessionIntegrityCliCommandOptions, K as SessionRepairCliCommandOptions, T as TailscaleStatusCliCommandOptions, L as TailscaleSyncCliCommandOptions, N as TierMigrationCliOrchestrator, O as TrainingExportCliCommandOptions, V as VerifyMemoryProjectionCliCommandOptions, W as WebDavServeCliCommandOptions, Q as WorkProjectCliCommandOptions, U as WorkTaskCliCommandOptions, X as emitConnectorsRunCliResult, Y as filterNormalMemorySearchResults, Z as hasDestructivePurgeFailures, _ as isNormalRetrievalVisibleMemory, $ as parseDurationToMs, a0 as parseStrictCliDate, a1 as planAggressiveDuplicateDeletions, a2 as planExactDuplicateDeletions, a3 as registerCli, a4 as resolveAccessPrincipalOverride, a5 as resolveMemoryDirForNamespace, a6 as runAbstractionNodeStatusCliCommand, a7 as runAccessHttpServeCliCommand, a8 as runAccessHttpStatusCliCommand, a9 as runAccessHttpStopCliCommand, aa as runAccessMcpServeCliCommand, ab as runArchiveObservationsCliCommand, ac as runBenchmarkBaselineReportCliCommand, ad as runBenchmarkBaselineSnapshotCliCommand, ae as runBenchmarkCiGateCliCommand, af as runBenchmarkImportCliCommand, ag as runBenchmarkStatusCliCommand, ah as runBenchmarkStoredBaselineCiGateCliCommand, ai as runBenchmarkValidateCliCommand, r as runBulkImportCliCommand, aj as runCausalTrajectoryStatusCliCommand, ak as runCommitmentLifecycleCliCommand, al as runCommitmentRecordCliCommand, am as runCommitmentSetStateCliCommand, an as runCommitmentStatusCliCommand, ao as runCompatCliCommand, ap as runCompoundingPromoteCliCommand, aq as runConversationIndexHealthCliCommand, ar as runConversationIndexInspectCliCommand, as as runConversationIndexRebuildCliCommand, at as runCueAnchorStatusCliCommand, au as runDashboardStartCliCommand, av as runDashboardStatusCliCommand, aw as runDashboardStopCliCommand, ax as runGraphHealthCliCommand, ay as runHarmonicSearchCliCommand, az as runMemoryActionAuditCliCommand, aA as runMemoryGovernanceCliCommand, aB as runMemoryGovernanceReportCliCommand, aC as runMemoryGovernanceRestoreCliCommand, aD as runMemoryReviewDispositionCliCommand, aE as runMemoryTimelineCliCommand, aF as runMigrateNormalizeFrontmatterCliCommand, aG as runMigrateObservationsCliCommand, aH as runMigrateRechunkCliCommand, aI as runMigrateReextractCliCommand, aJ as runMigrateRescoreImportanceCliCommand, aK as runObjectiveStateStatusCliCommand, aL as runPolicyDiffCliCommand, aM as runPolicyRollbackCliCommand, aN as runPolicyStatusCliCommand, aO as runRebuildMemoryLifecycleLedgerCliCommand, aP as runRebuildMemoryProjectionCliCommand, aQ as runRebuildObservationsCliCommand, aR as runRepairMemoryProjectionCliCommand, aS as runReplayCliCommand, aT as runResumeBundleBuildCliCommand, aU as runResumeBundleRecordCliCommand, aV as runResumeBundleStatusCliCommand, aW as runRouteCliCommand, aX as runSemanticRulePromoteCliCommand, aY as runSemanticRuleVerifyCliCommand, aZ as runSessionCheckCliCommand, a_ as runSessionRepairCliCommand, a$ as runTailscaleStatusCliCommand, b0 as runTailscaleSyncCliCommand, b1 as runTierMigrateCliCommand, b2 as runTierStatusCliCommand, b3 as runTrainingExportCliCommand, b4 as runTrustZoneDemoSeedCliCommand, b5 as runTrustZonePromoteCliCommand, b6 as runTrustZoneStatusCliCommand, b7 as runUtilityLearningCliCommand, b8 as runUtilityLearningStatusCliCommand, b9 as runUtilityTelemetryRecordCliCommand, ba as runUtilityTelemetryStatusCliCommand, bb as runVerifiedRecallSearchCliCommand, bc as runVerifyMemoryProjectionCliCommand, bd as runWebDavServeCliCommand, be as runWebDavStopCliCommand, bf as runWorkProductRecallSearchCliCommand, bg as runWorkProductRecordCliCommand, bh as runWorkProductStatusCliCommand, bi as runWorkProjectCliCommand, bj as runWorkTaskCliCommand } from './cli-CJKI2JIe.js';
+import './types-BliCnURB.js';
+import './pipeline-D18UAKlN.js';
 import './work/types.js';
 import './routing/engine.js';
 import './network/tailscale.js';
 import './dashboard-runtime.js';
-import './access-service-B5hgZPCN.js';
+import './access-service-qrrIrC-0.js';
 import './resolve-auth-token.js';
 import './compat/types.js';
 import './evals.js';
@@ -37,7 +38,8 @@ import './trust-zones.js';
 import './session-integrity.js';
 import './recall-state.js';
 import './policy-runtime.js';
-import './connectors-cli-CwbyjGR7.js';
+export { A as AccessHttpServeCliCommandOptions, a as ArchiveObservationsCliCommandOptions, B as BulkImportCliCommandOptions, C as CompatCliCommandOptions, b as ConnectorsRunCliOutputOptions, c as ConversationIndexHealthCliOrchestrator, D as DashboardStartCliCommandOptions, d as DedupeCandidate, E as ExactDedupePlan, G as GraphHealthCliCommandOptions, M as MemoryActionAuditCliCommandOptions, e as MemoryActionAuditCliNamespaceSummary, f as MemoryActionAuditCliReport, g as MemoryGovernanceCliCommandOptions, h as MemoryGovernanceReportCliCommandOptions, i as MemoryGovernanceRestoreCliCommandOptions, j as MemoryReviewDispositionCliCommandOptions, k as MemoryTimelineCliCommandOptions, l as MigrateCliOrchestrator, m as MigrateCliReport, n as MigrateObservationsCliCommandOptions, P as PolicyDiffCliReport, o as PolicyDiffEntry, q as PolicyRollbackCliReport, s as PolicyStatusCliReport, t as PolicyTuningCliOrchestrator, R as RebuildMemoryLifecycleLedgerCliCommandOptions, u as RebuildMemoryProjectionCliCommandOptions, v as RebuildObservationsCliCommandOptions, w as RepairMemoryProjectionCliCommandOptions, x as ReplayCliCommandOptions, y as ReplayCliOrchestrator, z as RouteCliCommandOptions, S as SessionIntegrityCliCommandOptions, F as SessionRepairCliCommandOptions, T as TailscaleStatusCliCommandOptions, H as TailscaleSyncCliCommandOptions, I as TierMigrationCliOrchestrator, J as TrainingExportCliCommandOptions, V as VerifyMemoryProjectionCliCommandOptions, W as WebDavServeCliCommandOptions, K as WorkProjectCliCommandOptions, L as WorkTaskCliCommandOptions, N as emitConnectorsRunCliResult, O as filterNormalMemorySearchResults, Q as hasDestructivePurgeFailures, U as isNormalRetrievalVisibleMemory, X as parseDurationToMs, Y as parseStrictCliDate, Z as planAggressiveDuplicateDeletions, _ as planExactDuplicateDeletions, $ as registerCli, a0 as resolveAccessPrincipalOverride, a1 as resolveMemoryDirForNamespace, a2 as runAbstractionNodeStatusCliCommand, a3 as runAccessHttpServeCliCommand, a4 as runAccessHttpStatusCliCommand, a5 as runAccessHttpStopCliCommand, a6 as runAccessMcpServeCliCommand, a7 as runArchiveObservationsCliCommand, a8 as runBenchmarkBaselineReportCliCommand, a9 as runBenchmarkBaselineSnapshotCliCommand, aa as runBenchmarkCiGateCliCommand, ab as runBenchmarkImportCliCommand, ac as runBenchmarkStatusCliCommand, ad as runBenchmarkStoredBaselineCiGateCliCommand, ae as runBenchmarkValidateCliCommand, r as runBulkImportCliCommand, af as runCausalTrajectoryStatusCliCommand, ag as runCommitmentLifecycleCliCommand, ah as runCommitmentRecordCliCommand, ai as runCommitmentSetStateCliCommand, aj as runCommitmentStatusCliCommand, ak as runCompatCliCommand, al as runCompoundingPromoteCliCommand, am as runConversationIndexHealthCliCommand, an as runConversationIndexInspectCliCommand, ao as runConversationIndexRebuildCliCommand, ap as runCueAnchorStatusCliCommand, aq as runDashboardStartCliCommand, ar as runDashboardStatusCliCommand, as as runDashboardStopCliCommand, at as runGraphHealthCliCommand, au as runHarmonicSearchCliCommand, av as runMemoryActionAuditCliCommand, aw as runMemoryGovernanceCliCommand, ax as runMemoryGovernanceReportCliCommand, ay as runMemoryGovernanceRestoreCliCommand, az as runMemoryReviewDispositionCliCommand, aA as runMemoryTimelineCliCommand, aB as runMigrateNormalizeFrontmatterCliCommand, aC as runMigrateObservationsCliCommand, aD as runMigrateRechunkCliCommand, aE as runMigrateReextractCliCommand, aF as runMigrateRescoreImportanceCliCommand, aG as runObjectiveStateStatusCliCommand, aH as runPolicyDiffCliCommand, aI as runPolicyRollbackCliCommand, aJ as runPolicyStatusCliCommand, aK as runRebuildMemoryLifecycleLedgerCliCommand, aL as runRebuildMemoryProjectionCliCommand, aM as runRebuildObservationsCliCommand, aN as runRepairMemoryProjectionCliCommand, aO as runReplayCliCommand, aP as runResumeBundleBuildCliCommand, aQ as runResumeBundleRecordCliCommand, aR as runResumeBundleStatusCliCommand, aS as runRouteCliCommand, aT as runSemanticRulePromoteCliCommand, aU as runSemanticRuleVerifyCliCommand, aV as runSessionCheckCliCommand, aW as runSessionRepairCliCommand, aX as runTailscaleStatusCliCommand, aY as runTailscaleSyncCliCommand, aZ as runTierMigrateCliCommand, a_ as runTierStatusCliCommand, a$ as runTrainingExportCliCommand, b0 as runTrustZoneDemoSeedCliCommand, b1 as runTrustZonePromoteCliCommand, b2 as runTrustZoneStatusCliCommand, b3 as runUtilityLearningCliCommand, b4 as runUtilityLearningStatusCliCommand, b5 as runUtilityTelemetryRecordCliCommand, b6 as runUtilityTelemetryStatusCliCommand, b7 as runVerifiedRecallSearchCliCommand, b8 as runVerifyMemoryProjectionCliCommand, b9 as runWebDavServeCliCommand, ba as runWebDavStopCliCommand, bb as runWorkProductRecallSearchCliCommand, bc as runWorkProductRecordCliCommand, bd as runWorkProductStatusCliCommand, be as runWorkProjectCliCommand, bf as runWorkTaskCliCommand } from './cli-X4NJoqSe.js';
+import './connectors-cli-DbTPNj2H.js';
 import './storage.js';
 import './page-versioning.js';
 import './consolidation-operator.js';
@@ -54,6 +56,7 @@ import './summarizer.js';
 import './model-registry.js';
 import './local-llm.js';
 import './fallback-llm.js';
+import './resolve-provider-secret.js';
 import './live-connectors-runner.js';
 import './framework-CyHYDcri.js';
 import './relevance.js';
@@ -63,7 +66,7 @@ import './memory-provenance.js';
 import './user-model.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
-import './semantic-VwGI14Ok.js';
+import './semantic-SLAa_prH.js';
 import './lcm/engine.js';
 import './lcm/archive.js';
 import './lcm/summarizer.js';
@@ -74,9 +77,10 @@ import './connectors/codex-materialize.js';
 import './logger.js';
 import './conversation-index/backend.js';
 import './conversation-index/chunker.js';
-import './faiss-adapter-CzPghc4C.js';
+import './faiss-adapter-BHecI1fF.js';
 import './runtime/child-process.js';
 import './profiling.js';
+import './types-B1VHaf2w.js';
 import './recall-explain-renderer.js';
 import './recall-audit-anomaly.js';
 import './recall-audit.js';

package/dist/cli.js

@@ -89,173 +89,178 @@ import {
   runWorkProductStatusCliCommand,
   runWorkProjectCliCommand,
   runWorkTaskCliCommand
-} from "./chunk-KRBK4BQH.js";
-import "./chunk-ICRIXAP2.js";
-import "./chunk-EHRTFRWW.js";
-import "./chunk-S7KDBTWT.js";
-import "./chunk-TZOLIGIG.js";
-import "./chunk-TK4UEOSK.js";
-import "./chunk-XKLD5OK4.js";
-import "./chunk-DOM4GKSW.js";
-import "./chunk-W4L6CZKA.js";
-import "./chunk-3JXBXXM2.js";
-import "./chunk-7OZ53EXP.js";
-import "./chunk-GIF42EW3.js";
-import "./chunk-6H2TESSP.js";
-import "./chunk-66DHUKLO.js";
+} from "./chunk-D6WE5MTW.js";
+import "./chunk-7F7Z6MOS.js";
+import "./chunk-MC4FJXPA.js";
+import "./chunk-LQHDIS7L.js";
+import "./chunk-JJEJJ7RK.js";
+import "./chunk-UP6MOYCB.js";
+import "./chunk-XSWKORGM.js";
+import "./chunk-HDDRVXX4.js";
+import "./chunk-4RR6ROTB.js";
 import "./chunk-Z734BLO3.js";
+import "./chunk-OZKVVUJB.js";
+import "./chunk-2DL3OFLD.js";
+import "./chunk-G4IAEX6D.js";
+import "./chunk-2NLLXCJG.js";
+import "./chunk-765K3SAT.js";
 import "./chunk-TKWGAOLV.js";
-import "./chunk-FIT6DMX6.js";
-import "./chunk-TPMQ3G6Z.js";
-import "./chunk-BVF3AGJP.js";
-import "./chunk-2IWUMAES.js";
-import "./chunk-PZIAX57I.js";
-import "./chunk-65PG43EQ.js";
+import "./chunk-UWY7GIVS.js";
+import "./chunk-HOJZMQ4J.js";
+import "./chunk-2NM43EWN.js";
+import "./chunk-LJBOVCQG.js";
+import "./chunk-E62SBGQ3.js";
+import "./chunk-XR6DNK4U.js";
+import "./chunk-RUZOJKNF.js";
+import "./chunk-S7WU3Y3D.js";
 import "./chunk-KJTKLXTH.js";
-import "./chunk-PK7H5L6Y.js";
-import "./chunk-LT3NLYSI.js";
-import "./chunk-TMM4S4IJ.js";
-import "./chunk-MRILGULB.js";
-import "./chunk-MXC3AP5I.js";
-import "./chunk-ZK7I7JYV.js";
-import "./chunk-MT4HVDUZ.js";
+import "./chunk-H2NCNXMS.js";
+import "./chunk-PU44GBL4.js";
+import "./chunk-YR6GIWWY.js";
+import "./chunk-V2RCP53Q.js";
+import "./chunk-R3PS27B4.js";
+import "./chunk-TGQ2NTWH.js";
+import "./chunk-PM3QHTFT.js";
 import "./chunk-AJA46VX5.js";
-import "./chunk-W6AQJ2PY.js";
-import "./chunk-77H5NU3M.js";
+import "./chunk-L7S47WZT.js";
+import "./chunk-EDBEWFJO.js";
 import "./chunk-HL4DB7TO.js";
-import "./chunk-ZPKBYX2F.js";
-import "./chunk-3SLRNYNG.js";
-import "./chunk-LIRZNNUP.js";
+import "./chunk-YNDLCWXS.js";
+import "./chunk-AUDJPF4N.js";
+import "./chunk-44442YCH.js";
 import "./chunk-Y4Z4I6WK.js";
-import "./chunk-5HRY2WRF.js";
+import "./chunk-LZ3VEOU5.js";
 import "./chunk-YBPYIAA5.js";
+import "./chunk-HPWVAEET.js";
 import "./chunk-2PRQG7PV.js";
-import "./chunk-LUDTDZLK.js";
-import "./chunk-JA3AK3PT.js";
-import "./chunk-PYXS46O7.js";
-import "./chunk-3QKK7QOS.js";
+import "./chunk-XNLXAWHX.js";
+import "./chunk-3BP57I6J.js";
+import "./chunk-TERNBNJB.js";
 import "./chunk-W4RVMTHR.js";
-import "./chunk-SAZS2QZB.js";
-import "./chunk-CULXMQJH.js";
-import "./chunk-5375UYTQ.js";
+import "./chunk-23UORJ4S.js";
+import "./chunk-XPXEJRUB.js";
+import "./chunk-A6D7A2FW.js";
 import "./chunk-FF4KLI5W.js";
-import "./chunk-EABGC2TL.js";
-import "./chunk-RR2PKP3I.js";
-import "./chunk-575RMLWN.js";
-import "./chunk-I5GLV3VE.js";
+import "./chunk-4426WSWL.js";
+import "./chunk-A2Z6UCWT.js";
+import "./chunk-7MV5CWTE.js";
+import "./chunk-EIPUHVKE.js";
+import "./chunk-A52AKD7C.js";
+import "./chunk-RCTS5CKK.js";
 import "./chunk-NJ3MJQZX.js";
-import "./chunk-XVVIG67A.js";
+import "./chunk-BLZAVUD2.js";
 import "./chunk-PIRJPV5T.js";
-import "./chunk-RXDLTSWT.js";
-import "./chunk-3VAL7ZL2.js";
-import "./chunk-TMQLARTH.js";
-import "./chunk-MJFNCJXV.js";
-import "./chunk-CYFQJMUV.js";
+import "./chunk-Q4CAQGKQ.js";
+import "./chunk-ONPLNAPX.js";
+import "./chunk-CINZGPSJ.js";
+import "./chunk-CHBI22MI.js";
+import "./chunk-ZFXCQPNO.js";
+import "./chunk-KIB7SDIJ.js";
+import "./chunk-ORFGK3XI.js";
+import "./chunk-HENLZHIT.js";
 import "./chunk-7DTASS5T.js";
-import "./chunk-FJ43PRLT.js";
-import "./chunk-LLQ2LLWF.js";
-import "./chunk-YRMVARQP.js";
-import "./chunk-3TNBOMQT.js";
-import "./chunk-U66YHYC7.js";
-import "./chunk-HXXBL2KD.js";
-import "./chunk-LPMVBPA3.js";
+import "./chunk-KFY3SGN7.js";
+import "./chunk-TVRN5QKH.js";
+import "./chunk-CMTINOFS.js";
+import "./chunk-BECQDWBA.js";
+import "./chunk-CWWMTTQE.js";
 import "./chunk-JXS5PDQ7.js";
-import "./chunk-HMDCOMYU.js";
-import "./chunk-7SEAZFFB.js";
-import "./chunk-D46YSIYX.js";
+import "./chunk-SKGV326D.js";
+import "./chunk-BEUDU7Y4.js";
+import "./chunk-G3Z3QEF5.js";
 import "./chunk-AJU4PJGY.js";
-import "./chunk-C6QPK5GG.js";
-import "./chunk-2KI4QFHU.js";
-import "./chunk-OZHRDTDX.js";
+import "./chunk-FZZ2QTJI.js";
+import "./chunk-LMDRGRJ2.js";
+import "./chunk-OKTXM5H4.js";
 import "./chunk-3UXOZBHV.js";
 import "./chunk-4WMCPJWX.js";
-import "./chunk-MZH6EHNR.js";
+import "./chunk-7H6CFEBJ.js";
 import "./chunk-PHK3HARR.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-6HZ6AO2P.js";
-import "./chunk-NZL6GGQE.js";
+import "./chunk-HQ6NIBL6.js";
 import "./chunk-PVGDJXVK.js";
-import "./chunk-NGAVDO7E.js";
-import "./chunk-3OWUCDKH.js";
+import "./chunk-OADWQ5CR.js";
+import "./chunk-FER4WARO.js";
 import "./chunk-SEDEKFYQ.js";
-import "./chunk-6FC5EGNV.js";
-import "./chunk-3Y4P7RXM.js";
-import "./chunk-6LVVDPJ4.js";
-import "./chunk-7MNMYOFP.js";
-import "./chunk-FKFMOY3N.js";
-import "./chunk-FAJ7FZYM.js";
-import "./chunk-UL2NNBUL.js";
-import "./chunk-C5BCH4ZS.js";
-import "./chunk-IQT3XTKW.js";
-import "./chunk-QKZGQIPJ.js";
-import "./chunk-ZKSK55RC.js";
-import "./chunk-WELDCG6C.js";
-import "./chunk-ZYVPLJ4T.js";
+import "./chunk-JBPKEARU.js";
+import "./chunk-TMSXWOBZ.js";
+import "./chunk-J64TK33U.js";
+import "./chunk-RSUYKGGZ.js";
+import "./chunk-42NQ7AVG.js";
+import "./chunk-7RXCMVFQ.js";
+import "./chunk-JYIKKAK3.js";
+import "./chunk-EAZGEEG2.js";
+import "./chunk-D24OXEPB.js";
+import "./chunk-3Q4H3OBR.js";
+import "./chunk-ETUPBUHB.js";
+import "./chunk-L227SKTB.js";
+import "./chunk-DHGSZ3UD.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-H7XKCNR6.js";
-import "./chunk-FBYESMQ2.js";
+import "./chunk-3C5RPJAX.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-FDU6HUUL.js";
-import "./chunk-QDZ2RLEC.js";
-import "./chunk-MGKYQQYF.js";
-import "./chunk-GL6I6MEQ.js";
-import "./chunk-3APJ5EVB.js";
-import "./chunk-5UM2VJ6D.js";
-import "./chunk-76FLAAUC.js";
+import "./chunk-EDQVAMQI.js";
+import "./chunk-472U7RDF.js";
+import "./chunk-7Q3RCKAQ.js";
+import "./chunk-WSGF57U2.js";
+import "./chunk-XKIQZXUB.js";
+import "./chunk-UEY3VB6W.js";
+import "./chunk-2AN2L4NL.js";
 import "./chunk-EIR5VLIH.js";
-import "./chunk-PCUKNJAZ.js";
-import "./chunk-RRF5UOBJ.js";
-import "./chunk-NBNN5GOB.js";
+import "./chunk-JKV57BTN.js";
+import "./chunk-EI6V5UXY.js";
+import "./chunk-QY7YA7OL.js";
 import "./chunk-NNVTUXEB.js";
 import "./chunk-QDW3E4RD.js";
-import "./chunk-25MQ7IHJ.js";
-import "./chunk-GDFS42HT.js";
-import "./chunk-U3PN77QT.js";
-import "./chunk-RK2Y4XOM.js";
+import "./chunk-EUML3N6B.js";
+import "./chunk-CHCA44C3.js";
+import "./chunk-4JRRISLU.js";
 import "./chunk-2LSZVONP.js";
-import "./chunk-WIICJPET.js";
-import "./chunk-SIC6U3GZ.js";
-import "./chunk-VBJ7V5SK.js";
+import "./chunk-DEUNUKTD.js";
+import "./chunk-YHV3KRKS.js";
+import "./chunk-UIPDNLXA.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-NN2DKE4T.js";
-import "./chunk-Q7P4WJDP.js";
+import "./chunk-4H5ZJHEN.js";
+import "./chunk-M5T4Q2ZU.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-3KW65B36.js";
+import "./chunk-KILOTVIF.js";
 import "./chunk-3HPAPHUK.js";
-import "./chunk-PFV5C235.js";
+import "./chunk-CPPS65WS.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-FAAFWE4G.js";
-import "./chunk-QRNI5JBH.js";
+import "./chunk-ALEPI75L.js";
 import "./chunk-ZY2MNJR6.js";
-import "./chunk-MY6TPVXW.js";
+import "./chunk-LMPHTYJC.js";
 import "./chunk-DT5TVLJE.js";
-import "./chunk-UWVJF25J.js";
+import "./chunk-HWVTS5NO.js";
+import "./chunk-U3PN77QT.js";
 import "./chunk-4DJQYKMN.js";
-import "./chunk-XIG5PDM7.js";
+import "./chunk-EYIEWJNI.js";
+import "./chunk-JUC24CTX.js";
 import "./chunk-TBBDFYXW.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-DGXUHMOV.js";
+import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
 import "./chunk-TVVEYCNW.js";
 import "./chunk-RFYAYKTD.js";
 import "./chunk-LBLXEFWK.js";
-import "./chunk-XKECPATV.js";
-import "./chunk-OC7KHOOX.js";
-import "./chunk-QA2ZAPBU.js";
-import "./chunk-WEHSQBFR.js";
-import "./chunk-KNKUID7G.js";
+import "./chunk-VFUEZZBS.js";
+import "./chunk-O27WNHTT.js";
+import "./chunk-IPLYGWQF.js";
 import "./chunk-J4EB7DNW.js";
+import "./chunk-WEHSQBFR.js";
+import "./chunk-X7Y7WX73.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
-import "./chunk-MG7NA5H3.js";
-import "./chunk-I6K5FBRQ.js";
-import "./chunk-AGZQD76C.js";
-import "./chunk-MXFBBHJU.js";
+import "./chunk-4Q73JBSM.js";
+import "./chunk-UI3NYK34.js";
+import "./chunk-GCGJW34D.js";
+import "./chunk-KJMYHC7K.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-AH2JUU6X.js";