@remnic/core 9.69.32 → 9.69.34

package/dist/{chunk-XQ2Q43XD.js → chunk-326KUXIR.js}

@@ -1,25 +1,16 @@
 import {
   tagPersistedMemories
-} from "./chunk-FBMYGNOC.js";
+} from "./chunk-A2YQL2FF.js";
 import {
-  hasBroadGraphIntent,
-  planRecallMode
-} from "./chunk-CSAKJVXW.js";
-import {
-  buildCompressionGuidelinesMarkdown
-} from "./chunk-OD4FM2U7.js";
-import {
-  parseQmdExplain
-} from "./chunk-DBQWVT2H.js";
+  raceRecallAbort,
+  throwIfRecallAborted
+} from "./chunk-TLHNF6GA.js";
 import {
   classifyOrigin
 } from "./chunk-6Q3ZTEF6.js";
-import {
-  resolveLifecycleState
-} from "./chunk-TBBDFYXW.js";
 import {
   resolveScopeProfilePlan
-} from "./chunk-VGXM5B4H.js";
+} from "./chunk-MNIPH6LD.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -33,593 +24,11 @@ import {
 } from "./chunk-JUOZ62Y7.js";
 import {
   resolveCodingNamespaceOverlay
-} from "./chunk-NZXEK3UF.js";
-import {
-  abortError,
-  throwIfAborted
-} from "./chunk-BTTPKDIL.js";
-import {
-  categoryDirName
-} from "./chunk-VS2IYZRU.js";
+} from "./chunk-3Q3N35W7.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 ARTIFACT_STATUS_CACHE_TTL_MS = 6e4;
-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);
-}
-var LOCATION_DAY_TOPLEVEL = /^locations[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
-var LOCATION_DAY_ANYWHERE = /(?:^|[\\/])locations[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
-function isLocationDayPath(filePath, memoryRoot) {
-  if (memoryRoot !== void 0 && memoryRoot.length > 0) {
-    const relative = path.relative(memoryRoot, path.resolve(memoryRoot, filePath));
-    return LOCATION_DAY_TOPLEVEL.test(relative);
-  }
-  return LOCATION_DAY_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;
@@ -834,7 +243,7 @@ async function commitEmptySuccessExtraction(args) {
 }
 
 // src/orchestration/extraction-run.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 
 // src/orchestration/extraction-origin-context.ts
 function deriveExtractionOriginContext(targetTurns, fallbackConnector) {
@@ -932,7 +341,7 @@ var ExtractionRunCoordinator = class {
   buildExtractionFingerprint(turns, bufferKey) {
     const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
     if (!normalized) return null;
-    return createHash2("sha256").update(`${bufferKey}
+    return createHash("sha256").update(`${bufferKey}
 ${normalized}`).digest("hex");
   }
   shouldQueueExtraction(turns, options = {}) {
@@ -1134,7 +543,7 @@ ${normalized}`).digest("hex");
         throw new ExtractionDeadlineError(stage);
       }
     };
-    const throwIfAborted2 = (stage) => {
+    const throwIfAborted = (stage) => {
       throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
     };
     const runPassiveCapture = async (captureTurns, captureOptions) => {
@@ -1185,7 +594,7 @@ ${normalized}`).digest("hex");
     const clearBuffer = async (options2) => {
       if (options2?.ignoreAbort !== true) {
         throwIfDeadlineExceeded("before_clear_buffer");
-        throwIfAborted2("before_clear_buffer");
+        throwIfAborted("before_clear_buffer");
       }
       if (clearBufferAfterExtraction) {
         await this.deps.getBuffer().clearAfterExtraction(bufferKey, turns, clearMatchingTurns ? { allowNonPrefix: true } : void 0);
@@ -1227,7 +636,7 @@ ${normalized}`).digest("hex");
     }
     const sourceValidAt = this.latestSourceValidAtFromTurns(targetTurns);
     throwIfDeadlineExceeded("before_extract");
-    throwIfAborted2("before_extract");
+    throwIfAborted("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;
@@ -1316,7 +725,7 @@ ${normalized}`).digest("hex");
           throwIfDeadlineExceeded(phase);
         }
         if (operationSignal?.aborted) {
-          throwIfAborted2(phase);
+          throwIfAborted(phase);
         }
         return await raceRecallAbort(
           operation(),
@@ -1425,7 +834,7 @@ ${normalized}`).digest("hex");
     }
     try {
       throwIfDeadlineExceeded("before_persist");
-      throwIfAborted2("before_persist");
+      throwIfAborted("before_persist");
       if (!result) {
         log.warn("runExtraction: extraction returned null/undefined");
         if (options.failOnExtractionFailure) {
@@ -1555,7 +964,7 @@ ${normalized}`).digest("hex");
       }
       const originContext = deriveExtractionOriginContext(targetTurns, result.sourceConnector);
       throwIfDeadlineExceeded("before_persist");
-      throwIfAborted2("before_persist");
+      throwIfAborted("before_persist");
       const { persistedIds } = await this.deps.persistExtraction(
         result,
         storage,
@@ -1666,52 +1075,10 @@ ${normalized}`).digest("hex");
 };
 
 export {
-  ARTIFACT_STATUS_CACHE_TTL_MS,
-  BulkImportBatchPartialFailureError,
-  mapRecallSourceToXrayServedBy,
-  abortRecallError,
-  throwIfRecallAborted,
-  raceRecallAbort,
-  COMPACTION_SIGNAL_MAX_AGE_MS,
-  normalizeIanaTimeZone,
-  formatDateInTimeZone,
-  utcDateKeysForLocalDay,
-  parseFiniteDate,
-  filterHourlySummaryMarkdownForLocalDay,
-  qmdStartupCollectionCheckWithTimeout,
-  defaultWorkspaceDir,
-  sanitizeSessionKeyForFilename,
-  targetSourceValidAtSortMs,
-  splitTurnsBySourceValidAt,
-  isArtifactMemoryPath,
-  isMeetingRecordPath,
-  isActivityDigestPath,
-  isLocationDayPath,
-  buildCompressionGuidelinesMarkdown2 as buildCompressionGuidelinesMarkdown,
-  applyQueryAwareCandidateFilter,
-  tokenizeRecallQuery,
-  shouldFilterLifecycleRecallCandidate,
-  lifecycleRecallScoreAdjustment,
-  computeArtifactRecallLimit,
-  resolveEffectiveRecallMode,
-  resolveRecallModeDecision,
-  resolveRecallModeDecisionAsync,
-  computeArtifactCandidateFetchLimit,
-  computeQmdHybridFetchLimit,
-  summarizeGraphShadowComparison,
-  parseGraphRecallRankedResults,
-  parseMemoryIntentSnapshot,
-  buildQmdIntentHint,
-  parseQmdRecallResults,
-  mergeArtifactRecallCandidates,
-  resolveRecentThreadMemoryPaths,
-  buildMemoryPathById,
-  appendMemoryToGraphContext,
-  resolvePersistedMemoryRelativePath,
   classifyExtractionOrigin,
   deriveTopicsFromExtraction,
   deriveSourceConnector,
   ExtractionDeadlineError,
   ExtractionRunCoordinator
 };
-//# sourceMappingURL=chunk-XQ2Q43XD.js.map
+//# sourceMappingURL=chunk-326KUXIR.js.map