@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-KH2D26LQ.js

@@ -1,2440 +0,0 @@
-import {
-  applyGroundingWithConnector,
-  headerConnector,
-  renderExtractionConversation,
-  resolveSourceConnector
-} from "./chunk-SPFNGHHP.js";
-import {
-  normalizeReasoningTrace
-} from "./chunk-54V4BZWP.js";
-import {
-  shouldRunProactivePass
-} from "./chunk-2CGLBUW3.js";
-import {
-  extractionProviderJsonSchema
-} from "./chunk-AAQA6ZUP.js";
-import {
-  ConsolidationResultSchema,
-  DaySummaryResultSchema,
-  ExtractionResultSchema,
-  IdentityConsolidationResultSchema,
-  ProactiveExtractionResultSchema,
-  ProactiveQuestionsResultSchema,
-  buildProfileConsolidationResultSchema
-} from "./chunk-JHU4EYDV.js";
-import {
-  applyExtractionSpanMaterialization,
-  bindLocalExtractionPrompt,
-  buildSpanMaterializeTurns,
-  stripUntrustedFactSpans,
-  truncateLocalExtractionConversation
-} from "./chunk-XVZA6VXC.js";
-import {
-  containsExtractionPlaceholder,
-  extractionAttributes,
-  extractionCueAnchors,
-  extractionText,
-  isPlainRecord
-} from "./chunk-FJMYMJLR.js";
-import {
-  attachExtractionProvenance
-} from "./chunk-SMBWBEE7.js";
-import {
-  classifyExtractionThrownError,
-  classifyFallbackParseFailure,
-  formatExtractionParseFailureLog
-} from "./chunk-PJRKLB4Z.js";
-import {
-  delinearize
-} from "./chunk-VEWZZM3H.js";
-import {
-  buildExtensionsFooterForSummary,
-  formatDaySummaryMemories,
-  loadDaySummaryPrompt
-} from "./chunk-LVXBC6YB.js";
-import {
-  CONSOLIDATION_RESPONSE_SCHEMA,
-  CUE_ANCHOR_PROMPT_INSTRUCTION,
-  OUTPUT_LANGUAGE_POLICY,
-  PROFILE_CONSOLIDATION_RESPONSE_SCHEMA,
-  buildConsolidationSystemPrompt,
-  buildExtractionInstructions,
-  buildProfileConsolidationSystemPrompt,
-  eventTimePromptInstruction,
-  extractionResponseShape,
-  spanModePromptSection
-} from "./chunk-BOADKFN4.js";
-import {
-  looksLikeMechanicalTelemetryTranscript
-} from "./chunk-4RA3C3EV.js";
-import {
-  AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT,
-  clampAmbientCaptureConfidence
-} from "./chunk-QW27DOHG.js";
-import {
-  applyWorkExtractionBoundary
-} from "./chunk-EI6V5UXY.js";
-import {
-  ProfilingCollector
-} from "./chunk-NLE6TSLG.js";
-import {
-  ModelRegistry
-} from "./chunk-WLZYGLJ4.js";
-import {
-  LocalLlmClient
-} from "./chunk-G2XZFGYN.js";
-import {
-  normalizeProcedureSteps
-} from "./chunk-QDW3E4RD.js";
-import {
-  FallbackLlmClient,
-  gatewayTaskChainOptions
-} from "./chunk-ZTHGFTMW.js";
-import {
-  buildChatCompletionTokenLimit,
-  shouldAssumeOpenAiChatCompletions
-} from "./chunk-L2EXJQJP.js";
-import {
-  fallbackLlmRuntimeContextFromConfig
-} from "./chunk-EP6BA7VV.js";
-import {
-  extractJsonCandidates
-} from "./chunk-RGMVMVMF.js";
-import {
-  isMemoryCategory
-} from "./chunk-GDYU6VF4.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
-import {
-  resolveLocalLlmCapabilities,
-  resolveMemoryLifecycleCapabilities,
-  resolvePipelineProcessingCapabilities,
-  resolveRecallAuxiliaryCapabilities
-} from "./chunk-JUOZ62Y7.js";
-import {
-  isAbortError
-} from "./chunk-BTTPKDIL.js";
-import {
-  log
-} from "./chunk-3WCASNQZ.js";
-
-// src/extraction.ts
-import OpenAI from "openai";
-
-// src/orchestration/dependency-revalidation.ts
-function isPlainRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function buildPrompt(superseded, replacement, dependents) {
-  const dependentPrompt = dependents.map(
-    (memory, index) => `[${index + 1}] id: ${memory.id} | category: ${memory.category}
-${memory.content}`
-  ).join("\n\n");
-  const input = `SUPERSEDED MEMORY (id: ${superseded.id}):
-${superseded.content}
-
-REPLACEMENT (id: ${replacement?.id ?? "none"}):
-${replacement?.content ?? "none \u2014 the memory was removed without replacement"}
-
-DEPENDENTS TO REVALIDATE (return exactly one verdict per id):
-${dependentPrompt}`;
-  const instructionText = `You revalidate dependent memory claims after a supporting memory changes.
-For each requested memory, decide whether its claim still holds.
-Return valid JSON only:
-{"verdicts":[{"memoryId":"id","verdict":"still_valid|invalidated|uncertain","reason":"brief reason"}]}
-Never invent memory IDs. Use "uncertain" when the evidence is insufficient.`;
-  return { input, instructionText };
-}
-function normalizeVerdicts(parsed, dependents) {
-  const raw = isPlainRecord2(parsed) && Array.isArray(parsed.verdicts) ? parsed.verdicts : [];
-  const requested = new Set(dependents.map((memory) => memory.id));
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const candidate of raw) {
-    if (!isPlainRecord2(candidate)) continue;
-    const memoryId = typeof candidate.memoryId === "string" ? candidate.memoryId.trim() : "";
-    if (!requested.has(memoryId) || seen.has(memoryId)) continue;
-    seen.add(memoryId);
-    const verdict = candidate.verdict === "still_valid" || candidate.verdict === "invalidated" || candidate.verdict === "uncertain" ? candidate.verdict : "uncertain";
-    normalized.push({
-      memoryId,
-      verdict,
-      ...typeof candidate.reason === "string" ? { reason: candidate.reason } : {}
-    });
-  }
-  return dependents.map((memory) => {
-    const verdict = normalized.find((candidate) => candidate.memoryId === memory.id);
-    return verdict ?? { memoryId: memory.id, verdict: "uncertain" };
-  });
-}
-async function revalidateDependentsViaLlm(deps, superseded, replacement, dependents, options = {}) {
-  const { input, instructionText } = buildPrompt(superseded, replacement, dependents);
-  const maxTokens = Math.max(1024, dependents.length * 256);
-  const response = await deps.fastChatCompletion(
-    [
-      { role: "system", content: instructionText },
-      { role: "user", content: input }
-    ],
-    {
-      temperature: 0.2,
-      maxTokens,
-      operation: "dependency_revalidation",
-      priority: "background",
-      timeoutMs: options.timeoutMs,
-      signal: options.signal
-    }
-  );
-  const rawContent = response?.content ?? null;
-  if (!rawContent?.trim()) {
-    throw new Error("fast completion returned no dependency revalidation output");
-  }
-  return { verdicts: normalizeVerdicts(deps.parseJsonObject(rawContent), dependents) };
-}
-
-// src/extraction.ts
-var PROACTIVE_MIN_CONFIDENCE = 0.8;
-function extractionEntityType(value) {
-  const type = extractionText(value);
-  if (type === "person" || type === "project" || type === "tool" || type === "company" || type === "place" || type === "other") {
-    return type;
-  }
-  return void 0;
-}
-function normalizeQuestion(question) {
-  const priority = Number.isFinite(question.priority) ? Math.max(0, Math.min(1, question.priority)) : 0.5;
-  return {
-    question: typeof question.question === "string" ? question.question.trim() : "",
-    context: typeof question.context === "string" ? question.context.trim() : "",
-    priority
-  };
-}
-function normalizeExtractedSpanRef(value) {
-  if (!isPlainRecord(value)) return void 0;
-  const { sourceMessageIndex, charStart, charEnd, frame, sourceHash, sourceLength } = value;
-  if (typeof sourceMessageIndex !== "number" || typeof charStart !== "number" || typeof charEnd !== "number" || typeof frame !== "string") {
-    return void 0;
-  }
-  return {
-    sourceMessageIndex,
-    charStart,
-    charEnd,
-    frame,
-    ...typeof sourceHash === "string" && typeof sourceLength === "number" ? { sourceHash, sourceLength } : {}
-  };
-}
-function normalizeFactKey(fact) {
-  return `${fact.category}:${fact.content.trim().toLowerCase()}`;
-}
-function normalizeEntityKey(entity) {
-  return `${entity.type}:${entity.name.trim().toLowerCase()}`;
-}
-function normalizeRelationshipKey(relationship) {
-  return `${relationship.source.trim().toLowerCase()}=>${relationship.target.trim().toLowerCase()}:${relationship.label.trim().toLowerCase()}`;
-}
-function normalizeProfileUpdateKey(update) {
-  return update.trim().toLowerCase();
-}
-function shouldEnableLocalExtractionThinking(config, conversationChars) {
-  return config.localLlmDisableThinking && config.localLlmThinkingThresholdChars > 0 && conversationChars < config.localLlmThinkingThresholdChars;
-}
-function throwIfExtractionAborted(signal) {
-  if (!signal?.aborted) return;
-  const reason = signal.reason;
-  throw reason instanceof Error ? reason : new Error("extraction aborted");
-}
-var ExtractionEngine = class {
-  constructor(config, profilerArg, localLlm, gatewayConfig, modelRegistry, fastChatCompletion) {
-    this.config = config;
-    this.fastChatCompletion = fastChatCompletion;
-    this.profiler = profilerArg ?? new ProfilingCollector({ enabled: false, storageDir: "/tmp/engram-profiler-disabled", maxTraces: 0 });
-    if (config.openaiApiKey) {
-      this.client = new OpenAI({
-        apiKey: config.openaiApiKey,
-        ...config.openaiBaseUrl ? { baseURL: config.openaiBaseUrl } : {}
-      });
-    } else {
-      this.client = null;
-      log.warn("no OpenAI API key \u2014 direct OpenAI client disabled; local and gateway fallback paths remain available");
-    }
-    this.localLlm = localLlm ?? new LocalLlmClient(config, modelRegistry);
-    this.fallbackLlm = new FallbackLlmClient(
-      gatewayConfig,
-      fallbackLlmRuntimeContextFromConfig(config)
-    );
-    this.modelRegistry = modelRegistry ?? new ModelRegistry(config.memoryDir);
-    if (config.modelSource === "gateway") {
-      log.debug(
-        `extraction engine: gateway model source active; extraction uses the gateway chain as its primary path` + (config.taskModelChain ? " (taskModelChain)" : config.gatewayAgentId ? ` (agent: ${config.gatewayAgentId})` : " (defaults)")
-      );
-    } else if (config.taskModelChain) {
-      log.warn(
-        `taskModelChain is set but modelSource is "${config.modelSource}"; the chain is ignored. Set modelSource: "gateway" to use it for extraction/consolidation/summarization.`
-      );
-    }
-  }
-  config;
-  fastChatCompletion;
-  client;
-  localLlm;
-  fallbackLlm;
-  modelRegistry;
-  profiler;
-  get useGatewayModelSource() {
-    return this.config.modelSource === "gateway";
-  }
-  get shouldUseLocalLlm() {
-    return resolveLocalLlmCapabilities(this.config).localLlm && !this.useGatewayModelSource;
-  }
-  get shouldUseDirectClient() {
-    return !this.useGatewayModelSource && this.client !== null;
-  }
-  /**
-   * Span-mode materialization (issue #2333 Phase B): sibling module, called
-   * after parse and before sanitize/grounding so downstream sees one content
-   * form. Offsets index the exact prompt turn texts and die at materialization.
-   */
-  applySpanMaterialization(result, spanTurns) {
-    return applyExtractionSpanMaterialization(
-      result,
-      spanTurns,
-      this.config.extraction?.spanMode ?? "off"
-    );
-  }
-  /**
-   * Build FallbackLlmOptions with the configured gateway agent ID injected.
-   */
-  withGatewayAgent(options) {
-    if (!this.useGatewayModelSource) return options;
-    return { ...options, ...gatewayTaskChainOptions(this.config) };
-  }
-  emit(event) {
-    try {
-      const cb = globalThis.__openclawEngramTrace;
-      if (typeof cb === "function") cb(event);
-    } catch {
-    }
-  }
-  directClientUsesOpenAiTokenSemantics() {
-    return shouldAssumeOpenAiChatCompletions(this.config.openaiBaseUrl);
-  }
-  sanitizeExtractionResult(result, messageTimestamp) {
-    const proceduralOn = this.config.procedural?.enabled === true;
-    const ts = messageTimestamp ?? /* @__PURE__ */ new Date();
-    const facts = result.facts.filter((fact) => proceduralOn || fact.category !== "procedure").map((fact) => {
-      const sanitized = sanitizeMemoryContent(fact.content);
-      if (!sanitized.clean) {
-        log.warn(`extraction fact sanitized; violations=${sanitized.violations.join(", ")}`);
-      }
-      let content = sanitized.text;
-      if (resolvePipelineProcessingCapabilities(this.config).delinearize) {
-        content = delinearize(content, result.entities, ts);
-      }
-      return {
-        ...fact,
-        content,
-        cueAnchors: extractionCueAnchors(fact.cueAnchors)
-      };
-    });
-    return { ...result, facts, episodeTitle: extractionText(result.episodeTitle) };
-  }
-  hasExtractionOutputs(result) {
-    return result.facts.length > 0 || result.entities.length > 0 || result.questions.length > 0 || result.profileUpdates.length > 0 || (result.relationships?.length ?? 0) > 0;
-  }
-  looksLikeExtractionResultPayload(parsed) {
-    return !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && ("facts" in parsed || "entities" in parsed || "profileUpdates" in parsed || "questions" in parsed || "relationships" in parsed || "identityReflection" in parsed);
-  }
-  normalizeExtractionResultPayload(parsed) {
-    const entities = Array.isArray(parsed?.entities) ? parsed.entities.map((candidate) => this.normalizeEntityUpdate(candidate)).filter((entity) => entity !== void 0 && entity.name.length > 0) : [];
-    const facts = Array.isArray(parsed?.facts) ? parsed.facts.map((candidate) => {
-      const f = isPlainRecord(candidate) ? candidate : {};
-      const category = typeof f.category === "string" ? f.category.trim() : "fact";
-      const reasoningTraceInput = isPlainRecord(f.reasoningTrace) ? f.reasoningTrace : isPlainRecord(f?.reasoning_trace) ? f.reasoning_trace : void 0;
-      if (!isMemoryCategory(category)) return void 0;
-      const procedureSteps = Array.isArray(f.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0;
-      const reasoningTrace = reasoningTraceInput ? normalizeReasoningTrace(reasoningTraceInput) ?? void 0 : void 0;
-      if (containsExtractionPlaceholder(procedureSteps) || containsExtractionPlaceholder(reasoningTrace)) {
-        return void 0;
-      }
-      return {
-        category,
-        content: extractionText(f.content) ?? extractionText(f.text) ?? "",
-        confidence: typeof f.confidence === "number" ? f.confidence : 0.7,
-        tags: Array.isArray(f.tags) ? f.tags.flatMap((tag) => {
-          const text = extractionText(tag);
-          return text === void 0 ? [] : [text];
-        }) : [],
-        entityRef: extractionText(f.entityRef),
-        cueAnchors: extractionCueAnchors(f.cueAnchors),
-        promptedByQuestion: extractionText(f.promptedByQuestion),
-        scope: f.scope === "global" || f.scope === "project" ? f.scope : void 0,
-        subject: f.subject === "user" || f.subject === "agent" ? f.subject : void 0,
-        structuredAttributes: extractionAttributes(f.structuredAttributes),
-        procedureSteps,
-        reasoningTrace,
-        quote: extractionText(f.quote),
-        span: normalizeExtractedSpanRef(f.span),
-        eventTime: extractionText(f.eventTime) ?? extractionText(f.event_time)
-      };
-    }).filter((fact) => fact !== void 0 && fact.content.length > 0) : [];
-    const questions = Array.isArray(parsed?.questions) ? parsed.questions.flatMap((candidate) => {
-      const record = isPlainRecord(candidate) ? candidate : void 0;
-      const question = extractionText(record?.question) ?? extractionText(record?.text) ?? extractionText(candidate);
-      if (question === void 0) return [];
-      return [{
-        question,
-        context: extractionText(record?.context) ?? "",
-        priority: typeof record?.priority === "number" ? record.priority : 0.5
-      }];
-    }) : [];
-    const profileUpdates = Array.isArray(parsed?.profileUpdates) ? parsed.profileUpdates.flatMap((candidate) => {
-      const update = extractionText(candidate);
-      return update === void 0 ? [] : [update];
-    }) : [];
-    const relationships = Array.isArray(parsed?.relationships) ? parsed.relationships.flatMap((candidate) => {
-      const relationship = isPlainRecord(candidate) ? candidate : void 0;
-      const source = extractionText(relationship?.source);
-      const target = extractionText(relationship?.target);
-      const label = extractionText(relationship?.label);
-      if (source === void 0 || target === void 0 || label === void 0) return [];
-      return [{
-        source,
-        target,
-        label,
-        promptedByQuestion: extractionText(relationship?.promptedByQuestion)
-      }];
-    }) : void 0;
-    return {
-      facts,
-      entities,
-      profileUpdates,
-      questions,
-      identityReflection: extractionText(parsed?.identityReflection),
-      episodeTitle: extractionText(parsed?.episodeTitle),
-      relationships
-    };
-  }
-  normalizeEntityUpdate(entity) {
-    const record = isPlainRecord(entity) ? entity : {};
-    const rawUpdates = isPlainRecord(record.updates) ? record.updates : void 0;
-    const normalizedTexts = (value) => Array.isArray(value) ? value.flatMap((candidate) => {
-      const text = extractionText(candidate);
-      return text === void 0 ? [] : [text];
-    }) : [];
-    const directFacts = normalizedTexts(record.facts);
-    const updateFacts = normalizedTexts(rawUpdates?.facts);
-    const scalarUpdateFacts = rawUpdates ? Object.entries(rawUpdates).sort(([left], [right]) => left.localeCompare(right)).flatMap(([key, value]) => {
-      if (["facts", "name", "promptedByQuestion", "structuredSections", "type"].includes(key)) {
-        return [];
-      }
-      const normalizedKey = extractionText(key);
-      if (normalizedKey === void 0) return [];
-      const normalizedValue = extractionText(value);
-      if (normalizedValue !== void 0) return [`${normalizedKey}: ${normalizedValue}`];
-      if (typeof value === "number" || typeof value === "boolean") {
-        return [`${normalizedKey}: ${String(value)}`];
-      }
-      return [];
-    }) : [];
-    const structuredSectionsSource = Array.isArray(record.structuredSections) ? record.structuredSections : Array.isArray(rawUpdates?.structuredSections) ? rawUpdates.structuredSections : [];
-    const structuredSections = structuredSectionsSource.flatMap((candidate) => {
-      const section = isPlainRecord(candidate) ? candidate : {};
-      const key = extractionText(section.key);
-      const title = extractionText(section.title);
-      const facts = normalizedTexts(section.facts);
-      if (key === void 0 || title === void 0 || facts.length === 0) return [];
-      return [{ key, title, facts }];
-    });
-    const rawType = record.type ?? rawUpdates?.type;
-    const type = rawType === void 0 ? "other" : extractionEntityType(rawType);
-    if (type === void 0) return void 0;
-    return {
-      name: extractionText(record.name) ?? extractionText(record.entityId) ?? extractionText(rawUpdates?.name) ?? "",
-      type,
-      facts: [...directFacts, ...updateFacts, ...scalarUpdateFacts],
-      structuredSections: structuredSections.length > 0 ? structuredSections : void 0,
-      promptedByQuestion: extractionText(record.promptedByQuestion) ?? extractionText(rawUpdates?.promptedByQuestion)
-    };
-  }
-  parseJsonObject(content) {
-    const trimmed = content?.trim();
-    if (!trimmed) return null;
-    for (const candidate of extractJsonCandidates(trimmed)) {
-      try {
-        return JSON.parse(candidate);
-      } catch {
-      }
-    }
-    return null;
-  }
-  normalizeContradictionVerificationResult(parsed) {
-    if (!parsed || typeof parsed.isContradiction !== "boolean") return null;
-    const rawWhich = parsed.whichIsNewer ?? parsed.winner;
-    const normalizedWhich = rawWhich === "first" || rawWhich === "existing" ? "first" : rawWhich === "second" || rawWhich === "new" ? "second" : "unclear";
-    return {
-      isContradiction: Boolean(parsed.isContradiction),
-      confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
-      reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : typeof parsed.explanation === "string" ? parsed.explanation : "",
-      whichIsNewer: normalizedWhich
-    };
-  }
-  normalizeSuggestedLinksResult(parsed) {
-    if (!parsed || !Array.isArray(parsed.links)) {
-      return null;
-    }
-    const normalizedLinks = parsed.links.map((link) => {
-      const rawLinkType = link?.linkType ?? link?.type;
-      return {
-        targetId: typeof link?.targetId === "string" ? link.targetId : "",
-        linkType: rawLinkType === "follows" || rawLinkType === "references" || rawLinkType === "contradicts" || rawLinkType === "supports" || rawLinkType === "related" ? rawLinkType : "related",
-        strength: typeof link?.strength === "number" ? Math.max(0, Math.min(1, link.strength)) : 0.5,
-        reason: typeof link?.reason === "string" ? link.reason : void 0
-      };
-    }).filter((link) => link.targetId.length > 0);
-    return { links: normalizedLinks };
-  }
-  normalizeMemorySummaryResult(parsed) {
-    if (!parsed) return null;
-    const normalized = {
-      summaryText: typeof parsed.summaryText === "string" ? parsed.summaryText : typeof parsed.summary === "string" ? parsed.summary : "",
-      keyFacts: Array.isArray(parsed.keyFacts) ? parsed.keyFacts.filter((f) => typeof f === "string") : [],
-      keyEntities: Array.isArray(parsed.keyEntities) ? parsed.keyEntities.filter((e) => typeof e === "string") : Array.isArray(parsed.entities) ? parsed.entities.filter((e) => typeof e === "string") : []
-    };
-    return normalized.summaryText.length > 0 ? normalized : null;
-  }
-  normalizeDaySummaryResult(parsed) {
-    if (!parsed) return null;
-    const normalized = {
-      summary: typeof parsed.summary === "string" ? parsed.summary.trim() : "",
-      bullets: Array.isArray(parsed.bullets) ? parsed.bullets.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [],
-      next_actions: Array.isArray(parsed.next_actions) ? parsed.next_actions.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [],
-      risks_or_open_loops: Array.isArray(parsed.risks_or_open_loops) ? parsed.risks_or_open_loops.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : []
-    };
-    return normalized.summary.length > 0 ? normalized : null;
-  }
-  sanitizeConsolidationResult(result) {
-    const items = [];
-    for (const item of Array.isArray(result.items) ? result.items : []) {
-      const rawAction = typeof item?.action === "string" ? item.action.toUpperCase() : "SKIP";
-      const action = rawAction === "ADD" || rawAction === "MERGE" || rawAction === "UPDATE" || rawAction === "INVALIDATE" || rawAction === "SKIP" ? rawAction : "SKIP";
-      const existingId = typeof item?.existingId === "string" ? item.existingId.trim() : typeof item?.newMemoryId === "string" ? item.newMemoryId.trim() : typeof item?.memoryId === "string" ? item.memoryId.trim() : "";
-      if (!existingId) continue;
-      const mergeWith = typeof item?.mergeWith === "string" ? item.mergeWith : void 0;
-      const reason = typeof item?.reason === "string" ? item.reason : "";
-      const rawUpdatedContent = typeof item?.updatedContent === "string" ? item.updatedContent : void 0;
-      if (!rawUpdatedContent) {
-        items.push({ existingId, action, mergeWith, updatedContent: void 0, reason });
-        continue;
-      }
-      const sanitized = sanitizeMemoryContent(rawUpdatedContent);
-      if (!sanitized.clean) {
-        log.warn(`consolidation item sanitized (${existingId}); violations=${sanitized.violations.join(", ")}`);
-      }
-      items.push({
-        existingId,
-        action,
-        mergeWith,
-        updatedContent: sanitized.text,
-        reason
-      });
-    }
-    const profileUpdates = (Array.isArray(result.profileUpdates) ? result.profileUpdates : []).map(
-      (update) => typeof update === "string" ? update.trim() : typeof update?.content === "string" ? update.content.trim() : ""
-    ).filter((update) => update.length > 0);
-    const entityUpdates = (Array.isArray(result.entityUpdates) ? result.entityUpdates : []).map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity !== void 0 && entity.name.length > 0);
-    return { items, profileUpdates, entityUpdates };
-  }
-  async applyProactiveQuestionPass(conversation, base, ctx, signal) {
-    if (!resolvePipelineProcessingCapabilities(this.config).proactiveExtraction) return base;
-    const maxAdditional = Math.max(0, Math.floor(this.config.maxProactiveQuestionsPerExtraction));
-    if (!shouldRunProactivePass(this.config, maxAdditional, this.shouldUseLocalLlm, this.localLlm)) return base;
-    try {
-      const proactive = await this.generateProactiveQuestions(conversation, base, maxAdditional, ctx.ambientCapture === true, signal);
-      if (proactive.length === 0) return base;
-      const ambient = ctx.ambientCapture === true;
-      const proactiveAdditions = await this.answerProactiveQuestions(
-        conversation,
-        base,
-        proactive,
-        maxAdditional,
-        ctx.sourceConnector,
-        ambient,
-        signal
-      );
-      const sanitizedAdditions = this.sanitizeExtractionResult({ ...proactiveAdditions, facts: stripUntrustedFactSpans(proactiveAdditions.facts) }, ctx.messageTimestamp);
-      const groundedAdditions = applyGroundingWithConnector(this.config, sanitizedAdditions, ctx);
-      if (!this.hasExtractionOutputs(groundedAdditions)) return base;
-      return this.mergeProactiveExtractionPass(base, groundedAdditions, maxAdditional);
-    } catch (err) {
-      if (signal?.aborted) throw err;
-      log.debug(`proactive extraction question pass failed (ignored): ${err}`);
-      return base;
-    }
-  }
-  parseProactiveQuestionsFromText(content, existingQuestionKeys) {
-    for (const candidate of extractJsonCandidates(content)) {
-      try {
-        const parsed = JSON.parse(candidate);
-        if (!Array.isArray(parsed.questions)) continue;
-        return parsed.questions.map((q) => normalizeQuestion(q)).filter((q) => q.question.length > 0).filter((q) => !existingQuestionKeys.has(q.question.toLowerCase()));
-      } catch {
-      }
-    }
-    return [];
-  }
-  parseProactiveExtractionResultFromText(content) {
-    for (const candidate of extractJsonCandidates(content)) {
-      try {
-        const parsed = ProactiveExtractionResultSchema.parse(JSON.parse(candidate));
-        return this.normalizeExtractionResultPayload({
-          ...parsed,
-          questions: []
-        });
-      } catch {
-      }
-    }
-    return null;
-  }
-  async generateProactiveQuestions(conversation, base, maxAdditional, ambientCapture, signal) {
-    const existingQuestionKeys = new Set(
-      (base.questions ?? []).map((q) => q.question.trim().toLowerCase()).filter((q) => q.length > 0)
-    );
-    const factsPreview = base.facts.slice(0, 8).map((f) => `- (${f.category}) ${f.content}`).join("\n");
-    const existingQuestionsPreview = (base.questions ?? []).slice(0, 8).map((q) => `- ${q.question}`).join("\n");
-    const prompt = [
-      "You are doing a proactive second-pass memory extraction.",
-      `Generate up to ${maxAdditional} additional high-value follow-up questions not already covered.${ambientCapture ? AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT : ""}`,
-      OUTPUT_LANGUAGE_POLICY,
-      "Return only valid JSON with this shape:",
-      '{"questions":[{"question":"...","context":"...","priority":0.0}]}',
-      "",
-      "Current extracted facts:",
-      factsPreview || "(none)",
-      "",
-      "Questions already extracted (do not repeat):",
-      existingQuestionsPreview || "(none)",
-      "",
-      "Conversation:",
-      conversation
-    ].join("\n");
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResponse = await this.localLlm.chatCompletion(
-          [
-            {
-              role: "system",
-              content: "You are a proactive memory extraction assistant. Output valid JSON only."
-            },
-            { role: "user", content: prompt }
-          ],
-          {
-            temperature: 0.2,
-            maxTokens: this.config.proactiveExtractionMaxTokens,
-            timeoutMs: this.config.proactiveExtractionTimeoutMs,
-            operation: "proactive_extraction",
-            priority: "background",
-            signal
-          }
-        );
-        throwIfExtractionAborted(signal);
-        if (localResponse?.content) {
-          const localParsed = this.parseProactiveQuestionsFromText(
-            localResponse.content.trim(),
-            existingQuestionKeys
-          );
-          if (localParsed.length > 0) {
-            return localParsed.slice(0, maxAdditional);
-          }
-        }
-        if (!this.config.localLlmFallback) {
-          return [];
-        }
-      } catch (err) {
-        if (signal?.aborted || !this.config.localLlmFallback) {
-          throw err;
-        }
-      }
-    }
-    const fallbackResult = await this.fallbackLlm.parseWithSchema(
-      [
-        {
-          role: "system",
-          content: "Generate additional proactive memory follow-up questions. Return valid JSON only."
-        },
-        { role: "user", content: prompt }
-      ],
-      ProactiveQuestionsResultSchema,
-      this.withGatewayAgent({
-        temperature: 0.2,
-        maxTokens: this.config.proactiveExtractionMaxTokens,
-        timeoutMs: this.config.proactiveExtractionTimeoutMs,
-        signal
-      })
-    );
-    if (!fallbackResult?.questions) return [];
-    return fallbackResult.questions.map((q) => normalizeQuestion(q)).filter((q) => q.question.length > 0).filter((q) => !existingQuestionKeys.has(q.question.toLowerCase())).slice(0, maxAdditional);
-  }
-  async answerProactiveQuestions(conversation, base, proactiveQuestions, maxAdditional, sourceConnector, ambientCapture, signal) {
-    const factsPreview = base.facts.slice(0, 8).map((f) => `- (${f.category}) ${f.content}`).join("\n");
-    const entitiesPreview = base.entities.slice(0, 8).map((entity) => `- (${entity.type}) ${entity.name}: ${entity.facts.join("; ") || "(no facts)"}`).join("\n");
-    const proactivePreview = proactiveQuestions.slice(0, maxAdditional).map((question, index) => `${index + 1}. ${question.question}${question.context ? `
-   context: ${question.context}` : ""}`).join("\n");
-    const prompt = [
-      "You are answering proactive memory follow-up questions using only the provided buffered conversation.",
-      `Return at most ${maxAdditional} additional high-confidence memory candidates that were omitted from the base extraction.`,
-      `Only include information directly supported by the conversation. Do not speculate. Do not repeat the base extraction.${ambientCapture ? AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT : ""}`,
-      OUTPUT_LANGUAGE_POLICY,
-      "Return only valid JSON with this shape:",
-      '{"facts":[{"category":"fact","content":"...","confidence":0.0,"tags":["..."],"entityRef":"optional","promptedByQuestion":"optional","quote":"optional verbatim span from a single turn"}],"profileUpdates":["..."],"entities":[{"name":"...","type":"person","facts":["..."],"structuredSections":[{"key":"beliefs","title":"Beliefs","facts":["..."]}],"promptedByQuestion":"optional"}],"relationships":[{"source":"...","target":"...","label":"...","promptedByQuestion":"optional"}]}',
-      this.config.provenance?.enabled ? '- Source quotes: For each fact, include a "quote" field with the EXACT verbatim words from the conversation that support the fact (a contiguous span from a single turn, not a paraphrase). Cap at ~300 chars.' : "",
-      // #1578: emit the same event-time guidance as the primary extraction
-      // paths so proactive-recovered facts also carry an optional eventTime
-      // (chatgpt-codex thread on extraction.ts:1607). Returns "" when the
-      // bi-temporal gate is off, keeping the prompt unchanged by default.
-      eventTimePromptInstruction(this.config),
-      headerConnector(sourceConnector) !== void 0 && resolveMemoryLifecycleCapabilities(this.config).extractionScopeClassification ? `Tool, command, or CLI-flag instructions tied to the ${sourceConnector} agent are "project" scope; when you recover one, begin the fact with a leading "In ${sourceConnector}, " clause naming that agent (e.g. "In ${sourceConnector}, use the search tool with a repository path.").` : "",
-      "",
-      "Base extracted facts (do not repeat):",
-      factsPreview || "(none)",
-      "",
-      "Base extracted entities (do not repeat):",
-      entitiesPreview || "(none)",
-      "",
-      "Answer these follow-up questions from the same conversation only:",
-      proactivePreview || "(none)",
-      "",
-      "Conversation:",
-      conversation
-    ].join("\n");
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResponse = await this.localLlm.chatCompletion(
-          [
-            {
-              role: "system",
-              content: "You are a proactive memory extraction assistant. Output valid JSON only."
-            },
-            { role: "user", content: prompt }
-          ],
-          {
-            temperature: 0.2,
-            maxTokens: this.config.proactiveExtractionMaxTokens,
-            timeoutMs: this.config.proactiveExtractionTimeoutMs,
-            operation: "proactive_extraction",
-            priority: "background",
-            signal
-          }
-        );
-        throwIfExtractionAborted(signal);
-        if (localResponse?.content) {
-          const parsed = this.parseProactiveExtractionResultFromText(localResponse.content.trim());
-          if (parsed) {
-            return parsed;
-          }
-        }
-        if (!this.config.localLlmFallback) {
-          return { facts: [], profileUpdates: [], entities: [], questions: [] };
-        }
-      } catch (err) {
-        if (signal?.aborted || !this.config.localLlmFallback) {
-          throw err;
-        }
-      }
-    }
-    const fallbackResult = await this.fallbackLlm.parseWithSchema(
-      [
-        {
-          role: "system",
-          content: "Answer proactive memory follow-up questions from the provided conversation only. Return valid JSON only."
-        },
-        { role: "user", content: prompt }
-      ],
-      ProactiveExtractionResultSchema,
-      this.withGatewayAgent({
-        temperature: 0.2,
-        maxTokens: this.config.proactiveExtractionMaxTokens,
-        timeoutMs: this.config.proactiveExtractionTimeoutMs,
-        signal
-      })
-    );
-    if (!fallbackResult) {
-      return { facts: [], profileUpdates: [], entities: [], questions: [] };
-    }
-    return this.normalizeExtractionResultPayload({
-      ...fallbackResult,
-      questions: []
-    });
-  }
-  mergeProactiveExtractionPass(base, proactive, maxAdditional) {
-    const allowlist = this.config.proactiveExtractionCategoryAllowlist;
-    let remainingBudget = Math.max(0, Math.floor(maxAdditional));
-    const mergedFacts = [...base.facts];
-    const seenFacts = new Set(base.facts.map((fact) => normalizeFactKey(fact)));
-    for (const fact of proactive.facts) {
-      if (remainingBudget <= 0) break;
-      if (fact.confidence < PROACTIVE_MIN_CONFIDENCE) continue;
-      if (allowlist && !allowlist.includes(fact.category)) continue;
-      const key = normalizeFactKey(fact);
-      if (seenFacts.has(key)) continue;
-      seenFacts.add(key);
-      mergedFacts.push({ ...fact, source: "proactive" });
-      remainingBudget -= 1;
-    }
-    const mergedEntities = base.entities.map((entity) => ({
-      ...entity,
-      facts: [...entity.facts],
-      structuredSections: entity.structuredSections ? entity.structuredSections.map((section) => ({
-        ...section,
-        facts: [...section.facts]
-      })) : void 0
-    }));
-    const entityIndex = new Map(mergedEntities.map((entity, index) => [normalizeEntityKey(entity), index]));
-    for (const entity of proactive.entities) {
-      if (remainingBudget <= 0) break;
-      const key = normalizeEntityKey(entity);
-      const existingIndex = entityIndex.get(key);
-      if (typeof existingIndex === "number") {
-        const existing = mergedEntities[existingIndex];
-        const nextFacts = new Set(existing.facts.map((fact) => fact.trim()));
-        const nextSections = new Map(
-          (existing.structuredSections ?? []).map((section) => [section.key, {
-            ...section,
-            facts: [...section.facts]
-          }])
-        );
-        let changed = false;
-        for (const fact of entity.facts) {
-          const trimmed = fact.trim();
-          if (!trimmed || nextFacts.has(trimmed)) continue;
-          nextFacts.add(trimmed);
-          changed = true;
-        }
-        for (const section of entity.structuredSections ?? []) {
-          const existingSection = nextSections.get(section.key);
-          if (!existingSection) {
-            nextSections.set(section.key, {
-              key: section.key,
-              title: section.title,
-              facts: [...section.facts]
-            });
-            changed = true;
-            continue;
-          }
-          const nextSectionFacts = new Set(existingSection.facts.map((fact) => fact.trim()));
-          for (const fact of section.facts) {
-            const trimmed = fact.trim();
-            if (!trimmed || nextSectionFacts.has(trimmed)) continue;
-            nextSectionFacts.add(trimmed);
-            changed = true;
-          }
-          existingSection.facts = Array.from(nextSectionFacts);
-        }
-        if (changed) {
-          mergedEntities[existingIndex] = {
-            ...existing,
-            facts: Array.from(nextFacts),
-            structuredSections: Array.from(nextSections.values()),
-            source: "proactive",
-            promptedByQuestion: existing.promptedByQuestion ?? entity.promptedByQuestion
-          };
-          remainingBudget -= 1;
-        }
-        continue;
-      }
-      mergedEntities.push({
-        ...entity,
-        source: "proactive",
-        structuredSections: entity.structuredSections ? entity.structuredSections.map((section) => ({
-          ...section,
-          facts: [...section.facts]
-        })) : void 0
-      });
-      entityIndex.set(key, mergedEntities.length - 1);
-      remainingBudget -= 1;
-    }
-    const mergedProfileUpdates = [...base.profileUpdates];
-    const seenProfileUpdates = new Set(base.profileUpdates.map((update) => normalizeProfileUpdateKey(update)));
-    for (const update of proactive.profileUpdates) {
-      if (remainingBudget <= 0) break;
-      const key = normalizeProfileUpdateKey(update);
-      if (!key || seenProfileUpdates.has(key)) continue;
-      seenProfileUpdates.add(key);
-      mergedProfileUpdates.push(update.trim());
-      remainingBudget -= 1;
-    }
-    const mergedRelationships = [...base.relationships ?? []];
-    const seenRelationships = new Set(mergedRelationships.map((relationship) => normalizeRelationshipKey(relationship)));
-    for (const relationship of proactive.relationships ?? []) {
-      if (remainingBudget <= 0) break;
-      const key = normalizeRelationshipKey(relationship);
-      if (seenRelationships.has(key)) continue;
-      seenRelationships.add(key);
-      mergedRelationships.push({ ...relationship, extractionSource: "proactive" });
-      remainingBudget -= 1;
-    }
-    return {
-      ...base,
-      facts: mergedFacts,
-      entities: mergedEntities,
-      profileUpdates: mergedProfileUpdates,
-      relationships: mergedRelationships
-    };
-  }
-  async parseWithGatewayFallback(traceId, operation, startedAtMs, schema, messages, options = {}) {
-    const detailed = await this.fallbackLlm.parseWithSchemaDetailed(messages, schema, this.withGatewayAgent(options));
-    if ("modelUsed" in detailed) {
-      const durationMs = Date.now() - startedAtMs;
-      this.emit({
-        kind: "llm_end",
-        traceId,
-        model: detailed.modelUsed,
-        operation,
-        durationMs,
-        output: JSON.stringify(detailed.result).slice(0, 2e3)
-      });
-      return detailed.result;
-    }
-    return null;
-  }
-  /**
-   * The one funnel every successful extraction path returns through — local
-   * LLM, direct client, and gateway fallback alike. The ambient clamp lives
-   * here so a new path cannot bypass it (issue #2294).
-   */
-  finalizeExtractionResult(result, turns, sourceConnector, ambientCapture = false) {
-    const clamped = ambientCapture ? clampAmbientCaptureConfidence(result) : result;
-    const provenanced = attachExtractionProvenance(clamped, turns, this.config.provenance);
-    return sourceConnector === void 0 ? provenanced : { ...provenanced, sourceConnector };
-  }
-  async extract(turns, existingEntities, signal) {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    const substantiveTurns = turns.filter((t) => t.content.trim().length > 0);
-    if (substantiveTurns.length === 0) {
-      log.debug("extraction skipped \u2014 no substantive turns in buffer");
-      return { facts: [], profileUpdates: [], entities: [], questions: [] };
-    }
-    const boundedTurns = substantiveTurns.map((turn) => ({
-      ...turn,
-      content: turn.role === "assistant" ? applyWorkExtractionBoundary(turn.content) : turn.content
-    })).filter((turn) => turn.content.trim().length > 0);
-    const resolvedConnector = resolveSourceConnector(boundedTurns);
-    const ambientCapture = boundedTurns.some(
-      (turn) => turn.ambientCapture === true && turn.extractionContextOnly !== true
-    );
-    const sourceConnector = lifecycleCaps.extractionScopeClassification ? resolvedConnector : void 0;
-    const { conversation, renderedConversation } = renderExtractionConversation(boundedTurns, headerConnector(sourceConnector));
-    const spanTurns = buildSpanMaterializeTurns(boundedTurns.map((turn) => turn.content));
-    const groundingSource = boundedTurns.map((turn) => turn.content).join("\n\n");
-    const assertionSource = boundedTurns.filter((turn) => turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n");
-    const roleAssertionSources = {
-      profile: boundedTurns.filter((turn) => turn.role === "user" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n"),
-      identity: boundedTurns.filter((turn) => turn.role === "assistant" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n")
-    };
-    if (renderedConversation.trim().length === 0) {
-      log.debug("extraction skipped \u2014 conversation only contained non-memory work-layer context");
-      return {
-        facts: [],
-        profileUpdates: [],
-        entities: [],
-        questions: [],
-        extractionSkippedReason: "conversation_only_non_memory"
-      };
-    }
-    if (lifecycleCaps.extractionTelemetryPrefilter && looksLikeMechanicalTelemetryTranscript(renderedConversation)) {
-      log.debug("extraction skipped \u2014 mechanical action/state telemetry without durable-memory cues");
-      return {
-        facts: [],
-        profileUpdates: [],
-        entities: [],
-        questions: [],
-        extractionSkippedReason: "mechanical_telemetry"
-      };
-    }
-    const lastTurnTs = boundedTurns.length > 0 ? new Date(boundedTurns[boundedTurns.length - 1].timestamp) : void 0;
-    const messageTimestamp = lastTurnTs && !isNaN(lastTurnTs.getTime()) ? lastTurnTs : void 0;
-    const groundingContext = {
-      groundingSource,
-      assertionSource,
-      roleAssertionSources,
-      messageTimestamp,
-      sourceConnector,
-      ambientCapture,
-      scopeClassificationEnabled: lifecycleCaps.extractionScopeClassification
-    };
-    const traceId = crypto.randomUUID();
-    const emittedDirectStart = !!(this.shouldUseDirectClient || this.shouldUseLocalLlm);
-    if (emittedDirectStart) {
-      this.emit({ kind: "llm_start", traceId, model: this.config.model, operation: "extraction", input: conversation });
-    }
-    let closedDirectTrace = false;
-    const startTime = Date.now();
-    const extractionTraceId = this.profiler.startTrace("extraction", void 0, {
-      model: this.config.model,
-      localLlm: resolveLocalLlmCapabilities(this.config).localLlm
-    });
-    this.profiler.startSpan("total", extractionTraceId);
-    let primaryExtractorAttempted = false;
-    try {
-      if (this.shouldUseLocalLlm) {
-        this.profiler.startSpan("local-llm", extractionTraceId);
-        primaryExtractorAttempted = true;
-        try {
-          const localResult = await this.extractWithLocalLlm(conversation, existingEntities, signal, ambientCapture);
-          throwIfExtractionAborted(signal);
-          if (localResult) {
-            const durationMs = Date.now() - startTime;
-            this.profiler.endSpan("local-llm", extractionTraceId);
-            this.emit({ kind: "llm_end", traceId, model: this.config.localLlmModel, operation: "extraction", durationMs });
-            log.debug(`extraction: used local LLM \u2014 ${localResult.facts.length} facts, ${localResult.entities.length} entities`);
-            const localSpanTurns = bindLocalExtractionPrompt(
-              conversation,
-              boundedTurns,
-              this.modelRegistry.calculateContextSizes(
-                this.config.localLlmModel,
-                this.config.localLlmMaxContext
-              ).maxInputChars,
-              renderedConversation
-            ).spanTurns;
-            const sanitized = this.sanitizeExtractionResult(this.applySpanMaterialization(localResult, localSpanTurns), messageTimestamp);
-            const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
-            const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
-            return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector, ambientCapture);
-          }
-          if (!this.config.localLlmFallback) {
-            log.warn("extraction: local LLM failed and fallback disabled");
-            return {
-              facts: [],
-              profileUpdates: [],
-              entities: [],
-              questions: [],
-              extractionFailure: "local_llm_unavailable",
-              extractionFailureClass: "provider_retryable"
-            };
-          }
-          log.info("extraction: local LLM unavailable, falling back to gateway default AI");
-        } catch (err) {
-          if (signal?.aborted) throw err;
-          if (!this.config.localLlmFallback) {
-            log.warn("extraction: local LLM error and fallback disabled:", err);
-            return {
-              facts: [],
-              profileUpdates: [],
-              entities: [],
-              questions: [],
-              extractionFailure: "local_llm_error",
-              extractionFailureClass: "provider_retryable"
-            };
-          }
-          log.info("extraction: local LLM error, falling back to gateway default AI:", err);
-        } finally {
-          try {
-            this.profiler.endSpan("local-llm", extractionTraceId);
-          } catch {
-          }
-        }
-      }
-      if (this.shouldUseDirectClient) {
-        this.profiler.startSpan("direct-client", extractionTraceId);
-        primaryExtractorAttempted = true;
-        try {
-          const directResult = await this.extractWithDirectClient(conversation, existingEntities, signal, ambientCapture);
-          if (directResult) {
-            const durationMs = Date.now() - startTime;
-            this.profiler.endSpan("direct-client", extractionTraceId);
-            this.emit({ kind: "llm_end", traceId, model: this.config.model, operation: "extraction", durationMs });
-            log.debug(`extraction: used direct client (${this.config.model}) \u2014 ${directResult.facts.length} facts, ${directResult.entities.length} entities`);
-            const sanitized = this.sanitizeExtractionResult(this.applySpanMaterialization(directResult, spanTurns), messageTimestamp);
-            const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
-            const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
-            return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector, ambientCapture);
-          }
-          try {
-            this.emit({
-              kind: "llm_error",
-              traceId,
-              model: this.config.model,
-              operation: "extraction",
-              durationMs: Date.now() - startTime,
-              error: "direct client returned no result"
-            });
-          } catch {
-          }
-          closedDirectTrace = true;
-          log.info("extraction: direct client returned no result, falling back to gateway AI");
-        } catch (err) {
-          if (signal?.aborted) throw err;
-          try {
-            this.emit({
-              kind: "llm_error",
-              traceId,
-              model: this.config.model,
-              operation: "extraction",
-              durationMs: Date.now() - startTime,
-              error: String(err)
-            });
-          } catch {
-          }
-          closedDirectTrace = true;
-          log.info("extraction: direct client failed, falling back to gateway AI:", err);
-        } finally {
-          try {
-            this.profiler.endSpan("direct-client", extractionTraceId);
-          } catch {
-          }
-        }
-      }
-      if (emittedDirectStart && !closedDirectTrace) {
-        try {
-          this.emit({
-            kind: "llm_error",
-            traceId,
-            model: this.config.model,
-            operation: "extraction",
-            durationMs: Date.now() - startTime,
-            error: "local LLM failed, handing off to gateway fallback"
-          });
-        } catch {
-        }
-      }
-      const fallbackTraceId = crypto.randomUUID();
-      const fallbackStartTime = Date.now();
-      if (this.useGatewayModelSource) {
-        log.debug(
-          `extraction: using gateway model chain as primary path` + (this.config.taskModelChain ? " (taskModelChain)" : this.config.gatewayAgentId ? ` (agent: ${this.config.gatewayAgentId})` : " (defaults)")
-        );
-      } else {
-        log.info("extraction: falling back to gateway default AI");
-      }
-      this.profiler.startSpan("gateway-fallback", extractionTraceId);
-      try {
-        const messages = [
-          {
-            role: "system",
-            content: buildExtractionInstructions(this.config, existingEntities, ambientCapture) + `
-
-Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
-${extractionResponseShape(this.config.extraction?.spanMode ?? "off")}`
-          },
-          { role: "user", content: conversation }
-        ];
-        this.emit({ kind: "llm_start", traceId: fallbackTraceId, model: "fallback", operation: "extraction", input: conversation });
-        const detailed = await this.fallbackLlm.parseWithSchemaDetailed(
-          messages,
-          ExtractionResultSchema,
-          this.withGatewayAgent({
-            temperature: 0.3,
-            maxTokens: this.config.extractionMaxOutputTokens,
-            timeoutMs: this.config.taskLlmTimeoutMs ?? this.config.localLlmTimeoutMs,
-            jsonSchema: {
-              name: "extraction_result",
-              schema: extractionProviderJsonSchema(this.config.extraction?.spanMode ?? "off"),
-              strict: false
-            },
-            signal
-          })
-        );
-        const fallbackDurationMs = Date.now() - fallbackStartTime;
-        if ("modelUsed" in detailed && Array.isArray(detailed.result.facts)) {
-          const result = detailed.result;
-          this.emit({
-            kind: "llm_end",
-            traceId: fallbackTraceId,
-            model: detailed.modelUsed,
-            operation: "extraction",
-            durationMs: fallbackDurationMs,
-            output: JSON.stringify(result).slice(0, 2e3)
-          });
-          log.debug(
-            `extracted ${result.facts.length} facts, ${result.entities.length} entities, ${(result.questions ?? []).length} questions via fallback (${detailed.modelUsed})`
-          );
-          const normalized = this.normalizeExtractionResultPayload(result);
-          const sanitized = this.sanitizeExtractionResult(this.applySpanMaterialization(normalized, spanTurns), messageTimestamp);
-          const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
-          const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
-          return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector, ambientCapture);
-        }
-        const parseFailure = detailed.result === null ? detailed : { failureReason: "empty", attemptedModel: void 0, httpStatus: void 0, errorClass: "empty" };
-        const failureLog = formatExtractionParseFailureLog({
-          failureReason: parseFailure.failureReason,
-          attemptedModel: parseFailure.attemptedModel,
-          httpStatus: parseFailure.httpStatus,
-          errorClass: parseFailure.errorClass,
-          traceId: fallbackTraceId
-        });
-        this.emit({
-          kind: "llm_error",
-          traceId: fallbackTraceId,
-          model: parseFailure.attemptedModel ?? "fallback",
-          operation: "extraction",
-          durationMs: fallbackDurationMs,
-          error: failureLog
-        });
-        log.warn(failureLog);
-        const fallbackParseFailureClass = detailed.result === null ? detailed.failureReason === "no_models" && primaryExtractorAttempted ? (
-          // Gateway had no models, but a local/direct extractor already failed —
-          // the root cause is the primary (transient), not gateway auth/config.
-          "provider_retryable"
-        ) : classifyFallbackParseFailure(detailed.failureReason) : "parse_empty";
-        return {
-          facts: [],
-          profileUpdates: [],
-          entities: [],
-          questions: [],
-          extractionFailure: "fallback_no_parsed_output",
-          extractionFailureClass: fallbackParseFailureClass
-        };
-      } catch (err) {
-        if (signal?.aborted) throw err;
-        this.emit({
-          kind: "llm_error",
-          traceId: fallbackTraceId,
-          model: "fallback",
-          operation: "extraction",
-          durationMs: Date.now() - fallbackStartTime,
-          error: String(err)
-        });
-        log.error("extraction fallback failed", err);
-        return {
-          facts: [],
-          profileUpdates: [],
-          entities: [],
-          questions: [],
-          extractionFailure: "fallback_failed",
-          extractionFailureClass: classifyExtractionThrownError(err)
-        };
-      } finally {
-        try {
-          this.profiler.endSpan("gateway-fallback", extractionTraceId);
-        } catch {
-        }
-      }
-    } finally {
-      this.profiler.endSpan("total", extractionTraceId);
-      this.profiler.endTrace(extractionTraceId);
-    }
-  }
-  /**
-   * Extract memories using local LLM with JSON mode.
-   * Uses a minimal prompt to fit within local model context limits (typically 4k-8k).
-   */
-  async extractWithLocalLlm(conversation, existingEntities, signal, ambientCapture = false) {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    log.debug(
-      `extractWithLocalLlm: starting extraction, localLlmEnabled=${this.shouldUseLocalLlm}, model=${this.config.localLlmModel}`
-    );
-    const contextSizes = this.modelRegistry.calculateContextSizes(
-      this.config.localLlmModel,
-      this.config.localLlmMaxContext
-    );
-    log.debug(`Model context: ${contextSizes.description}`);
-    const maxConversationChars = contextSizes.maxInputChars;
-    const truncatedConversation = truncateLocalExtractionConversation(conversation, maxConversationChars);
-    const localPrompt = `You are a memory extraction system. Extract durable, reusable memories from this conversation.
-
-Use the most specific category:
-- fact: objective information
-- preference: a durable preference or style
-- correction: a correction of a prior mistake
-- entity: a durable person, project, tool, company, or place
-- decision: a choice with rationale
-- relationship: a durable link between two entities
-- principle: a reusable rule or operating belief
-${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? "- rule: an explicit causal rule or constraint\n" : ""}- commitment: a promise, obligation, or deadline
-- moment: a significant milestone
-- skill: a demonstrated capability
-- procedure: an explicit reusable workflow with ordered procedureSteps
-- reasoning_trace: Stored solution chains \u2014 an explicitly narrated solution path with reasoningTrace. Use {"category": "reasoning_trace", "reasoningTrace": {"steps": [...], "finalAnswer": "..."}} only when the conversation provides the chain.
-
-Rules:
-- Extract only new information stated or clearly established in the conversation.
-- Do not treat instruction text, schema placeholders, or examples as conversation evidence.
-- Facts, entity facts, profile updates, questions, and relationships must be grounded in the conversation.
-- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.
-- Questions are optional. Return an empty array when the conversation does not support a useful unresolved question.
-- Set confidence from source evidence: Explicit (0.95-1.0), Implied (0.70-0.94), Inferred (0.40-0.69), or Speculative (0.00-0.39). Corrections get highest confidence.
-- Use normalized, hyphenated entity names and keep the entity list short. When the source language is not written in a Latin script, the source-script name IS the normalized form \u2014 never transliterate or translate it.
-- Keep facts standalone. Skip transient task state and operational noise such as routine scheduler, monitoring, or automation status.
-- Add structuredAttributes only for concrete values.
-- ${OUTPUT_LANGUAGE_POLICY}
-${CUE_ANCHOR_PROMPT_INSTRUCTION}
-- Include at most five durable relationships.${this.config.provenance?.enabled ? `
-- Each fact must include a quote copied verbatim from one contiguous conversation span.` : ""}${lifecycleCaps.extractionScopeClassification ? `
-- Set each fact scope to "global" for cross-project knowledge or "project" for codebase-specific knowledge. Tool, command, or CLI-flag instructions tied to one agent are "project" (the same tool name can mean different things across agents); when keeping one, begin the fact with a leading "In <agent>," clause naming that agent.` : ""}${this.config.subjectClassification?.enabled === true ? `
-- Set each fact subject to "user" when it models the person (preferences, relationships, biography, moments, commitments about their life) or "agent" when it is reusable operating knowledge (procedures, principles, tool-usage lessons, debugging strategies, environment facts with no personal content).` : ""}${ambientCapture ? AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT : ""}
-${eventTimePromptInstruction(this.config)}${spanModePromptSection(this.config.extraction?.spanMode ?? "off")}
-Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
-${extractionResponseShape(this.config.extraction?.spanMode ?? "off")}
-
-Conversation:
-${truncatedConversation}`;
-    log.debug(
-      `extractWithLocalLlm: calling localLlm.chatCompletion with prompt length ${localPrompt.length}...`
-    );
-    const response = await this.localLlm.chatCompletion(
-      [
-        { role: "system", content: "You are a memory extraction system. Output valid JSON only." },
-        { role: "user", content: localPrompt }
-      ],
-      {
-        temperature: 0.1,
-        maxTokens: contextSizes.maxOutputTokens,
-        operation: "extraction",
-        disableThinking: shouldEnableLocalExtractionThinking(this.config, conversation.length) ? false : void 0,
-        priority: "background",
-        signal
-      }
-    );
-    if (!response?.content) {
-      log.debug("extractWithLocalLlm: chatCompletion returned null or empty content");
-      return null;
-    }
-    const content = response.content.trim();
-    log.debug(`extractWithLocalLlm: got response content, length=${content.length}`);
-    for (const candidate of extractJsonCandidates(content)) {
-      try {
-        log.debug(`extractWithLocalLlm: attempting JSON parse, candidate length=${candidate.length}`);
-        const parsed = JSON.parse(candidate);
-        if (!this.looksLikeExtractionResultPayload(parsed)) {
-          continue;
-        }
-        const result = this.normalizeExtractionResultPayload(parsed);
-        log.debug(
-          `extractWithLocalLlm: successfully parsed response, facts=${result.facts.length}, entities=${result.entities.length}, profileUpdates=${result.profileUpdates.length}, questions=${result.questions.length}`
-        );
-        return result;
-      } catch {
-      }
-    }
-    log.debug("extractWithLocalLlm: JSON parse failed, attempting partial extraction...");
-    const partial = this.extractPartialFacts(content);
-    if (partial.facts.length > 0 || partial.entities.length > 0) {
-      log.debug(
-        `extractWithLocalLlm: extracted ${partial.facts.length} partial facts from truncated JSON`
-      );
-      return partial;
-    }
-    return null;
-  }
-  /**
-   * Extract memories using direct OpenAI-compatible client (Chat Completions API).
-   * Works with Scryr, OpenRouter, and other OpenAI-compatible endpoints.
-   */
-  async extractWithDirectClient(conversation, existingEntities, signal, ambientCapture = false) {
-    if (!this.client) return null;
-    const tokenParams = buildChatCompletionTokenLimit(this.config.model, this.config.extractionMaxOutputTokens, {
-      assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-    });
-    log.debug(`extractWithDirectClient: calling model=${this.config.model} tokenParams=${JSON.stringify(tokenParams)}`);
-    const response = await this.client.chat.completions.create(
-      {
-        model: this.config.model,
-        messages: [
-          {
-            role: "system",
-            content: buildExtractionInstructions(this.config, existingEntities, ambientCapture) + `
-
-Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
-${extractionResponseShape(this.config.extraction?.spanMode ?? "off")}`
-          },
-          { role: "user", content: conversation }
-        ],
-        ...tokenParams
-      },
-      signal ? { signal } : void 0
-    );
-    const content = response.choices?.[0]?.message?.content?.trim();
-    if (!content) {
-      log.info(`extractWithDirectClient: empty response \u2014 choices=${JSON.stringify(response.choices?.length ?? 0)} finishReason=${response.choices?.[0]?.finish_reason ?? "n/a"}`);
-      return null;
-    }
-    log.info(
-      `extractWithDirectClient: got response, length=${content.length}`
-    );
-    for (const candidate of extractJsonCandidates(content)) {
-      try {
-        const parsed = JSON.parse(candidate);
-        return this.normalizeExtractionResultPayload(parsed);
-      } catch {
-      }
-    }
-    log.info(`extractWithDirectClient: failed to parse JSON from response (first 200 chars: ${content.slice(0, 200)})`);
-    return null;
-  }
-  /**
-   * Extract partial facts from truncated JSON responses.
-   * Local LLMs sometimes hit token limits mid-JSON. This tries to salvage valid facts.
-   */
-  extractPartialFacts(jsonStr) {
-    const facts = [];
-    const entities = [];
-    try {
-      const factRegex = /\{\s*"category"\s*:\s*"([^"]+)"\s*,\s*"content"\s*:\s*"([^"]+)"\s*,\s*"confidence"\s*:\s*([0-9.]+)/g;
-      let match;
-      while ((match = factRegex.exec(jsonStr)) !== null) {
-        const category = match[1]?.trim() ?? "";
-        if (!isMemoryCategory(category)) continue;
-        facts.push({
-          category,
-          content: match[2].replace(/\\n/g, "\n").replace(/\\"/g, '"'),
-          confidence: parseFloat(match[3]),
-          tags: []
-        });
-      }
-      const entityRegex = /\{\s*"name"\s*:\s*"([^"]+)"\s*,\s*"type"\s*:\s*"([^"]+)"/g;
-      while ((match = entityRegex.exec(jsonStr)) !== null) {
-        const type = extractionEntityType(match[2]);
-        if (type === void 0) continue;
-        entities.push({
-          name: match[1],
-          type,
-          facts: []
-        });
-      }
-    } catch {
-    }
-    return this.normalizeExtractionResultPayload({ facts, entities, profileUpdates: [], questions: [] });
-  }
-  async consolidate(newMemories, existingMemories, currentProfile) {
-    const newList = newMemories.map(
-      (m) => `[${m.frontmatter.id}] (${m.frontmatter.category}) ${m.content}`
-    ).join("\n");
-    const existingList = existingMemories.slice(-50).map(
-      (m) => `[${m.frontmatter.id}] (${m.frontmatter.category}) ${m.content}`
-    ).join("\n");
-    const cTraceId = crypto.randomUUID();
-    this.emit({ kind: "llm_start", traceId: cTraceId, model: this.config.model, operation: "consolidation", input: newList });
-    const cStartTime = Date.now();
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResult = await this.consolidateWithLocalLlm(newList, existingList, currentProfile);
-        if (localResult) {
-          const durationMs = Date.now() - cStartTime;
-          this.emit({ kind: "llm_end", traceId: cTraceId, model: this.config.localLlmModel, operation: "consolidation", durationMs });
-          log.debug(`consolidation: used local LLM \u2014 ${localResult.items.length} decisions`);
-          return this.sanitizeConsolidationResult(localResult);
-        }
-        if (!this.config.localLlmFallback) {
-          log.warn("consolidation: local LLM failed and fallback disabled");
-          return { items: [], profileUpdates: [], entityUpdates: [] };
-        }
-        log.info("consolidation: local LLM unavailable, falling back to gateway AI");
-      } catch (err) {
-        if (!this.config.localLlmFallback) {
-          log.warn("consolidation: local LLM error and fallback disabled:", err);
-          return { items: [], profileUpdates: [], entityUpdates: [] };
-        }
-        log.info("consolidation: local LLM error, falling back to gateway AI:", err);
-      }
-    }
-    const fallbackResult = await this.parseWithGatewayFallback(
-      cTraceId,
-      "consolidation",
-      cStartTime,
-      ConsolidationResultSchema,
-      [
-        {
-          role: "system",
-          content: buildConsolidationSystemPrompt(this.config)
-        },
-        {
-          role: "user",
-          content: `Current behavioral profile:
-${currentProfile || "(empty)"}
-
-Existing memories:
-${existingList || "(none)"}
-
-New memories to consolidate:
-${newList}
-
-Consolidate the new memories against existing ones.`
-        }
-      ],
-      { temperature: 0.3, maxTokens: 4096 }
-    );
-    if (fallbackResult) {
-      log.debug(`consolidation: ${fallbackResult.items.length} decisions via fallback`);
-      return this.sanitizeConsolidationResult({
-        items: fallbackResult.items,
-        profileUpdates: fallbackResult.profileUpdates,
-        entityUpdates: fallbackResult.entityUpdates
-      });
-    }
-    if (!this.client) {
-      log.warn("consolidation skipped \u2014 no OpenAI API key and local LLM failed/disabled");
-      return { items: [], profileUpdates: [], entityUpdates: [] };
-    }
-    try {
-      const instructionText = `${buildConsolidationSystemPrompt(this.config)}
-
-Current behavioral profile:
-${currentProfile || "(empty)"}
-
-Existing memories:
-${existingList || "(none)"}
-
-New memories to consolidate:
-${newList}
-
-Respond with valid JSON only, matching this schema:
-${CONSOLIDATION_RESPONSE_SCHEMA}`;
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: "Consolidate the new memories against existing ones." }
-        ],
-        ...this.config.reasoningEffort !== "none" ? { reasoning_effort: this.config.reasoningEffort } : {},
-        ...buildChatCompletionTokenLimit(this.config.model, 4096, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const rawContent = response.choices?.[0]?.message?.content?.trim();
-      const cDurationMs = Date.now() - cStartTime;
-      const cUsage = response.usage;
-      let parsed = null;
-      if (rawContent) {
-        for (const candidate of extractJsonCandidates(rawContent)) {
-          try {
-            parsed = JSON.parse(candidate);
-            break;
-          } catch {
-          }
-        }
-      }
-      this.emit({
-        kind: "llm_end",
-        traceId: cTraceId,
-        model: this.config.model,
-        operation: "consolidation",
-        durationMs: cDurationMs,
-        output: parsed ? JSON.stringify(parsed).slice(0, 2e3) : void 0,
-        tokenUsage: cUsage ? { input: cUsage.prompt_tokens, output: cUsage.completion_tokens, total: cUsage.total_tokens } : void 0
-      });
-      if (parsed && Array.isArray(parsed.items)) {
-        log.debug(
-          `consolidation: ${parsed.items.length} decisions`
-        );
-        return this.sanitizeConsolidationResult({
-          items: parsed.items,
-          profileUpdates: Array.isArray(parsed.profileUpdates) ? parsed.profileUpdates : [],
-          entityUpdates: Array.isArray(parsed.entityUpdates) ? parsed.entityUpdates : []
-        });
-      }
-      log.warn("consolidation returned no parsed output");
-      return { items: [], profileUpdates: [], entityUpdates: [] };
-    } catch (err) {
-      this.emit({
-        kind: "llm_error",
-        traceId: cTraceId,
-        model: this.config.model,
-        operation: "consolidation",
-        durationMs: Date.now() - cStartTime,
-        error: String(err)
-      });
-      log.error("consolidation failed", err);
-      return { items: [], profileUpdates: [], entityUpdates: [] };
-    }
-  }
-  /**
-   * Consolidate memories using local LLM.
-   */
-  async consolidateWithLocalLlm(newList, existingList, currentProfile) {
-    const contextSizes = this.modelRegistry.calculateContextSizes(
-      this.config.localLlmModel,
-      this.config.localLlmMaxContext
-    );
-    log.debug(`Consolidation model context: ${contextSizes.description}`);
-    const prompt = `${buildConsolidationSystemPrompt(this.config)}
-
-Current behavioral profile:
-${currentProfile || "(empty)"}
-
-Existing memories:
-${existingList || "(none)"}
-
-New memories to consolidate:
-${newList}
-
-Respond with valid JSON matching this schema:
-${CONSOLIDATION_RESPONSE_SCHEMA}`;
-    const response = await this.localLlm.chatCompletion(
-      [
-        { role: "system", content: "You are a memory consolidation system. Output valid JSON only." },
-        { role: "user", content: prompt }
-      ],
-      {
-        temperature: 0.3,
-        maxTokens: contextSizes.maxOutputTokens,
-        operation: "consolidation",
-        priority: "background"
-      }
-    );
-    if (!response?.content) {
-      return null;
-    }
-    try {
-      const content = response.content.trim();
-      for (const candidate of extractJsonCandidates(content)) {
-        try {
-          const parsed = JSON.parse(candidate);
-          return {
-            items: Array.isArray(parsed.items) ? parsed.items : [],
-            profileUpdates: Array.isArray(parsed.profileUpdates) ? parsed.profileUpdates : [],
-            entityUpdates: Array.isArray(parsed.entityUpdates) ? parsed.entityUpdates : []
-          };
-        } catch {
-        }
-      }
-      return null;
-    } catch (err) {
-      log.warn("local LLM consolidation: failed to parse JSON response:", err);
-      return null;
-    }
-  }
-  /**
-   * Consolidate a bloated profile.md into a compact version.
-   * The LLM merges duplicates, removes stale info, and preserves section structure.
-   * Returns the consolidated markdown or null on failure.
-   */
-  async consolidateProfile(fullProfileContent, targetLines = 50) {
-    const pTraceId = crypto.randomUUID();
-    this.emit({ kind: "llm_start", traceId: pTraceId, model: this.config.model, operation: "profile_consolidation", input: fullProfileContent.slice(0, 2e3) });
-    const pStartTime = Date.now();
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResult = await this.consolidateProfileWithLocalLlm(fullProfileContent, targetLines);
-        if (localResult) {
-          const durationMs = Date.now() - pStartTime;
-          this.emit({ kind: "llm_end", traceId: pTraceId, model: this.config.localLlmModel, operation: "profile_consolidation", durationMs });
-          log.debug(`profile consolidation: used local LLM \u2014 removed ${localResult.removedCount} items`);
-          return localResult;
-        }
-        if (!this.config.localLlmFallback) {
-          log.warn("profile consolidation: local LLM failed and fallback disabled");
-          return null;
-        }
-        log.info("profile consolidation: local LLM unavailable, falling back to gateway AI");
-      } catch (err) {
-        if (!this.config.localLlmFallback) {
-          log.warn("profile consolidation: local LLM error and fallback disabled:", err);
-          return null;
-        }
-        log.info("profile consolidation: local LLM error, falling back to gateway AI:", err);
-      }
-    }
-    const profileFallback = await this.parseWithGatewayFallback(
-      pTraceId,
-      "profile_consolidation",
-      pStartTime,
-      buildProfileConsolidationResultSchema(targetLines),
-      [
-        {
-          role: "system",
-          content: buildProfileConsolidationSystemPrompt(targetLines)
-        },
-        { role: "user", content: fullProfileContent }
-      ],
-      { temperature: 0.3, maxTokens: 4096 }
-    );
-    if (profileFallback) {
-      log.debug(
-        `profile consolidation: removed ${profileFallback.removedCount} items \u2014 ${profileFallback.summary} (fallback)`
-      );
-      return profileFallback;
-    }
-    if (!this.client) {
-      log.warn("profile consolidation skipped \u2014 no OpenAI API key and local LLM failed/disabled");
-      return null;
-    }
-    try {
-      const instructionText = `${buildProfileConsolidationSystemPrompt(targetLines)}
-
-Respond with valid JSON matching this schema:
-${PROFILE_CONSOLIDATION_RESPONSE_SCHEMA}`;
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: fullProfileContent }
-        ],
-        ...this.config.reasoningEffort !== "none" ? { reasoning_effort: this.config.reasoningEffort } : {},
-        ...buildChatCompletionTokenLimit(this.config.model, 4096, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const rawContent = response.choices?.[0]?.message?.content?.trim();
-      const pDurationMs = Date.now() - pStartTime;
-      const pUsage = response.usage;
-      let parsed = null;
-      if (rawContent) {
-        for (const candidate of extractJsonCandidates(rawContent)) {
-          try {
-            parsed = JSON.parse(candidate);
-            break;
-          } catch {
-          }
-        }
-      }
-      this.emit({
-        kind: "llm_end",
-        traceId: pTraceId,
-        model: this.config.model,
-        operation: "profile_consolidation",
-        durationMs: pDurationMs,
-        output: parsed ? parsed.summary : void 0,
-        tokenUsage: pUsage ? { input: pUsage.prompt_tokens, output: pUsage.completion_tokens, total: pUsage.total_tokens } : void 0
-      });
-      if (parsed && typeof parsed.consolidatedProfile === "string") {
-        log.debug(
-          `profile consolidation: removed ${parsed.removedCount ?? 0} items \u2014 ${parsed.summary ?? ""}`
-        );
-        return {
-          consolidatedProfile: parsed.consolidatedProfile,
-          removedCount: Number(parsed.removedCount || 0),
-          summary: String(parsed.summary || "")
-        };
-      }
-      log.warn("profile consolidation returned no parsed output");
-      return null;
-    } catch (err) {
-      this.emit({
-        kind: "llm_error",
-        traceId: pTraceId,
-        model: this.config.model,
-        operation: "profile_consolidation",
-        durationMs: Date.now() - pStartTime,
-        error: String(err)
-      });
-      log.error("profile consolidation failed", err);
-      return null;
-    }
-  }
-  /**
-   * Consolidate profile using local LLM.
-   */
-  async consolidateProfileWithLocalLlm(fullProfileContent, targetLines = 50) {
-    const contextSizes = this.modelRegistry.calculateContextSizes(
-      this.config.localLlmModel,
-      this.config.localLlmMaxContext
-    );
-    log.debug(`Profile consolidation model context: ${contextSizes.description}`);
-    const prompt = `${buildProfileConsolidationSystemPrompt(targetLines)}
-
-Profile to consolidate:
-${fullProfileContent}
-
-Respond with valid JSON matching this schema:
-${PROFILE_CONSOLIDATION_RESPONSE_SCHEMA}`;
-    const response = await this.localLlm.chatCompletion(
-      [
-        { role: "system", content: "You are a profile consolidation system. Output valid JSON only." },
-        { role: "user", content: prompt }
-      ],
-      {
-        temperature: 0.3,
-        maxTokens: contextSizes.maxOutputTokens,
-        operation: "profile_consolidation",
-        priority: "background"
-      }
-    );
-    if (!response?.content) {
-      return null;
-    }
-    try {
-      const content = response.content.trim();
-      for (const candidate of extractJsonCandidates(content)) {
-        try {
-          const parsed = JSON.parse(candidate);
-          return {
-            consolidatedProfile: String(parsed.consolidatedProfile || ""),
-            removedCount: Number(parsed.removedCount || 0),
-            summary: String(parsed.summary || "")
-          };
-        } catch {
-        }
-      }
-      return null;
-    } catch (err) {
-      log.warn("local LLM profile consolidation: failed to parse JSON response:", err);
-      return null;
-    }
-  }
-  /**
-   * Consolidate IDENTITY.md reflections into a concise "Learned Patterns" section.
-   * Returns the new content for the IDENTITY.md file (everything below the static header).
-   */
-  async consolidateIdentity(fullIdentityContent, staticHeaderEndMarker) {
-    const iTraceId = crypto.randomUUID();
-    this.emit({ kind: "llm_start", traceId: iTraceId, model: this.config.model, operation: "identity_consolidation", input: fullIdentityContent.slice(0, 2e3) });
-    const iStartTime = Date.now();
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResult = await this.consolidateIdentityWithLocalLlm(fullIdentityContent);
-        if (localResult) {
-          const durationMs = Date.now() - iStartTime;
-          this.emit({ kind: "llm_end", traceId: iTraceId, model: this.config.localLlmModel, operation: "identity_consolidation", durationMs });
-          log.debug(`identity consolidation: used local LLM \u2014 ${localResult.learnedPatterns.length} patterns`);
-          return localResult;
-        }
-        if (!this.config.localLlmFallback) {
-          log.warn("identity consolidation: local LLM failed and fallback disabled");
-          return null;
-        }
-        log.info("identity consolidation: local LLM unavailable, falling back to gateway AI");
-      } catch (err) {
-        if (!this.config.localLlmFallback) {
-          log.warn("identity consolidation: local LLM error and fallback disabled:", err);
-          return null;
-        }
-        log.info("identity consolidation: local LLM error, falling back to gateway AI:", err);
-      }
-    }
-    const identityFallback = await this.parseWithGatewayFallback(
-      iTraceId,
-      "identity_consolidation",
-      iStartTime,
-      IdentityConsolidationResultSchema,
-      [
-        {
-          role: "system",
-          content: `You are an identity consolidation system. You are given the full contents of an IDENTITY.md file that contains many individual reflection entries. Your job is to:
-
-1. Read all the reflection entries (sections starting with "## Reflection")
-2. Extract the most important, durable behavioral patterns and lessons learned
-3. Consolidate them into concise, standalone statements (aim for 10-25 key patterns)
-4. Remove redundancy \u2014 if multiple reflections say the same thing, merge into one clear statement
-5. Prioritize patterns that are actionable and recurring over one-off observations
-6. Write a brief summary paragraph
-
-The goal is to reduce a bloated file to a compact, high-signal set of learned patterns while preserving all genuinely useful self-knowledge.`
-        },
-        { role: "user", content: fullIdentityContent }
-      ],
-      { temperature: 0.3, maxTokens: 4096 }
-    );
-    if (identityFallback) {
-      log.debug(
-        `identity consolidation: ${identityFallback.learnedPatterns.length} patterns (fallback)`
-      );
-      return identityFallback;
-    }
-    if (!this.client) {
-      log.warn("identity consolidation skipped \u2014 no OpenAI API key and local LLM failed/disabled");
-      return null;
-    }
-    try {
-      const instructionText = `You are an identity consolidation system. You are given the full contents of an IDENTITY.md file that contains many individual reflection entries. Your job is to:
-
-1. Read all the reflection entries (sections starting with "## Reflection")
-2. Extract the most important, durable behavioral patterns and lessons learned
-3. Consolidate them into concise, standalone statements (aim for 10-25 key patterns)
-4. Remove redundancy \u2014 if multiple reflections say the same thing, merge into one clear statement
-5. Prioritize patterns that are actionable and recurring over one-off observations
-6. Write a brief summary paragraph
-
-The goal is to reduce a bloated file to a compact, high-signal set of learned patterns while preserving all genuinely useful self-knowledge.
-
-Respond with valid JSON matching this schema:
-{
-  "learnedPatterns": ["pattern 1", "pattern 2", "pattern 3"],
-  "summary": "brief summary of consolidation"
-}`;
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: fullIdentityContent }
-        ],
-        ...this.config.reasoningEffort !== "none" ? { reasoning_effort: this.config.reasoningEffort } : {},
-        ...buildChatCompletionTokenLimit(this.config.model, 4096, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const rawContent = response.choices?.[0]?.message?.content?.trim();
-      const iDurationMs = Date.now() - iStartTime;
-      const iUsage = response.usage;
-      let parsed = null;
-      if (rawContent) {
-        for (const candidate of extractJsonCandidates(rawContent)) {
-          try {
-            parsed = JSON.parse(candidate);
-            break;
-          } catch {
-          }
-        }
-      }
-      this.emit({
-        kind: "llm_end",
-        traceId: iTraceId,
-        model: this.config.model,
-        operation: "identity_consolidation",
-        durationMs: iDurationMs,
-        output: parsed ? parsed.summary : void 0,
-        tokenUsage: iUsage ? { input: iUsage.prompt_tokens, output: iUsage.completion_tokens, total: iUsage.total_tokens } : void 0
-      });
-      if (parsed && Array.isArray(parsed.learnedPatterns)) {
-        const learnedPatterns = parsed.learnedPatterns.filter((pattern) => typeof pattern === "string").map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0);
-        log.debug(
-          `identity consolidation: ${learnedPatterns.length} patterns`
-        );
-        return {
-          learnedPatterns,
-          summary: String(parsed.summary || "")
-        };
-      }
-      log.warn("identity consolidation returned no parsed output");
-      return null;
-    } catch (err) {
-      this.emit({
-        kind: "llm_error",
-        traceId: iTraceId,
-        model: this.config.model,
-        operation: "identity_consolidation",
-        durationMs: Date.now() - iStartTime,
-        error: String(err)
-      });
-      log.error("identity consolidation failed", err);
-      return null;
-    }
-  }
-  /**
-   * Consolidate identity using local LLM.
-   */
-  async consolidateIdentityWithLocalLlm(fullIdentityContent) {
-    const contextSizes = this.modelRegistry.calculateContextSizes(
-      this.config.localLlmModel,
-      this.config.localLlmMaxContext
-    );
-    log.debug(`Identity consolidation model context: ${contextSizes.description}`);
-    const prompt = `You are an identity consolidation system. You are given the full contents of an IDENTITY.md file that contains many individual reflection entries. Your job is to:
-
-1. Read all the reflection entries (sections starting with "## Reflection")
-2. Extract the most important, durable behavioral patterns and lessons learned
-3. Consolidate them into concise, standalone statements (aim for 10-25 key patterns)
-4. Remove redundancy \u2014 if multiple reflections say the same thing, merge into one clear statement
-5. Prioritize patterns that are actionable and recurring over one-off observations
-6. Write a brief summary paragraph
-
-The goal is to reduce a bloated file to a compact, high-signal set of learned patterns while preserving all genuinely useful self-knowledge.
-
-IDENTITY.md content:
-${fullIdentityContent}
-
-Respond with valid JSON matching this schema:
-{
-  "learnedPatterns": ["pattern 1", "pattern 2", "pattern 3"],
-  "summary": "brief summary of consolidation"
-}`;
-    const response = await this.localLlm.chatCompletion(
-      [
-        { role: "system", content: "You are an identity consolidation system. Output valid JSON only." },
-        { role: "user", content: prompt }
-      ],
-      {
-        temperature: 0.3,
-        maxTokens: contextSizes.maxOutputTokens,
-        operation: "identity_consolidation",
-        priority: "background"
-      }
-    );
-    if (!response?.content) {
-      return null;
-    }
-    try {
-      const content = response.content.trim();
-      for (const candidate of extractJsonCandidates(content)) {
-        try {
-          const parsed = JSON.parse(candidate);
-          return {
-            learnedPatterns: Array.isArray(parsed.learnedPatterns) ? parsed.learnedPatterns : [],
-            summary: String(parsed.summary || "")
-          };
-        } catch {
-        }
-      }
-      return null;
-    } catch (err) {
-      log.warn("local LLM identity consolidation: failed to parse JSON response:", err);
-      return null;
-    }
-  }
-  /**
-   * Verify if two memories contradict each other using LLM.
-   * Called when QMD finds semantically similar memories (Phase 2B).
-   */
-  async verifyContradiction(newMemory, existingMemory) {
-    const input = `Memory 1 (existing, created ${existingMemory.created}):
-Category: ${existingMemory.category}
-Content: ${existingMemory.content}
-
-Memory 2 (new):
-Category: ${newMemory.category}
-Content: ${newMemory.content}`;
-    try {
-      const instructionText = `You are a contradiction detection system. Analyze whether two memories contradict each other.
-
-IMPORTANT: Not all similar memories are contradictions!
-- "User likes TypeScript" and "User likes Python" are NOT contradictions (preferences can coexist)
-- "User prefers dark mode" and "User prefers light mode" ARE contradictions (mutually exclusive)
-- "User's email is a@b.com" and "User's email is c@d.com" ARE contradictions (only one email)
-- "User works at Acme" and "User used to work at Acme" might be a contradiction (temporal change)
-
-Only mark as contradiction if the two statements CANNOT both be true at the same time.
-
-If they ARE contradictory, determine which represents the more recent/current state based on:
-- Explicit time references ("now", "currently", "used to", "no longer")
-- The fact that newer corrections often start with "actually" or "correction"
-- Context clues about change over time
-
-Respond with valid JSON matching this schema:
-{
-  "isContradiction": true,
-  "confidence": 0.95,
-  "reasoning": "why they contradict or don't",
-  "whichIsNewer": "first"
-}`;
-      if (this.shouldUseLocalLlm) {
-        try {
-          const localResponse = await this.localLlm.chatCompletion(
-            [
-              { role: "system", content: instructionText },
-              { role: "user", content: input }
-            ],
-            {
-              temperature: 0.3,
-              maxTokens: 2048,
-              operation: "contradiction_verification",
-              priority: "background"
-            }
-          );
-          const normalized2 = this.normalizeContradictionVerificationResult(
-            this.parseJsonObject(localResponse?.content)
-          );
-          if (normalized2) {
-            log.debug(
-              `contradiction check via local LLM: ${normalized2.isContradiction ? "YES" : "NO"} (confidence: ${normalized2.confidence})`
-            );
-            return normalized2;
-          }
-          if (!this.config.localLlmFallback) {
-            log.warn("contradiction verification skipped \u2014 local LLM returned invalid JSON and cloud fallback is disabled");
-            return null;
-          }
-        } catch (err) {
-          if (!this.config.localLlmFallback) {
-            log.warn(`contradiction verification skipped \u2014 local LLM failed and cloud fallback is disabled: ${err}`);
-            return null;
-          }
-        }
-      }
-      if (!this.shouldUseDirectClient) {
-        const fallbackResponse = await this.fallbackLlm.chatCompletion(
-          [
-            { role: "system", content: instructionText },
-            { role: "user", content: input }
-          ],
-          this.withGatewayAgent({ temperature: 0.3, maxTokens: 2048 })
-        );
-        const normalized2 = this.normalizeContradictionVerificationResult(
-          this.parseJsonObject(fallbackResponse?.content)
-        );
-        if (normalized2) {
-          log.debug(
-            `contradiction check via fallback: ${normalized2.isContradiction ? "YES" : "NO"} (confidence: ${normalized2.confidence})`
-          );
-          return normalized2;
-        }
-        log.warn("contradiction verification skipped \u2014 no OpenAI API key and fallback unavailable");
-        return null;
-      }
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: input }
-        ],
-        ...buildChatCompletionTokenLimit(this.config.model, 2048, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const normalized = this.normalizeContradictionVerificationResult(
-        this.parseJsonObject(response.choices?.[0]?.message?.content)
-      );
-      if (normalized) {
-        log.debug(
-          `contradiction check: ${normalized.isContradiction ? "YES" : "NO"} (confidence: ${normalized.confidence})`
-        );
-        return normalized;
-      }
-      return null;
-    } catch (err) {
-      log.error("contradiction verification failed", err);
-      return null;
-    }
-  }
-  async revalidateDependents(superseded, replacement, dependents, signal) {
-    const complete = async (messages, options) => {
-      try {
-        const fast = await this.fastChatCompletion?.(messages, options);
-        if (fast) return fast;
-      } catch (error) {
-        if (isAbortError(error) || options.signal?.aborted) throw error;
-        log.warn(`dependency revalidation fast route failed: ${error}`);
-      }
-      if (this.shouldUseLocalLlm) {
-        try {
-          const local = await this.localLlm.chatCompletion(messages, options);
-          if (local || !this.config.localLlmFallback) return local;
-        } catch (error) {
-          if (!this.config.localLlmFallback) throw error;
-        }
-      }
-      if (!this.shouldUseDirectClient) {
-        return this.fallbackLlm.chatCompletion(messages, this.withGatewayAgent(options));
-      }
-      const client = this.client;
-      if (!client) return null;
-      if (!shouldAssumeOpenAiChatCompletions(client.baseURL ?? this.config.openaiBaseUrl)) {
-        const response2 = await client.chat.completions.create(
-          {
-            model: this.config.model,
-            messages,
-            max_tokens: options.maxTokens
-          },
-          { signal: options.signal }
-        );
-        const content = response2.choices[0]?.message?.content;
-        return typeof content === "string" ? { content } : null;
-      }
-      const response = await client.responses.create({
-        model: this.config.model,
-        instructions: messages.find((message) => message.role === "system")?.content,
-        input: messages.filter((message) => message.role !== "system").map((message) => message.content).join("\n\n"),
-        max_output_tokens: options.maxTokens
-      }, { signal: options.signal });
-      return typeof response.output_text === "string" ? { content: response.output_text } : null;
-    };
-    return revalidateDependentsViaLlm(
-      { fastChatCompletion: complete, parseJsonObject: this.parseJsonObject },
-      superseded,
-      replacement,
-      dependents,
-      { signal, timeoutMs: this.config.dependencyPropagation.timeoutMs }
-    );
-  }
-  async suggestLinks(newMemory, candidateMemories) {
-    if (candidateMemories.length === 0) {
-      return { links: [] };
-    }
-    const candidateList = candidateMemories.map((m, i) => `[${i + 1}] ID: ${m.id}
-Category: ${m.category}
-Content: ${m.content}`).join("\n\n");
-    const input = `New memory:
-Category: ${newMemory.category}
-Content: ${newMemory.content}
-
-Candidate memories to link to:
-${candidateList}`;
-    try {
-      const instructionText = `You are a memory linking system. Analyze the new memory and suggest relationships to existing memories.
-
-Link types:
-- follows: This memory is a continuation or next step (e.g., decision follows discussion)
-- references: This memory mentions or refers to the other (e.g., fact references entity)
-- contradicts: This memory conflicts with the other (use sparingly, only for true contradictions)
-- supports: This memory provides evidence or reinforcement (e.g., example supports principle)
-- related: General topical relationship
-
-Rules:
-- Only suggest links with strength > 0.5
-- Quality over quantity \u2014 0-3 links is typical
-- Prefer specific link types over generic "related"
-- Consider entity references, topics, and causal relationships
-
-Respond with valid JSON matching this schema:
-{
-  "links": [{"targetId": "memory-id", "linkType": "follows|references|contradicts|supports|related", "strength": 0.8, "reason": "why"}]
-}`;
-      if (this.shouldUseLocalLlm) {
-        try {
-          const localResponse = await this.localLlm.chatCompletion(
-            [
-              { role: "system", content: instructionText },
-              { role: "user", content: input }
-            ],
-            {
-              temperature: 0.3,
-              maxTokens: 2048,
-              operation: "link_suggestion",
-              priority: "background"
-            }
-          );
-          const normalized2 = this.normalizeSuggestedLinksResult(this.parseJsonObject(localResponse?.content));
-          if (normalized2) {
-            log.debug(`suggested ${normalized2.links.length} links via local LLM`);
-            return normalized2;
-          }
-          if (!this.config.localLlmFallback) {
-            log.warn("link suggestion skipped \u2014 local LLM returned invalid JSON and cloud fallback is disabled");
-            return null;
-          }
-        } catch (err) {
-          if (!this.config.localLlmFallback) {
-            log.warn(`link suggestion skipped \u2014 local LLM failed and cloud fallback is disabled: ${err}`);
-            return null;
-          }
-        }
-      }
-      if (!this.shouldUseDirectClient) {
-        const fallbackResponse = await this.fallbackLlm.chatCompletion(
-          [
-            { role: "system", content: instructionText },
-            { role: "user", content: input }
-          ],
-          this.withGatewayAgent({ temperature: 0.3, maxTokens: 2048 })
-        );
-        const normalized2 = this.normalizeSuggestedLinksResult(this.parseJsonObject(fallbackResponse?.content));
-        if (normalized2) {
-          log.debug(`suggested ${normalized2.links.length} links via fallback`);
-          return normalized2;
-        }
-        log.warn("link suggestion skipped \u2014 no OpenAI API key and fallback unavailable");
-        return null;
-      }
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: input }
-        ],
-        ...buildChatCompletionTokenLimit(this.config.model, 2048, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const normalized = this.normalizeSuggestedLinksResult(
-        this.parseJsonObject(response.choices?.[0]?.message?.content)
-      );
-      if (normalized) {
-        log.debug(`suggested ${normalized.links.length} links`);
-        return normalized;
-      }
-      return null;
-    } catch (err) {
-      log.error("link suggestion failed", err);
-      return null;
-    }
-  }
-  async generateDaySummary(memories) {
-    if (!resolveRecallAuxiliaryCapabilities(this.config).daySummary) {
-      log.warn("day summary skipped \u2014 disabled by config");
-      return null;
-    }
-    const memoryContext = formatDaySummaryMemories(memories);
-    if (memoryContext.length === 0) return null;
-    const instructionText = await loadDaySummaryPrompt();
-    let extensionsFooter = "";
-    try {
-      extensionsFooter = await buildExtensionsFooterForSummary(this.config);
-    } catch {
-    }
-    const userPrompt = `Generate an end-of-day summary from this Remnic memory context:
-
-${memoryContext}${extensionsFooter.length > 0 ? `
-
-${extensionsFooter}` : ""}`;
-    const traceId = crypto.randomUUID();
-    const startedAt = Date.now();
-    this.emit({ kind: "llm_start", traceId, model: this.config.model, operation: "day_summary", input: memoryContext.slice(0, 4e3) });
-    if (this.shouldUseLocalLlm) {
-      try {
-        const localResponse = await this.localLlm.chatCompletion(
-          [
-            { role: "system", content: `${instructionText}
-
-Return valid JSON only.` },
-            { role: "user", content: userPrompt }
-          ],
-          {
-            temperature: 0.2,
-            maxTokens: 2048,
-            operation: "day_summary",
-            priority: "background"
-          }
-        );
-        const normalized = this.normalizeDaySummaryResult(this.parseJsonObject(localResponse?.content));
-        if (normalized) {
-          this.emit({ kind: "llm_end", traceId, model: this.config.localLlmModel, operation: "day_summary", durationMs: Date.now() - startedAt, output: JSON.stringify(normalized).slice(0, 2e3) });
-          log.debug(`generated day summary via local LLM (${normalized.bullets.length} bullets)`);
-          return normalized;
-        }
-        if (!this.config.localLlmFallback) {
-          this.emit({ kind: "llm_error", traceId, model: this.config.localLlmModel, operation: "day_summary", durationMs: Date.now() - startedAt, error: "local LLM returned invalid JSON and fallback disabled" });
-          log.warn("day summary skipped \u2014 local LLM returned invalid JSON and fallback disabled");
-          return null;
-        }
-      } catch (err) {
-        if (!this.config.localLlmFallback) {
-          this.emit({ kind: "llm_error", traceId, model: this.config.localLlmModel, operation: "day_summary", durationMs: Date.now() - startedAt, error: String(err) });
-          log.warn(`day summary skipped \u2014 local LLM failed and fallback disabled: ${err}`);
-          return null;
-        }
-      }
-    }
-    const fallbackResult = await this.parseWithGatewayFallback(
-      traceId,
-      "day_summary",
-      startedAt,
-      DaySummaryResultSchema,
-      [
-        { role: "system", content: `${instructionText}
-
-Return valid JSON only.` },
-        { role: "user", content: userPrompt }
-      ],
-      { temperature: 0.2, maxTokens: 2048 }
-    );
-    if (fallbackResult) {
-      const normalized = this.normalizeDaySummaryResult(fallbackResult);
-      if (normalized) {
-        log.debug(`generated day summary via fallback (${normalized.bullets.length} bullets)`);
-        return normalized;
-      }
-    }
-    if (this.shouldUseDirectClient) {
-      try {
-        const response = await this.client.responses.create({
-          model: this.config.model,
-          instructions: `${instructionText}
-
-Return valid JSON only.`,
-          input: userPrompt,
-          max_output_tokens: 2048
-        });
-        const rawText = typeof response.output_text === "string" ? response.output_text : JSON.stringify(response.output_text ?? "");
-        const normalized = this.normalizeDaySummaryResult(this.parseJsonObject(rawText));
-        if (normalized) {
-          this.emit({ kind: "llm_end", traceId, model: this.config.model, operation: "day_summary", durationMs: Date.now() - startedAt, output: JSON.stringify(normalized).slice(0, 2e3) });
-          log.debug(`generated day summary via Responses API (${normalized.bullets.length} bullets)`);
-          return normalized;
-        }
-        this.emit({ kind: "llm_error", traceId, model: this.config.model, operation: "day_summary", durationMs: Date.now() - startedAt, error: "Responses API returned unparseable output" });
-      } catch (err) {
-        this.emit({ kind: "llm_error", traceId, model: this.config.model, operation: "day_summary", durationMs: Date.now() - startedAt, error: `Responses API failed: ${err}` });
-      }
-    }
-    this.emit({ kind: "llm_error", traceId, model: this.config.model, operation: "day_summary", durationMs: Date.now() - startedAt, error: "all generation paths exhausted (local LLM + gateway + Responses API)" });
-    log.warn("day summary skipped \u2014 all generation paths exhausted");
-    return null;
-  }
-  /**
-   * Summarize a batch of old memories into a compact summary (Phase 4A).
-   */
-  async summarizeMemories(memories) {
-    if (memories.length === 0) return null;
-    const memoryList = memories.map((m) => `[${m.id}] (${m.category}, ${m.created.slice(0, 10)})
-${m.content}`).join("\n\n");
-    try {
-      const instructionText = `You are a memory summarization system. You are given a batch of old memories that need to be compressed into a summary.
-
-Your task:
-1. Write a concise summary paragraph (2-4 sentences) capturing the essence of these memories
-2. Extract the 5-10 most important facts that should be preserved
-3. List the key entities mentioned
-
-Guidelines:
-- Preserve specific, actionable information
-- Merge redundant details into single statements
-- Focus on durable insights, not transient details
-- Maintain any preferences, decisions, or corrections as key facts
-
-Respond with valid JSON matching this schema:
-{
-  "summaryText": "concise summary paragraph",
-  "keyFacts": ["fact 1", "fact 2"],
-  "keyEntities": ["entity-1", "entity-2"]
-}`;
-      if (this.shouldUseLocalLlm) {
-        try {
-          const localResponse = await this.localLlm.chatCompletion(
-            [
-              { role: "system", content: instructionText },
-              { role: "user", content: `Summarize these ${memories.length} memories:
-
-${memoryList}` }
-            ],
-            {
-              temperature: 0.3,
-              maxTokens: 4096,
-              operation: "memory_summarization",
-              priority: "background"
-            }
-          );
-          const normalized2 = this.normalizeMemorySummaryResult(this.parseJsonObject(localResponse?.content));
-          if (normalized2) {
-            log.debug(
-              `summarized ${memories.length} memories into ${normalized2.keyFacts.length} key facts via local LLM`
-            );
-            return normalized2;
-          }
-          if (!this.config.localLlmFallback) {
-            log.warn("summarization skipped \u2014 local LLM returned invalid JSON and cloud fallback is disabled");
-            return null;
-          }
-        } catch (err) {
-          if (!this.config.localLlmFallback) {
-            log.warn(`summarization skipped \u2014 local LLM failed and cloud fallback is disabled: ${err}`);
-            return null;
-          }
-        }
-      }
-      if (!this.shouldUseDirectClient) {
-        const fallbackResponse = await this.fallbackLlm.chatCompletion(
-          [
-            { role: "system", content: instructionText },
-            { role: "user", content: `Summarize these ${memories.length} memories:
-
-${memoryList}` }
-          ],
-          this.withGatewayAgent({ temperature: 0.3, maxTokens: 4096 })
-        );
-        const normalized2 = this.normalizeMemorySummaryResult(this.parseJsonObject(fallbackResponse?.content));
-        if (normalized2) {
-          log.debug(`summarized ${memories.length} memories into ${normalized2.keyFacts.length} key facts via fallback`);
-          return normalized2;
-        }
-        log.warn("summarization skipped \u2014 no OpenAI API key and fallback unavailable");
-        return null;
-      }
-      const response = await this.client.chat.completions.create({
-        model: this.config.model,
-        messages: [
-          { role: "system", content: instructionText },
-          { role: "user", content: `Summarize these ${memories.length} memories:
-
-${memoryList}` }
-        ],
-        ...buildChatCompletionTokenLimit(this.config.model, 4096, {
-          assumeOpenAI: this.directClientUsesOpenAiTokenSemantics()
-        })
-      });
-      const normalized = this.normalizeMemorySummaryResult(
-        this.parseJsonObject(response.choices?.[0]?.message?.content)
-      );
-      if (normalized) {
-        log.debug(`summarized ${memories.length} memories into ${normalized.keyFacts.length} key facts`);
-        return normalized;
-      }
-      return null;
-    } catch (err) {
-      log.error("memory summarization failed", err);
-      return null;
-    }
-  }
-};
-
-export {
-  shouldEnableLocalExtractionThinking,
-  ExtractionEngine
-};
-//# sourceMappingURL=chunk-KH2D26LQ.js.map