@remnic/core 9.30.1 → 9.32.0

package/dist/chunk-YPC7W6GA.js

@@ -0,0 +1,1604 @@
+import {
+  resolveCodingNamespaceOverlay,
+  resolveScopeProfilePlan
+} from "./chunk-BUE5E2HL.js";
+import {
+  hasBroadGraphIntent,
+  planRecallMode
+} from "./chunk-PD6O7AXF.js";
+import {
+  parseQmdExplain
+} from "./chunk-ONHRRJZM.js";
+import {
+  buildCompressionGuidelinesMarkdown
+} from "./chunk-OD4FM2U7.js";
+import {
+  resolveLifecycleState
+} from "./chunk-TBBDFYXW.js";
+import {
+  parseFlexibleIsoTimestamp
+} from "./chunk-P7FMDTKL.js";
+import {
+  defaultNamespaceForPrincipal,
+  resolvePrincipal
+} from "./chunk-3GD2HFR6.js";
+import {
+  resolveMemoryLifecycleCapabilities,
+  resolvePresentationCapabilities
+} from "./chunk-2XRE6FLM.js";
+import {
+  abortError,
+  throwIfAborted
+} from "./chunk-PVGDJXVK.js";
+import {
+  categoryDirName
+} from "./chunk-VS2IYZRU.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/orchestration/orchestrator-helpers.ts
+import { createHash } from "crypto";
+import os from "os";
+import path from "path";
+var BulkImportBatchPartialFailureError = class extends Error {
+  partialResult;
+  originalError;
+  constructor(message, partialResult, originalError) {
+    super(message);
+    this.name = "BulkImportBatchPartialFailureError";
+    this.partialResult = partialResult;
+    this.originalError = originalError;
+  }
+};
+function mapRecallSourceToXrayServedBy(source) {
+  switch (source) {
+    case "recent_scan":
+      return "recent-scan";
+    case "hot_qmd":
+    case "hot_embedding":
+    case "cold_fallback":
+    case "none":
+      return "hybrid";
+  }
+  const _exhaustive = source;
+  void _exhaustive;
+  return "hybrid";
+}
+var abortRecallError = abortError;
+function throwIfRecallAborted(signal, message = "recall aborted") {
+  throwIfAborted(signal, message);
+}
+async function raceRecallAbort(promise, signal, message = "recall aborted") {
+  throwIfRecallAborted(signal, message);
+  if (!signal) return promise;
+  let onAbort = null;
+  const abortPromise = new Promise((_resolve, reject) => {
+    onAbort = () => reject(abortRecallError(message));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([promise, abortPromise]);
+  } finally {
+    if (onAbort) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+}
+var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
+var DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 1e4;
+function normalizeIanaTimeZone(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: trimmed });
+    return trimmed;
+  } catch {
+    return void 0;
+  }
+}
+function formatDateInTimeZone(date, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(date);
+  const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+function utcDateKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function utcDateKeysAround(date) {
+  const dayMs = 864e5;
+  const keys = [
+    utcDateKey(new Date(date.getTime() - dayMs)),
+    utcDateKey(date),
+    utcDateKey(new Date(date.getTime() + dayMs))
+  ];
+  return keys.filter((value, index, array) => array.indexOf(value) === index);
+}
+function utcDateKeysForLocalDay(date, timeZone) {
+  const targetLocalDate = formatDateInTimeZone(date, timeZone);
+  const keys = /* @__PURE__ */ new Set();
+  const hourMs = 36e5;
+  const scanStart = date.getTime() - 48 * hourMs;
+  const scanEnd = date.getTime() + 48 * hourMs;
+  for (let ms = scanStart; ms <= scanEnd; ms += hourMs) {
+    const candidate = new Date(ms);
+    if (formatDateInTimeZone(candidate, timeZone) === targetLocalDate) {
+      keys.add(utcDateKey(candidate));
+    }
+  }
+  return keys.size > 0 ? [...keys].sort() : utcDateKeysAround(date);
+}
+function parseFiniteDate(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return null;
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.getTime()) ? parsed : null;
+}
+function filterHourlySummaryMarkdownForLocalDay(raw, utcDate, timeZone, targetLocalDate) {
+  const hourHeaderPattern = /^## ([01]\d|2[0-3]):00[ \t]*$/gm;
+  const matches = Array.from(raw.matchAll(hourHeaderPattern));
+  if (matches.length === 0) return null;
+  const firstSectionStart = matches[0]?.index ?? 0;
+  const preamble = raw.slice(0, firstSectionStart).trim();
+  const sections = [];
+  for (let index = 0; index < matches.length; index += 1) {
+    const match = matches[index];
+    const hour = match[1];
+    if (!hour) continue;
+    const sectionTimestamp = parseFiniteDate(`${utcDate}T${hour}:00:00.000Z`);
+    if (!sectionTimestamp || formatDateInTimeZone(sectionTimestamp, timeZone) !== targetLocalDate) {
+      continue;
+    }
+    const sectionStart = match.index ?? 0;
+    const sectionEnd = matches[index + 1]?.index ?? raw.length;
+    const section = raw.slice(sectionStart, sectionEnd).trim();
+    if (section.length > 0) sections.push(section);
+  }
+  if (sections.length === 0) return null;
+  return [preamble, ...sections].filter((section) => section.length > 0).join("\n\n");
+}
+function qmdStartupCollectionCheckTimeoutMs() {
+  const raw = process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS ?? process.env.ENGRAM_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+  if (raw === void 0) return DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 1e3 ? Math.floor(parsed) : DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+}
+async function qmdStartupCollectionCheckWithTimeout(promise, controller, label) {
+  const timeoutMs = qmdStartupCollectionCheckTimeoutMs();
+  let timer;
+  let settled = false;
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      if (settled) return;
+      controller.abort();
+      log.warn(
+        `QMD startup collection check for ${label} timed out after ${timeoutMs}ms; keeping search enabled fail-open`
+      );
+      resolve("unknown");
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  const checkedPromise = promise.catch((err) => {
+    log.warn(
+      `QMD startup collection check for ${label} failed; keeping search enabled fail-open: ${err}`
+    );
+    return "unknown";
+  }).finally(() => {
+    settled = true;
+    if (timer) clearTimeout(timer);
+  });
+  return await Promise.race([checkedPromise, timeoutPromise]);
+}
+function defaultWorkspaceDir() {
+  return path.join(os.homedir(), ".openclaw", "workspace");
+}
+function sanitizeSessionKeyForFilename(sessionKey) {
+  const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash("sha256").update(sessionKey).digest("hex").slice(0, 12);
+  return `${readable}-${hash}`;
+}
+function sourceValidAtMs(turn) {
+  if (typeof turn.sourceValidAt !== "string") return null;
+  return parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
+}
+var SOURCE_VALID_AT_CONTEXT_TURNS = 2;
+function sourceValidAtSliceKey(turn, index) {
+  const validAtMs = sourceValidAtMs(turn);
+  return validAtMs === null ? `unknown:${index}` : String(validAtMs);
+}
+function asExtractionContextTurn(turn) {
+  return { ...turn, extractionContextOnly: true };
+}
+function asExtractionTargetTurn(turn) {
+  const { extractionContextOnly: _contextOnly, ...targetTurn } = turn;
+  return targetTurn;
+}
+function sourceValidAtContextTurns(turns, targetStart, targetEnd, targetValidAtMs) {
+  if (targetValidAtMs === null) return [];
+  return turns.flatMap((turn, index) => {
+    if (index >= targetStart && index < targetEnd) return [];
+    const contextValidAtMs = sourceValidAtMs(turn);
+    if (contextValidAtMs === null || contextValidAtMs > targetValidAtMs) {
+      return [];
+    }
+    return [{ turn, index, validAtMs: contextValidAtMs }];
+  }).sort((a, b) => {
+    if (a.validAtMs < b.validAtMs) return -1;
+    if (a.validAtMs > b.validAtMs) return 1;
+    if (a.index === b.index) return 0;
+    return a.index < b.index ? -1 : 1;
+  }).slice(-SOURCE_VALID_AT_CONTEXT_TURNS).map(({ turn }) => asExtractionContextTurn(turn));
+}
+function targetSourceValidAtSortMs(turns) {
+  let latestMs = null;
+  for (const turn of turns) {
+    if (turn.extractionContextOnly === true) continue;
+    const validAtMs = sourceValidAtMs(turn);
+    if (validAtMs === null) continue;
+    if (latestMs === null || validAtMs > latestMs) {
+      latestMs = validAtMs;
+    }
+  }
+  return latestMs ?? Number.POSITIVE_INFINITY;
+}
+function sortSourceValidAtSlicesChronologically(slices) {
+  return slices.map((turns, order) => ({
+    turns,
+    order,
+    targetValidAtMs: targetSourceValidAtSortMs(turns)
+  })).sort((a, b) => {
+    if (a.targetValidAtMs < b.targetValidAtMs) return -1;
+    if (a.targetValidAtMs > b.targetValidAtMs) return 1;
+    if (a.order === b.order) return 0;
+    return a.order < b.order ? -1 : 1;
+  }).map((slice) => slice.turns);
+}
+function splitTurnsBySourceValidAt(turns, options = {}) {
+  if (turns.length === 0) return [];
+  if (!turns.some((turn) => sourceValidAtMs(turn) !== null)) {
+    return [[...turns]];
+  }
+  const slices = [];
+  let start = 0;
+  while (start < turns.length) {
+    const targetValidAtMs = sourceValidAtMs(turns[start]);
+    const activeKey = sourceValidAtSliceKey(turns[start], start);
+    let end = start + 1;
+    while (end < turns.length && sourceValidAtSliceKey(turns[end], end) === activeKey) {
+      end += 1;
+    }
+    const contextTurns = options.includeContext === false ? [] : sourceValidAtContextTurns(turns, start, end, targetValidAtMs);
+    slices.push([
+      ...contextTurns,
+      ...turns.slice(start, end).map(asExtractionTargetTurn)
+    ]);
+    start = end;
+  }
+  return sortSourceValidAtSlicesChronologically(slices);
+}
+function isArtifactMemoryPath(filePath) {
+  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
+}
+function isMeetingRecordPath(filePath) {
+  return /(?:^|[\\/])meetings[\\/]\d{4}-\d{2}-\d{2}[\\/]mtg-\d{4}-\d{2}-\d{2}-[0-9a-f]{8}\.md$/i.test(filePath);
+}
+var ACTIVITY_DIGEST_TOPLEVEL = /^activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
+var ACTIVITY_DIGEST_ANYWHERE = /(?:^|[\\/])activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
+function isActivityDigestPath(filePath, memoryRoot) {
+  if (memoryRoot !== void 0 && memoryRoot.length > 0) {
+    const relative = path.relative(memoryRoot, path.resolve(memoryRoot, filePath));
+    return ACTIVITY_DIGEST_TOPLEVEL.test(relative);
+  }
+  return ACTIVITY_DIGEST_ANYWHERE.test(filePath);
+}
+function buildCompressionGuidelinesMarkdown2(events, generatedAtIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  return buildCompressionGuidelinesMarkdown(events, generatedAtIso);
+}
+function applyQueryAwareCandidateFilter(candidates, candidatePaths) {
+  if (!candidatePaths) return candidates;
+  if (candidatePaths.size === 0) return [];
+  const filtered = candidates.filter(
+    (candidate) => candidatePaths.has(candidate.path)
+  );
+  return filtered.length > 0 ? filtered : candidates;
+}
+function tokenizeRecallQuery(prompt) {
+  return prompt.toLowerCase().split(/[^a-z0-9]+/i).map((t) => t.trim()).filter((t) => t.length >= 3);
+}
+function hasLifecycleMetadata(frontmatter) {
+  return frontmatter.lifecycleState !== void 0 || frontmatter.verificationState !== void 0 || frontmatter.policyClass !== void 0 || frontmatter.lastValidatedAt !== void 0 || frontmatter.decayScore !== void 0 || frontmatter.heatScore !== void 0;
+}
+function shouldFilterLifecycleRecallCandidate(frontmatter, options) {
+  if (!options.lifecyclePolicyEnabled || !options.lifecycleFilterStaleEnabled)
+    return false;
+  if (!hasLifecycleMetadata(frontmatter)) return false;
+  const lifecycleState = resolveLifecycleState(frontmatter);
+  return lifecycleState === "stale" || lifecycleState === "archived";
+}
+function lifecycleRecallScoreAdjustment(frontmatter, options) {
+  if (!options.lifecyclePolicyEnabled) return 0;
+  if (!hasLifecycleMetadata(frontmatter)) return 0;
+  let delta = 0;
+  const lifecycleState = resolveLifecycleState(frontmatter);
+  switch (lifecycleState) {
+    case "active":
+      delta += 0.05;
+      break;
+    case "validated":
+      delta += 0.03;
+      break;
+    case "candidate":
+      delta -= 0.01;
+      break;
+    case "stale":
+      delta -= 0.06;
+      break;
+    case "archived":
+      delta -= 0.08;
+      break;
+  }
+  if (frontmatter.verificationState === "disputed") {
+    delta -= 0.12;
+  }
+  return delta;
+}
+function computeArtifactRecallLimit(recallMode, recallResultLimit, verbatimArtifactsMaxRecall) {
+  if (recallMode === "no_recall") return 0;
+  if (Math.max(0, recallResultLimit) === 0) return 0;
+  const base = Math.max(0, verbatimArtifactsMaxRecall);
+  if (recallMode === "minimal") {
+    return Math.min(base, Math.max(0, recallResultLimit));
+  }
+  return base;
+}
+function resolveEffectiveRecallMode(options) {
+  return resolveRecallModeDecision(options).effectiveMode;
+}
+function finalizeRecallModeDecision(plannedModeRaw, options) {
+  let plannedMode = plannedModeRaw;
+  const graphExpandedIntentDetected = options.plannerEnabled && options.graphExpandedIntentEnabled === true && hasBroadGraphIntent(options.prompt);
+  if (plannedMode !== "graph_mode" && graphExpandedIntentDetected) {
+    plannedMode = "graph_mode";
+  }
+  if (plannedMode === "graph_mode" && (!options.graphRecallEnabled || !options.multiGraphMemoryEnabled)) {
+    return {
+      plannedMode,
+      effectiveMode: "full",
+      graphExpandedIntentDetected,
+      graphReason: !options.graphRecallEnabled ? "graph recall disabled by config" : "multi-graph memory disabled by config"
+    };
+  }
+  return {
+    plannedMode,
+    effectiveMode: plannedMode,
+    graphExpandedIntentDetected
+  };
+}
+function resolveRecallModeDecision(options) {
+  const plannedMode = options.plannerEnabled ? planRecallMode(options.prompt) : "full";
+  return finalizeRecallModeDecision(plannedMode, options);
+}
+async function resolveRecallModeDecisionAsync(options) {
+  const heuristicDecision = resolveRecallModeDecision(options);
+  const plannerLlmEnabled = options.caps.recallPlannerLlm;
+  if (!options.plannerEnabled || !plannerLlmEnabled) {
+    return heuristicDecision;
+  }
+  const { planRecallModeLLM } = await import("./recall-planner-llm.js");
+  const planned = await planRecallModeLLM(
+    options.prompt,
+    options.hints,
+    options.config,
+    options.caps,
+    options.llm,
+    options.signal
+  );
+  if (options.config.recallPlannerShadowMode) {
+    return {
+      ...heuristicDecision,
+      plannerSource: planned.source,
+      plannerReason: `shadow:${planned.reason}`,
+      plannerLatencyMs: planned.latencyMs,
+      plannerFallbackUsed: planned.fallbackUsed,
+      plannerModelUsed: planned.modelUsed,
+      plannerHeuristicMode: planned.heuristicMode,
+      shadowLlmMode: planned.mode
+    };
+  }
+  const llmDecision = finalizeRecallModeDecision(planned.mode, options);
+  return {
+    ...llmDecision,
+    plannerSource: planned.source,
+    plannerReason: planned.reason,
+    plannerLatencyMs: planned.latencyMs,
+    plannerFallbackUsed: planned.fallbackUsed,
+    plannerModelUsed: planned.modelUsed,
+    plannerHeuristicMode: planned.heuristicMode
+  };
+}
+function computeArtifactCandidateFetchLimit(targetCount) {
+  const cappedTarget = Math.max(0, targetCount);
+  if (cappedTarget === 0) return 0;
+  const headroom = Math.max(8, cappedTarget * 4);
+  return Math.min(200, cappedTarget + headroom);
+}
+function computeQmdHybridFetchLimit(recallFetchLimit, artifactsEnabled, maxArtifactRecall) {
+  const cappedRecallLimit = Math.max(0, recallFetchLimit);
+  if (cappedRecallLimit === 0) return 0;
+  if (!artifactsEnabled) return cappedRecallLimit;
+  const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
+  return Math.min(400, cappedRecallLimit + artifactHeadroom);
+}
+function summarizeGraphShadowComparison(baseline, merged, topN) {
+  const limit = Math.max(0, Math.floor(topN));
+  const baselineTop = limit > 0 ? baseline.slice(0, limit) : [];
+  const graphTop = limit > 0 ? merged.slice(0, limit) : [];
+  const baselineByPath = new Map(
+    baselineTop.map((item) => [item.path, item.score])
+  );
+  const graphByPath = new Map(graphTop.map((item) => [item.path, item.score]));
+  let overlapCount = 0;
+  let overlapDeltaSum = 0;
+  for (const [p, baselineScore] of baselineByPath.entries()) {
+    const graphScore = graphByPath.get(p);
+    if (typeof graphScore !== "number") continue;
+    overlapCount += 1;
+    overlapDeltaSum += graphScore - baselineScore;
+  }
+  const baselineCount = baselineTop.length;
+  return {
+    baselineCount,
+    graphCount: graphTop.length,
+    overlapCount,
+    overlapRatio: baselineCount > 0 ? overlapCount / baselineCount : 0,
+    averageOverlapDelta: overlapCount > 0 ? overlapDeltaSum / overlapCount : 0
+  };
+}
+function parseGraphRecallRankedResults(value) {
+  if (!Array.isArray(value)) return [];
+  const parsed = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const candidate = entry;
+    if (typeof candidate.path !== "string" || typeof candidate.score !== "number")
+      continue;
+    parsed.push({
+      path: candidate.path,
+      score: candidate.score,
+      docid: typeof candidate.docid === "string" ? candidate.docid : void 0,
+      sourceLabels: Array.isArray(candidate.sourceLabels) ? candidate.sourceLabels.filter(
+        (item) => typeof item === "string"
+      ) : []
+    });
+  }
+  return parsed.slice(0, 64);
+}
+function parseMemoryIntentSnapshot(value) {
+  const candidate = value && typeof value === "object" ? value : {};
+  return {
+    goal: typeof candidate.goal === "string" ? candidate.goal : "unknown",
+    actionType: typeof candidate.actionType === "string" ? candidate.actionType : "unknown",
+    entityTypes: Array.isArray(candidate.entityTypes) ? candidate.entityTypes.filter(
+      (item) => typeof item === "string"
+    ) : [],
+    taskInitiation: candidate.taskInitiation === true
+  };
+}
+function buildQmdIntentHint(intent) {
+  const parts = [];
+  if (intent.goal !== "unknown") {
+    parts.push(`goal:${intent.goal.replace(/_/g, " ")}`);
+  }
+  if (intent.actionType !== "unknown") {
+    parts.push(`action:${intent.actionType.replace(/_/g, " ")}`);
+  }
+  if (intent.entityTypes.length > 0) {
+    parts.push(`entities:${intent.entityTypes.join(",")}`);
+  }
+  if (intent.taskInitiation === true) {
+    parts.push("task_initiation");
+  }
+  return parts.length > 0 ? parts.join(" ") : void 0;
+}
+function parseQmdRecallResults(value) {
+  if (!Array.isArray(value)) return [];
+  const parsed = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const candidate = entry;
+    if (typeof candidate.path !== "string" || typeof candidate.score !== "number")
+      continue;
+    parsed.push({
+      docid: typeof candidate.docid === "string" ? candidate.docid : "",
+      path: candidate.path,
+      snippet: typeof candidate.snippet === "string" ? candidate.snippet : "",
+      score: candidate.score,
+      explain: parseQmdExplain(candidate.explain),
+      transport: candidate.transport === "daemon" || candidate.transport === "subprocess" || candidate.transport === "hybrid" || candidate.transport === "scoped_prefilter" ? candidate.transport : void 0
+    });
+  }
+  return parsed.slice(0, 32);
+}
+function mergeArtifactRecallCandidates(candidatesByNamespace, limit) {
+  const cappedLimit = Math.max(0, limit);
+  if (cappedLimit === 0) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  let offset = 0;
+  while (out.length < cappedLimit) {
+    let hasAnyCandidateAtOffset = false;
+    for (const list of candidatesByNamespace) {
+      if (offset >= list.length) continue;
+      hasAnyCandidateAtOffset = true;
+      const item = list[offset];
+      const dedupeKey = `${item.frontmatter.id}:${item.frontmatter.sourceMemoryId ?? ""}:${item.content}`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      out.push(item);
+      if (out.length >= cappedLimit) break;
+    }
+    if (!hasAnyCandidateAtOffset) break;
+    offset += 1;
+  }
+  return out;
+}
+function resolveRecentThreadMemoryPaths(options) {
+  const maxRecent = Math.max(0, options.maxRecent);
+  if (options.threadEpisodeIds.length === 0 || maxRecent === 0) return [];
+  const pathById = options.pathById ?? buildMemoryPathById(options.allMemsForGraph, options.storageDir);
+  if (pathById.size === 0) return [];
+  const pendingReviewIds = new Set(
+    (options.allMemsForGraph ?? []).filter((m) => m.frontmatter.status === "pending_review" && m.frontmatter.id).map((m) => m.frontmatter.id)
+  );
+  return options.threadEpisodeIds.filter((id) => id !== options.currentMemoryId).filter((id) => !pendingReviewIds.has(id)).slice(-maxRecent).map((id) => pathById.get(id)).filter((p) => typeof p === "string" && p.length > 0);
+}
+function buildMemoryPathById(allMemsForGraph, storageDir) {
+  const pathById = /* @__PURE__ */ new Map();
+  for (const mem of allMemsForGraph ?? []) {
+    const id = mem.frontmatter.id;
+    if (!id) continue;
+    pathById.set(id, path.relative(storageDir, mem.path));
+  }
+  return pathById;
+}
+function appendMemoryToGraphContext(options) {
+  if (!Array.isArray(options.allMemsForGraph)) return;
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  options.allMemsForGraph.push({
+    path: path.join(options.storageDir, options.memoryRelPath),
+    content: options.content,
+    frontmatter: {
+      id: options.memoryId,
+      category: options.category,
+      created: nowIso,
+      updated: nowIso,
+      source: "extraction",
+      confidence: 0.8,
+      confidenceTier: "implied",
+      tags: [],
+      entityRef: options.entityRef,
+      status: "active"
+    }
+  });
+}
+function resolvePersistedMemoryRelativePath(options) {
+  const persisted = options.pathById.get(options.memoryId);
+  if (persisted) return persisted;
+  if (options.category === "correction") {
+    return path.join("corrections", `${options.memoryId}.md`);
+  }
+  const subtree = categoryDirName(options.category);
+  const idParts = options.memoryId.split("-");
+  const maybeTimestamp = Number(idParts[1]);
+  if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
+    const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
+    return path.join(subtree, day, `${options.memoryId}.md`);
+  }
+  return path.join(subtree, `${options.memoryId}.md`);
+}
+
+// src/orchestration/extraction-run-helpers.ts
+function combineExtractionAbortSignals(primary, deadlineController) {
+  if (!deadlineController) return primary;
+  return primary ? AbortSignal.any([primary, deadlineController.signal]) : deadlineController.signal;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function deriveTopicsFromExtraction(result) {
+  if (!isRecord(result)) return [];
+  const topics = /* @__PURE__ */ new Set();
+  const facts = Array.isArray(result.facts) ? result.facts : [];
+  for (const rawFact of facts) {
+    if (!isRecord(rawFact)) continue;
+    const tags = Array.isArray(rawFact.tags) ? rawFact.tags : [];
+    for (const tag of tags) {
+      if (typeof tag === "string" && tag.length >= 2) topics.add(tag.toLowerCase());
+    }
+    if (typeof rawFact.entityRef === "string" && rawFact.entityRef.length >= 2) {
+      topics.add(rawFact.entityRef.toLowerCase());
+    }
+    if (typeof rawFact.category === "string" && rawFact.category.length > 0) {
+      topics.add(rawFact.category);
+    }
+  }
+  const entities = Array.isArray(result.entities) ? result.entities : [];
+  for (const rawEntity of entities) {
+    if (!isRecord(rawEntity)) continue;
+    if (typeof rawEntity.name === "string" && rawEntity.name.length >= 2) {
+      topics.add(rawEntity.name.toLowerCase());
+    }
+  }
+  return [...topics].slice(0, 16);
+}
+var EXTRACTION_RETRY_STATE_MAX_ENTRIES = 500;
+function computeExtractionRetryNextEligibleMs(attempts, scheduleMs, maxBackoffMs, jitterRatio, now, rng = Math.random) {
+  if (!Number.isFinite(attempts) || !Number.isInteger(attempts) || attempts < 1) {
+    throw new RangeError("attempts must be a finite integer >= 1");
+  }
+  if (!Number.isFinite(maxBackoffMs) || maxBackoffMs < 0) {
+    throw new RangeError("maxBackoffMs must be a finite number >= 0");
+  }
+  if (!Number.isFinite(jitterRatio) || jitterRatio < 0 || jitterRatio > 1) {
+    throw new RangeError("jitterRatio must be a finite number in [0, 1]");
+  }
+  const safeNow = Number.isFinite(now) ? now : 0;
+  const cap = maxBackoffMs;
+  if (!Array.isArray(scheduleMs) || scheduleMs.length === 0) {
+    return safeNow + cap;
+  }
+  const idx = Math.min(attempts - 1, scheduleMs.length - 1);
+  const step = scheduleMs[idx];
+  const base = Math.min(typeof step === "number" && Number.isFinite(step) && step > 0 ? step : cap, cap);
+  const randomValue = rng();
+  if (!Number.isFinite(randomValue) || randomValue < 0 || randomValue > 1) {
+    throw new RangeError("rng() must return a finite number in [0, 1]");
+  }
+  const jitter = 1 + (randomValue * 2 - 1) * jitterRatio;
+  return safeNow + Math.max(0, Math.round(base * jitter));
+}
+function capExtractionRetryStateEntries(entries, maxEntries) {
+  if (!Number.isFinite(maxEntries) || !Number.isInteger(maxEntries) || maxEntries <= 0) return [];
+  const sorted = [...entries].sort((a, b) => a.firstFailedAt.localeCompare(b.firstFailedAt));
+  return sorted.slice(-maxEntries);
+}
+function deriveSourceConnector(turns) {
+  if (turns.length === 0) return void 0;
+  const connectors = /* @__PURE__ */ new Set();
+  let untaggedCount = 0;
+  for (const turn of turns) {
+    if (typeof turn.sourceConnector === "string" && turn.sourceConnector.length > 0) {
+      connectors.add(turn.sourceConnector);
+    } else {
+      untaggedCount += 1;
+    }
+  }
+  if (untaggedCount > 0) return void 0;
+  return connectors.size === 1 ? [...connectors][0] : void 0;
+}
+async function runExtractionPostPersistBestEffort(runDeadlineAware, stage, operation, options) {
+  try {
+    await runDeadlineAware(operation, stage, false, {
+      ignoreAbort: options?.ignoreAbort,
+      ignoreDeadline: options?.ignoreDeadline
+    });
+  } catch (error) {
+    if (options?.propagateErrors) throw error;
+    log.warn(`runExtraction: ${stage} failed after persistence (non-fatal)`, error);
+  }
+}
+async function runExtractionDeferRetention(runPostPersistBestEffort, options) {
+  await runPostPersistBestEffort("during_defer_retention", async () => {
+    if (options.clearBufferAfterExtraction && !options.extractionJudgeShadow) {
+      const deferredCount = options.getDeferredCount();
+      if (deferredCount > 0 && options.normalizedTurns.length > 0) {
+        await options.retainDeferredTurns(options.bufferKey, options.normalizedTurns, 10);
+      } else {
+        await options.retainDeferredTurns(options.bufferKey, [], 0);
+      }
+    }
+  });
+}
+async function runExtractionPostPersist(options) {
+  let metadataFailed = false;
+  let deadlineError;
+  const recordFailure = (stage, error) => {
+    metadataFailed = true;
+    if (options.isDeadlineError(error) && deadlineError === void 0) {
+      deadlineError = error;
+    }
+    log.warn(`runExtraction: ${stage} failed after durable persistence; continuing with buffer clear`, error);
+  };
+  let meta = options.meta;
+  try {
+    meta ??= await options.runDeadlineAware(
+      () => options.storage.loadMeta(),
+      "during_post_persist_load_meta",
+      false
+    );
+  } catch (error) {
+    recordFailure("metadata load", error);
+  }
+  if (meta && options.extractionFingerprint && options.shouldPersistProcessedFingerprint) {
+    try {
+      await options.runDeadlineAware(
+        () => options.recordProcessedExtractionFingerprint(options.storage, options.extractionFingerprint, meta),
+        "during_post_persist_fingerprint",
+        false
+      );
+    } catch (error) {
+      recordFailure("processed fingerprint", error);
+    }
+  }
+  if (meta) {
+    meta.extractionCount += 1;
+    meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
+    meta.totalMemories += Array.isArray(options.result.facts) ? options.result.facts.length : 0;
+    meta.totalEntities += Array.isArray(options.result.entities) ? options.result.entities.length : 0;
+    try {
+      await options.runDeadlineAware(
+        () => options.storage.saveMeta(meta),
+        "during_post_persist_meta_save",
+        false
+      );
+    } catch (error) {
+      recordFailure("metadata save", error);
+    }
+  }
+  const runBestEffort = options.runPostPersistBestEffort;
+  await runExtractionDeferRetention(runBestEffort, {
+    clearBufferAfterExtraction: options.clearBufferAfterExtraction,
+    extractionJudgeShadow: options.extractionJudgeShadow,
+    getDeferredCount: options.getDeferredCount,
+    normalizedTurns: options.normalizedTurns,
+    bufferKey: options.bufferKey,
+    retainDeferredTurns: options.retainDeferredTurns
+  });
+  await runBestEffort(
+    "during_buffer_clear",
+    () => options.clearBuffer({ ignoreAbort: true }),
+    {
+      ignoreAbort: true,
+      ignoreDeadline: options.failOnExtractionFailure,
+      propagateErrors: options.failOnExtractionFailure
+    }
+  );
+  if (options.failOnExtractionFailure && typeof options.deadlineMs === "number" && Date.now() >= options.deadlineMs) {
+    throw options.createDeadlineError("during_buffer_clear");
+  }
+  if (deadlineError) throw deadlineError;
+  return { meta, metadataFailed };
+}
+
+// src/orchestration/extraction-run.ts
+import { createHash as createHash2 } from "crypto";
+var ExtractionDeadlineError = class extends Error {
+  stage;
+  constructor(stage) {
+    super(`replay extraction deadline exceeded (${stage})`);
+    this.name = "ExtractionDeadlineError";
+    this.stage = stage;
+  }
+};
+var ExtractionRunCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  recentExtractionFingerprints = /* @__PURE__ */ new Map();
+  // Per-fingerprint extraction retry/backoff state (extraction hot-loop
+  // hardening). Outer key = namespace, inner key = fingerprint. Hydrated lazily
+  // from namespace-scoped meta so the hot path is a Map lookup; persisted back
+  // to meta on change (restart-safe, cross-process coherent via the shared
+  // meta.json). The breaker below is intentionally per-process in-memory
+  // (mirrors local-llm.cooldownUntilMs); a restart clears it but the persisted
+  // backoff still throttles, so a restart can't resurrect the hot loop.
+  extractionRetryState = /* @__PURE__ */ new Map();
+  hydratedRetryNamespaces = /* @__PURE__ */ new Set();
+  providerBreaker = { consecutiveFailures: 0, openUntilMs: 0, state: "closed", lastReason: "" };
+  get config() {
+    return this.deps.config;
+  }
+  // -------------------------------------------------------------------------
+  // Source-valid-at helpers (moved from orchestrator.ts module scope)
+  // -------------------------------------------------------------------------
+  latestSourceValidAtFromTurns(turns) {
+    let latestMs = null;
+    for (const turn of turns) {
+      if (turn.extractionContextOnly === true) continue;
+      if (typeof turn.sourceValidAt !== "string") continue;
+      const parsed = parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
+      if (parsed === null) continue;
+      if (latestMs === null || parsed > latestMs) {
+        latestMs = parsed;
+      }
+    }
+    return latestMs === null ? void 0 : new Date(latestMs).toISOString();
+  }
+  // -------------------------------------------------------------------------
+  // Extraction dedupe fingerprint helpers
+  // -------------------------------------------------------------------------
+  normalizeExtractionFingerprintTurns(turns) {
+    if (!Array.isArray(turns) || turns.length === 0) return [];
+    return turns.filter((turn) => turn.role === "user" || turn.role === "assistant").map((turn) => {
+      if (typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0) {
+        return `fp:${turn.turnFingerprint}`;
+      }
+      return `${turn.role}:${(turn.content ?? "").replace(/\s+/g, " ").trim().slice(0, this.config.extractionMaxTurnChars)}`;
+    }).filter((value) => value.length > 0);
+  }
+  buildExtractionFingerprint(turns, bufferKey) {
+    const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
+    if (!normalized) return null;
+    return createHash2("sha256").update(`${bufferKey}
+${normalized}`).digest("hex");
+  }
+  shouldQueueExtraction(turns, options = {}) {
+    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
+    if (!lifecycleCaps.extractionDedupe) return true;
+    if (!Array.isArray(turns) || turns.length === 0) return false;
+    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
+    const fingerprint = this.buildExtractionFingerprint(turns, bufferKey);
+    if (!fingerprint) return false;
+    const now = Date.now();
+    const seenAt = this.recentExtractionFingerprints.get(fingerprint);
+    if (seenAt && now - seenAt < this.config.extractionDedupeWindowMs) {
+      log.debug("extraction dedupe: skipped duplicate buffered turn set");
+      return false;
+    }
+    if (options.commit !== false) {
+      this.recentExtractionFingerprints.set(fingerprint, now);
+    }
+    if (options.commit !== false && this.recentExtractionFingerprints.size > 200) {
+      const entries = Array.from(this.recentExtractionFingerprints.entries()).sort((a, b) => a[1] - b[1]);
+      for (const [key] of entries.slice(0, entries.length - 200)) {
+        this.recentExtractionFingerprints.delete(key);
+      }
+    }
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Processed-fingerprint recording
+  // -------------------------------------------------------------------------
+  async recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta) {
+    const meta = preloadedMeta ?? await storage.loadMeta();
+    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const seen = new Map(
+      (meta.processedExtractionFingerprints ?? []).map((entry) => [entry.fingerprint, entry.observedAt])
+    );
+    seen.set(fingerprint, observedAt);
+    meta.processedExtractionFingerprints = Array.from(seen.entries()).map(([value, at]) => ({ fingerprint: value, observedAt: at })).sort((left, right) => left.observedAt.localeCompare(right.observedAt)).slice(-500);
+    if (!preloadedMeta) {
+      await storage.saveMeta(meta);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
+  // -------------------------------------------------------------------------
+  /** Lazily hydrate the in-memory retry-state mirror for a namespace from meta.
+   *  One-time per namespace per coordinator; the hot path is then a Map lookup.
+   *  Cross-process coherence: a fresh coordinator hydrates from the shared
+   *  meta.json, so a failure persisted by another process is honored here. */
+  hydrateRetryStateFromMeta(namespace, meta) {
+    if (this.hydratedRetryNamespaces.has(namespace)) return;
+    this.hydratedRetryNamespaces.add(namespace);
+    const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
+    for (const entry of meta.extractionRetryState ?? []) {
+      const nextEligibleAtMs = Date.parse(entry.nextEligibleAt);
+      const firstFailedAtMs = Date.parse(entry.firstFailedAt);
+      nsMap.set(entry.fingerprint, {
+        attempts: entry.attempts,
+        nextEligibleAtMs: Number.isFinite(nextEligibleAtMs) ? nextEligibleAtMs : 0,
+        firstFailedAtMs: Number.isFinite(firstFailedAtMs) ? firstFailedAtMs : Date.now(),
+        lastFailureClass: entry.lastFailureClass
+      });
+    }
+    this.extractionRetryState.set(namespace, nsMap);
+  }
+  logBreakerTransition(state) {
+    log.warn("extraction: provider circuit breaker transition", {
+      state,
+      consecutiveFailures: this.providerBreaker.consecutiveFailures,
+      lastReason: this.providerBreaker.lastReason,
+      openUntilMs: this.providerBreaker.openUntilMs
+    });
+  }
+  /** True while the breaker suppresses non-forced attempts. Flips an expired
+   *  `open` breaker to `half_open`, which allows exactly one probe (the next
+   *  non-forced attempt) because the extraction queue is a serial drain. */
+  isProviderBreakerOpen(now) {
+    if (now < this.providerBreaker.openUntilMs) return true;
+    if (this.providerBreaker.state === "open") {
+      this.providerBreaker.state = "half_open";
+      this.logBreakerTransition("half_open");
+    }
+    return false;
+  }
+  onProviderFailure(cls, now) {
+    this.providerBreaker.consecutiveFailures += 1;
+    const trip = cls === "auth_config" || // A failed half-open probe re-opens immediately (standard breaker
+    // semantics). Without this, an auth_config-opened breaker (which trips
+    // below the threshold) would get stuck half_open after a transient
+    // probe failure and stop suppressing (cursor review).
+    this.providerBreaker.state === "half_open" || this.providerBreaker.consecutiveFailures >= this.config.extractionBreakerFailureThreshold;
+    if (!trip) return;
+    const cooldown = cls === "auth_config" ? this.config.extractionBreakerAuthCooldownMs : this.config.extractionBreakerCooldownMs;
+    this.providerBreaker.openUntilMs = now + Math.max(0, cooldown);
+    this.providerBreaker.lastReason = cls;
+    if (this.providerBreaker.state !== "open") {
+      this.providerBreaker.state = "open";
+      this.logBreakerTransition("open");
+    }
+  }
+  resetProviderBreakerOnSuccess() {
+    const wasDisturbed = this.providerBreaker.state !== "closed" || this.providerBreaker.consecutiveFailures > 0 || this.providerBreaker.openUntilMs > 0;
+    if (!wasDisturbed) return;
+    const wasOpen = this.providerBreaker.state !== "closed";
+    this.providerBreaker.consecutiveFailures = 0;
+    this.providerBreaker.openUntilMs = 0;
+    this.providerBreaker.lastReason = "";
+    this.providerBreaker.state = "closed";
+    if (wasOpen) this.logBreakerTransition("closed");
+  }
+  /** Rebuild `meta.extractionRetryState` from the in-memory namespace mirror,
+   *  bounded to the newest entries, and prune the mirror to match. */
+  persistRetryStateToMeta(namespace, meta) {
+    const nsMap = this.extractionRetryState.get(namespace);
+    const entries = nsMap ? Array.from(nsMap.entries()).map(([fingerprint, st]) => ({
+      fingerprint,
+      attempts: st.attempts,
+      nextEligibleAt: new Date(st.nextEligibleAtMs).toISOString(),
+      firstFailedAt: new Date(st.firstFailedAtMs).toISOString(),
+      lastFailureClass: st.lastFailureClass
+    })) : [];
+    const capped = capExtractionRetryStateEntries(entries, EXTRACTION_RETRY_STATE_MAX_ENTRIES);
+    meta.extractionRetryState = capped;
+    if (nsMap && capped.length < nsMap.size) {
+      const kept = new Set(capped.map((e) => e.fingerprint));
+      for (const key of Array.from(nsMap.keys())) {
+        if (!kept.has(key)) nsMap.delete(key);
+      }
+    }
+  }
+  /** Record an extraction failure into per-fingerprint backoff state + breaker,
+   *  persisting to namespace meta. Fail-open: never throws upward. */
+  async recordExtractionFailure(storage, namespace, fingerprint, cls, meta, now) {
+    try {
+      this.hydrateRetryStateFromMeta(namespace, meta);
+      const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
+      const prev = nsMap.get(fingerprint);
+      const attempts = (prev?.attempts ?? 0) + 1;
+      const firstFailedAtMs = prev?.firstFailedAtMs ?? now;
+      let nextEligibleAtMs;
+      if (cls === "parse_empty" && attempts > this.config.extractionParseEmptyMaxAttempts) {
+        nextEligibleAtMs = now + Math.max(0, this.config.extractionRetryMaxBackoffMs);
+      } else {
+        nextEligibleAtMs = computeExtractionRetryNextEligibleMs(
+          attempts,
+          this.config.extractionRetryScheduleMs,
+          this.config.extractionRetryMaxBackoffMs,
+          this.config.extractionRetryJitterRatio,
+          now
+        );
+      }
+      nsMap.set(fingerprint, { attempts, nextEligibleAtMs, firstFailedAtMs, lastFailureClass: cls });
+      this.extractionRetryState.set(namespace, nsMap);
+      this.onProviderFailure(cls, now);
+      this.persistRetryStateToMeta(namespace, meta);
+      await storage.saveMeta(meta);
+    } catch (err) {
+      log.warn("runExtraction: failed to record extraction retry state (non-fatal)", err);
+    }
+  }
+  /** Delete a fingerprint's retry entry from the mirror + meta. Returns whether
+   *  meta changed (so the caller can decide to persist). Does not touch the
+   *  breaker — callers pair this with `resetProviderBreakerOnSuccess`. */
+  clearExtractionRetryEntry(namespace, fingerprint, meta) {
+    const nsMap = this.extractionRetryState.get(namespace);
+    if (!nsMap?.has(fingerprint)) return false;
+    nsMap.delete(fingerprint);
+    this.persistRetryStateToMeta(namespace, meta);
+    return true;
+  }
+  /** Live in-process resilience snapshot (breaker + backoff population). */
+  getExtractionResilienceStatus() {
+    let backoffFingerprintCount = 0;
+    for (const nsMap of this.extractionRetryState.values()) {
+      backoffFingerprintCount += nsMap.size;
+    }
+    return {
+      breaker: {
+        state: this.providerBreaker.state,
+        openUntilMs: this.providerBreaker.openUntilMs,
+        consecutiveFailures: this.providerBreaker.consecutiveFailures,
+        lastReason: this.providerBreaker.lastReason
+      },
+      backoffFingerprintCount
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Main extraction pipeline
+  // -------------------------------------------------------------------------
+  async runExtraction(turns, options = {}) {
+    log.debug(`running extraction on ${turns.length} turns`);
+    const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
+    const clearMatchingTurns = options.clearMatchingTurns === true;
+    const skipCharThreshold = options.skipCharThreshold ?? false;
+    const skipUserTurnThreshold = options.skipUserTurnThreshold ?? false;
+    const deadlineMs = typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs) ? options.deadlineMs : void 0;
+    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
+    const throwIfDeadlineExceeded = (stage) => {
+      if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+        throw new ExtractionDeadlineError(stage);
+      }
+    };
+    const throwIfAborted2 = (stage) => {
+      throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
+    };
+    const runPassiveCapture = async (captureTurns, captureOptions) => {
+      const deadlineController = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) ? new AbortController() : void 0;
+      const captureSignal = combineExtractionAbortSignals(
+        captureOptions.abortSignal ?? options.abortSignal,
+        deadlineController
+      );
+      let deadlineTimer;
+      if (deadlineController && typeof deadlineMs === "number") {
+        const scheduleDeadlineAbort = () => {
+          const remainingMs = deadlineMs - Date.now();
+          if (remainingMs <= 0) {
+            deadlineController.abort();
+            return;
+          }
+          deadlineTimer = setTimeout(
+            () => {
+              if (Date.now() >= deadlineMs) {
+                deadlineController.abort();
+              } else {
+                scheduleDeadlineAbort();
+              }
+            },
+            Math.min(remainingMs, 2147483647)
+          );
+        };
+        scheduleDeadlineAbort();
+      }
+      try {
+        await raceRecallAbort(
+          this.deps.maybeCapturePassiveCorrections(captureTurns, {
+            ...captureOptions,
+            ...captureSignal ? { abortSignal: captureSignal } : {}
+          }),
+          captureSignal,
+          "extraction aborted (during_passive_capture)"
+        );
+      } catch (error) {
+        if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+          throw new ExtractionDeadlineError("during_passive_capture");
+        }
+        throw error;
+      } finally {
+        if (deadlineTimer) clearTimeout(deadlineTimer);
+      }
+    };
+    const clearBuffer = async (options2) => {
+      if (options2?.ignoreAbort !== true) {
+        throwIfDeadlineExceeded("before_clear_buffer");
+        throwIfAborted2("before_clear_buffer");
+      }
+      if (clearBufferAfterExtraction) {
+        await this.deps.getBuffer().clearAfterExtraction(bufferKey, turns, clearMatchingTurns ? { allowNonPrefix: true } : void 0);
+      }
+    };
+    const sessionKey = turns[0]?.sessionKey ?? "";
+    if (sessionKey.includes(":cron:")) {
+      log.debug(`skipping extraction for cron session: ${sessionKey}`);
+      await clearBuffer();
+      return {
+        status: "skipped",
+        reason: "cron_session",
+        persistedCount: 0,
+        durableOutputCount: 0
+      };
+    }
+    const normalizedTurns = turns.filter((t) => (t.role === "user" || t.role === "assistant") && typeof t.content === "string").map((t) => ({
+      ...t,
+      content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
+    })).filter((t) => t.content.length > 0);
+    const targetTurns = normalizedTurns.filter((turn) => turn.extractionContextOnly !== true);
+    if (targetTurns.length === 0) {
+      log.debug("skipping extraction: no non-context turns after normalization");
+      if (normalizedTurns.length > 0) {
+        throwIfDeadlineExceeded("before_context_only_capture");
+        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
+        const captureNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : this.deps.resolveSelfNamespace(sessionKey);
+        await runPassiveCapture(normalizedTurns, {
+          sessionKey,
+          principal: capturePrincipal,
+          namespace: captureNamespace,
+          bufferKey,
+          isLiveSession: clearBufferAfterExtraction
+        });
+        throwIfDeadlineExceeded("before_context_only_clear");
+      }
+      await clearBuffer();
+      return { status: "skipped", reason: "empty_normalized_turns", persistedCount: 0, durableOutputCount: 0 };
+    }
+    const sourceValidAt = this.latestSourceValidAtFromTurns(targetTurns);
+    throwIfDeadlineExceeded("before_extract");
+    throwIfAborted2("before_extract");
+    const userTurns = targetTurns.filter((t) => t.role === "user");
+    const totalChars = targetTurns.reduce((sum, t) => sum + t.content.length, 0);
+    const belowCharThreshold = totalChars < this.config.extractionMinChars;
+    const belowUserTurnThreshold = !skipUserTurnThreshold && userTurns.length < this.config.extractionMinUserTurns;
+    if (!skipCharThreshold && belowCharThreshold || belowUserTurnThreshold) {
+      log.debug(`skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`);
+      {
+        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
+        const captureWO = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
+        const captureCodingCtx = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
+        const captureCodingOv = resolveCodingNamespaceOverlay(
+          captureCodingCtx,
+          this.config.codingMode,
+          this.config.defaultNamespace
+        );
+        const captureScopePlan = resolveScopeProfilePlan({
+          config: this.config,
+          principal: capturePrincipal,
+          codingContext: captureCodingCtx,
+          codingOverlay: captureCodingOv
+        });
+        const captureNamespace = captureWO ?? captureScopePlan?.writeNamespace ?? this.deps.resolveSelfNamespace(sessionKey);
+        await runPassiveCapture(normalizedTurns, {
+          sessionKey,
+          principal: capturePrincipal,
+          namespace: captureNamespace,
+          bufferKey,
+          isLiveSession: clearBufferAfterExtraction
+        });
+      }
+      await clearBuffer();
+      return {
+        status: "skipped",
+        reason: "below_threshold",
+        persistedCount: 0,
+        durableOutputCount: 0
+      };
+    }
+    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
+    const explicitWriteNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
+    const codingContextForWrite = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
+    const codingOverlayForWrite = resolveCodingNamespaceOverlay(
+      codingContextForWrite,
+      this.config.codingMode,
+      this.config.defaultNamespace
+    );
+    const scopeProfileGatePlan = options.scopeProfileWritePlan !== void 0 ? options.scopeProfileWritePlan : resolveScopeProfilePlan({
+      config: this.config,
+      principal,
+      codingContext: codingContextForWrite,
+      codingOverlay: codingOverlayForWrite
+    });
+    const scopeProfileWritePlan = explicitWriteNamespace && options.scopeProfileWritePlan === void 0 ? null : scopeProfileGatePlan;
+    if (scopeProfileWritePlan) {
+      const selectedLayer = scopeProfileWritePlan.layers.find((layer) => layer.id === scopeProfileWritePlan.writeLayer);
+      const writeNamespaceReadable = scopeProfileWritePlan.readNamespaces.includes(
+        scopeProfileWritePlan.writeNamespace
+      );
+      if (!selectedLayer?.writable || !writeNamespaceReadable) {
+        log.warn(
+          `runExtraction: skipping scope profile ${scopeProfileWritePlan.profileId} because write layer ${scopeProfileWritePlan.writeLayer} is not writable inside the profile read stack`
+        );
+        await clearBuffer();
+        return {
+          status: "skipped",
+          reason: "scope_profile_no_writable_layer",
+          persistedCount: 0,
+          durableOutputCount: 0
+        };
+      }
+    }
+    const selfNamespace = explicitWriteNamespace ?? scopeProfileWritePlan?.writeNamespace ?? this.deps.applyCodingNamespaceOverlay(sessionKey, defaultNamespaceForPrincipal(principal, this.config));
+    const extractionDeadlineController = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) ? new AbortController() : void 0;
+    const extractionAbortSignal = extractionDeadlineController ? options.abortSignal ? AbortSignal.any([options.abortSignal, extractionDeadlineController.signal]) : extractionDeadlineController.signal : options.abortSignal;
+    let extractionDeadlineTimer;
+    const clearExtractionDeadlineTimer = () => {
+      if (extractionDeadlineTimer) {
+        clearTimeout(extractionDeadlineTimer);
+        extractionDeadlineTimer = void 0;
+      }
+    };
+    const runDeadlineAware = async (operation, phase, clearTimerOnError = true, options2 = {}) => {
+      const operationSignal = options2.ignoreAbort ? void 0 : extractionAbortSignal;
+      try {
+        if (!options2.ignoreDeadline && typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+          throwIfDeadlineExceeded(phase);
+        }
+        if (operationSignal?.aborted) {
+          throwIfAborted2(phase);
+        }
+        return await raceRecallAbort(
+          operation(),
+          operationSignal,
+          `extraction aborted (${phase})`
+        );
+      } catch (error) {
+        if (clearTimerOnError) clearExtractionDeadlineTimer();
+        if (!options2.ignoreDeadline && typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+          throw new ExtractionDeadlineError(phase);
+        }
+        throw error;
+      }
+    };
+    if (extractionDeadlineController && typeof deadlineMs === "number") {
+      const deadline = deadlineMs;
+      const maxTimerDelayMs = 2147483647;
+      const scheduleDeadlineAbort = () => {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          extractionDeadlineController.abort();
+          return;
+        }
+        extractionDeadlineTimer = setTimeout(() => {
+          if (Date.now() >= deadline) {
+            extractionDeadlineController.abort();
+          } else {
+            scheduleDeadlineAbort();
+          }
+        }, Math.min(remainingMs, maxTimerDelayMs));
+      };
+      scheduleDeadlineAbort();
+    }
+    const storage = await runDeadlineAware(
+      () => this.deps.getStorageRouter().storageFor(selfNamespace),
+      "during_storage"
+    );
+    const shouldPersistProcessedFingerprint = targetTurns.some((turn) => turn.persistProcessedFingerprint === true);
+    const extractionFingerprint = this.buildExtractionFingerprint(targetTurns, bufferKey);
+    let meta = extractionFingerprint && shouldPersistProcessedFingerprint ? await runDeadlineAware(() => storage.loadMeta(), "during_load_meta") : null;
+    if (extractionFingerprint && shouldPersistProcessedFingerprint && (meta?.processedExtractionFingerprints ?? []).some((entry) => entry.fingerprint === extractionFingerprint)) {
+      await runDeadlineAware(() => clearBuffer(), "during_clear_buffer");
+      clearExtractionDeadlineTimer();
+      return {
+        status: "skipped",
+        reason: "processed_fingerprint",
+        persistedCount: 0,
+        durableOutputCount: 0
+      };
+    }
+    const forcedExtractionAttempt = options.failOnExtractionFailure === true || options.forceExtractionAttempt === true;
+    const extractionRetryEnabled = resolveMemoryLifecycleCapabilities(this.config).extractionRetry;
+    if (extractionFingerprint && !forcedExtractionAttempt && extractionRetryEnabled) {
+      try {
+        meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_gate");
+        this.hydrateRetryStateFromMeta(selfNamespace, meta);
+        const nowMs = Date.now();
+        let suppressReason = null;
+        if (this.isProviderBreakerOpen(nowMs)) {
+          suppressReason = "provider_circuit_open";
+        } else {
+          const st = this.extractionRetryState.get(selfNamespace)?.get(extractionFingerprint);
+          if (st && nowMs < st.nextEligibleAtMs) suppressReason = "extraction_backoff";
+        }
+        if (suppressReason) {
+          try {
+            await runDeadlineAware(
+              () => runPassiveCapture(normalizedTurns, {
+                sessionKey,
+                principal,
+                namespace: selfNamespace,
+                bufferKey,
+                isLiveSession: clearBufferAfterExtraction
+              }),
+              "during_passive_capture"
+            );
+          } catch (captureErr) {
+            if (captureErr instanceof ExtractionDeadlineError) throw captureErr;
+            log.warn("runExtraction: passive correction capture failed on suppressed attempt (non-fatal)", captureErr);
+          }
+          clearExtractionDeadlineTimer();
+          return { status: "skipped", reason: suppressReason, persistedCount: 0, durableOutputCount: 0 };
+        }
+      } catch (err) {
+        if (err instanceof ExtractionDeadlineError) throw err;
+        log.warn("runExtraction: extraction retry gate check failed; proceeding (fail-open)", err);
+      }
+    }
+    const existingEntities = await runDeadlineAware(
+      () => storage.listEntityNames(),
+      "during_list_entity_names"
+    );
+    let result;
+    try {
+      result = await raceRecallAbort(
+        this.deps.getExtraction().extract(normalizedTurns, existingEntities, extractionAbortSignal),
+        extractionAbortSignal,
+        "extraction aborted (during_extract)"
+      );
+    } catch (error) {
+      clearExtractionDeadlineTimer();
+      if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+        throw new ExtractionDeadlineError("during_extract");
+      }
+      throw error;
+    }
+    try {
+      throwIfDeadlineExceeded("before_persist");
+      throwIfAborted2("before_persist");
+      if (!result) {
+        log.warn("runExtraction: extraction returned null/undefined");
+        if (options.failOnExtractionFailure) {
+          throw new Error("extraction failed: invalid_extraction_result");
+        }
+        await clearBuffer();
+        return {
+          status: "skipped",
+          reason: "invalid_extraction_result",
+          persistedCount: 0,
+          durableOutputCount: 0
+        };
+      }
+      const invalidExtractionResultFields = [
+        ["facts", result.facts],
+        ["entities", result.entities],
+        ["questions", result.questions],
+        ["profileUpdates", result.profileUpdates]
+      ].filter(([, value]) => !Array.isArray(value)).map(([field]) => field);
+      if (invalidExtractionResultFields.length > 0) {
+        log.warn("runExtraction: extraction returned invalid collection fields", {
+          invalidFields: invalidExtractionResultFields,
+          resultKeys: typeof result === "object" && result !== null ? Object.keys(result) : []
+        });
+        if (options.failOnExtractionFailure) {
+          throw new Error("extraction failed: invalid_extraction_result");
+        }
+        await clearBuffer();
+        return {
+          status: "skipped",
+          reason: "invalid_extraction_result",
+          persistedCount: 0,
+          durableOutputCount: 0
+        };
+      }
+      const extractionFailure = typeof result.extractionFailure === "string" && result.extractionFailure.trim().length > 0 ? result.extractionFailure : void 0;
+      let recordedRetryFailure = false;
+      if (extractionFingerprint && extractionRetryEnabled) {
+        if (extractionFailure) {
+          try {
+            meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_bookkeeping_load", false);
+            await runDeadlineAware(
+              () => this.recordExtractionFailure(
+                storage,
+                selfNamespace,
+                extractionFingerprint,
+                result.extractionFailureClass ?? "provider_retryable",
+                meta,
+                Date.now()
+              ),
+              "during_retry_bookkeeping_save",
+              false
+            );
+            recordedRetryFailure = true;
+          } catch (err) {
+            if (err instanceof ExtractionDeadlineError) throw err;
+            log.warn("runExtraction: failed to load meta for retry bookkeeping (non-fatal)", err);
+          }
+        } else {
+          this.resetProviderBreakerOnSuccess();
+          try {
+            meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_bookkeeping_load", false);
+            this.hydrateRetryStateFromMeta(selfNamespace, meta);
+            if (this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, meta)) {
+              await runDeadlineAware(() => storage.saveMeta(meta), "during_retry_bookkeeping_save", false);
+            }
+          } catch (err) {
+            if (err instanceof ExtractionDeadlineError) throw err;
+            log.warn("runExtraction: failed to persist cleared retry state (non-fatal)", err);
+          }
+        }
+      }
+      if (options.failOnExtractionFailure && extractionFailure) {
+        throw new Error(`extraction failed: ${extractionFailure}`);
+      }
+      if (result.facts.length === 0 && result.entities.length === 0 && result.questions.length === 0 && result.profileUpdates.length === 0) {
+        log.debug("runExtraction: extraction produced no durable outputs; skipping persistence");
+        if (extractionFailure) {
+          log.warn(
+            "runExtraction: extraction reported failure with no durable outputs; not marking fingerprint processed",
+            { extractionFailure }
+          );
+        }
+        if (extractionFingerprint && shouldPersistProcessedFingerprint && !extractionFailure) {
+          meta ??= await storage.loadMeta();
+          await this.deps.recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
+          meta.extractionCount += 1;
+          meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
+          await storage.saveMeta(meta);
+        }
+        await runPassiveCapture(normalizedTurns, {
+          sessionKey,
+          principal,
+          namespace: selfNamespace,
+          bufferKey,
+          isLiveSession: clearBufferAfterExtraction
+        });
+        if (recordedRetryFailure) {
+          log.debug("runExtraction: retaining buffer for backoff retry after failure");
+        } else {
+          await clearBuffer();
+        }
+        return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
+      }
+      let threadIdForExtraction = null;
+      if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
+        const lastTurn = turns[turns.length - 1];
+        try {
+          threadIdForExtraction = await runDeadlineAware(
+            () => this.deps.getThreading().processTurn(lastTurn, []),
+            "during_threading"
+          );
+        } catch (err) {
+          if (err instanceof ExtractionDeadlineError) throw err;
+          log.warn("[threading] processTurn failed before persistence (non-fatal)", err);
+        }
+      }
+      throwIfDeadlineExceeded("before_persist");
+      throwIfAborted2("before_persist");
+      const { persistedIds } = await this.deps.persistExtraction(
+        result,
+        storage,
+        threadIdForExtraction,
+        { sessionKey, principal, validAt: sourceValidAt, sourceConnector: deriveSourceConnector(targetTurns) },
+        // Pass the KNOWN base namespace (NHIdx) so the catalog write touch records the
+        // real namespace rather than a guess decoded from the storage dir.
+        selfNamespace,
+        scopeProfileWritePlan,
+        // Verbatim source turns for the faithfulness gate (#1576) so it can
+        // locate a quote per fact when #1575 spans are absent.
+        normalizedTurns.map((t) => t.content).join("\n\n")
+      );
+      const durableOutputCount = result.facts.length + result.entities.length + result.questions.length + result.profileUpdates.length;
+      try {
+        options.onDurableCommit?.();
+      } catch (error) {
+        log.warn("runExtraction: durable-commit callback failed", error);
+      }
+      const runPostPersistBestEffort = runExtractionPostPersistBestEffort.bind(null, runDeadlineAware);
+      const postPersist = await runExtractionPostPersist({
+        result,
+        storage,
+        meta: meta ?? void 0,
+        extractionFingerprint: extractionFingerprint ?? void 0,
+        shouldPersistProcessedFingerprint,
+        recordProcessedExtractionFingerprint: this.deps.recordProcessedExtractionFingerprint,
+        runDeadlineAware,
+        isDeadlineError: (error) => error instanceof ExtractionDeadlineError,
+        createDeadlineError: (stage) => new ExtractionDeadlineError(stage),
+        deadlineMs,
+        clearBufferAfterExtraction,
+        runPostPersistBestEffort,
+        extractionJudgeShadow: this.config.extractionJudgeShadow,
+        getDeferredCount: () => this.deps.getLastPersistExtractionDeferredCount(),
+        normalizedTurns,
+        bufferKey,
+        retainDeferredTurns: (key, retainedTurns, max) => this.deps.getBuffer().retainDeferredTurns(key, retainedTurns, max),
+        clearBuffer,
+        failOnExtractionFailure: options.failOnExtractionFailure === true
+      });
+      meta = postPersist.meta ?? null;
+      const postPersistMetadataFailed = postPersist.metadataFailed;
+      await runPostPersistBestEffort(
+        "during_post_persist_passive_capture",
+        () => runPassiveCapture(normalizedTurns, {
+          sessionKey,
+          principal,
+          namespace: selfNamespace,
+          bufferKey,
+          isLiveSession: clearBufferAfterExtraction,
+          abortSignal: extractionAbortSignal
+        })
+      );
+      if (resolvePresentationCapabilities(this.config).memoryBoxes && persistedIds.length > 0) {
+        const extractionTopics = deriveTopicsFromExtraction(result);
+        const firstUserTurn = turns.find((t) => t.role === "user");
+        const boxGoal = firstUserTurn?.content?.slice(0, 100)?.trim() || void 0;
+        await runPostPersistBestEffort(
+          "during_memory_box",
+          () => this.deps.boxBuilderFor(storage).onExtraction({
+            topics: extractionTopics,
+            memoryIds: persistedIds,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            goal: boxGoal
+          })
+        );
+      }
+      if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction && persistedIds.length > 0) {
+        await runPostPersistBestEffort(
+          "during_thread_episode_append",
+          () => this.deps.appendPersistedThreadEpisodes(threadIdForExtraction, persistedIds)
+        );
+      }
+      if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction) {
+        const conversationContent = turns.map((t) => t.content).join(" ");
+        await runPostPersistBestEffort(
+          "during_thread_title_update",
+          () => this.deps.getThreading().updateThreadTitle(threadIdForExtraction, conversationContent)
+        );
+      }
+      const nonZeroExtraction = durableOutputCount > 0;
+      try {
+        this.deps.maybeScheduleConsolidation(nonZeroExtraction);
+      } catch (err) {
+        log.warn("runExtraction: consolidation scheduling failed after persistence (non-fatal)", err);
+      }
+      try {
+        this.deps.requestQmdMaintenance();
+      } catch (err) {
+        log.warn("runExtraction: QMD maintenance scheduling failed after persistence (non-fatal)", err);
+      }
+      await runPostPersistBestEffort(
+        "during_tier_migration",
+        () => this.deps.runTierMigrationCycle(storage, "extraction")
+      );
+      return {
+        status: "completed",
+        persistedCount: persistedIds.length,
+        durableOutputCount,
+        postPersistMetadataFailed
+      };
+    } finally {
+      clearExtractionDeadlineTimer();
+    }
+  }
+};
+
+export {
+  BulkImportBatchPartialFailureError,
+  mapRecallSourceToXrayServedBy,
+  abortRecallError,
+  throwIfRecallAborted,
+  raceRecallAbort,
+  COMPACTION_SIGNAL_MAX_AGE_MS,
+  normalizeIanaTimeZone,
+  formatDateInTimeZone,
+  utcDateKeysForLocalDay,
+  parseFiniteDate,
+  filterHourlySummaryMarkdownForLocalDay,
+  qmdStartupCollectionCheckWithTimeout,
+  defaultWorkspaceDir,
+  sanitizeSessionKeyForFilename,
+  targetSourceValidAtSortMs,
+  splitTurnsBySourceValidAt,
+  isArtifactMemoryPath,
+  isMeetingRecordPath,
+  isActivityDigestPath,
+  buildCompressionGuidelinesMarkdown2 as buildCompressionGuidelinesMarkdown,
+  applyQueryAwareCandidateFilter,
+  tokenizeRecallQuery,
+  shouldFilterLifecycleRecallCandidate,
+  lifecycleRecallScoreAdjustment,
+  computeArtifactRecallLimit,
+  resolveEffectiveRecallMode,
+  resolveRecallModeDecision,
+  resolveRecallModeDecisionAsync,
+  computeArtifactCandidateFetchLimit,
+  computeQmdHybridFetchLimit,
+  summarizeGraphShadowComparison,
+  parseGraphRecallRankedResults,
+  parseMemoryIntentSnapshot,
+  buildQmdIntentHint,
+  parseQmdRecallResults,
+  mergeArtifactRecallCandidates,
+  resolveRecentThreadMemoryPaths,
+  buildMemoryPathById,
+  appendMemoryToGraphContext,
+  resolvePersistedMemoryRelativePath,
+  deriveTopicsFromExtraction,
+  ExtractionDeadlineError,
+  ExtractionRunCoordinator
+};
+//# sourceMappingURL=chunk-YPC7W6GA.js.map