@remnic/core 10.0.69 → 10.0.70

package/dist/{chunk-5KDDAQ6K.js → chunk-WN2DASTS.js}

@@ -1,13 +1,18 @@
 import {
-  matchesOfflineSyncDefaultExclude
-} from "./chunk-63LFM77Z.js";
+  EMBEDDING_SHARD_FILE_PATTERN
+} from "./chunk-LDWE7OZS.js";
 import {
   prepareSafeArchiveRoot,
   resolveSafeArchiveTarget
 } from "./chunk-GCGJW34D.js";
 import {
-  EMBEDDING_SHARD_FILE_PATTERN
-} from "./chunk-LDWE7OZS.js";
+  matchesOfflineSyncDefaultExclude
+} from "./chunk-63LFM77Z.js";
+import {
+  assertEmbeddingGenerationLockHeld,
+  embeddingGenerationLockPath,
+  withEmbeddingGenerationLock
+} from "./chunk-XZ66U5M3.js";
 import {
   EmbeddingIndexFileStore,
   EmbeddingIndexStorageError,
@@ -16,11 +21,6 @@ import {
   shardEntriesForIndex,
   validateShardMembership
 } from "./chunk-SWRRZNHM.js";
-import {
-  assertEmbeddingGenerationLockHeld,
-  embeddingGenerationLockPath,
-  withEmbeddingGenerationLock
-} from "./chunk-XZ66U5M3.js";
 import {
   GENERATION_MARKER_BASENAME,
   beginGenerationMarker,
@@ -709,4 +709,4 @@ export {
   divergedEmbeddingGenerationDeferrals,
   applyIncomingEmbeddingGenerations
 };
-//# sourceMappingURL=chunk-5KDDAQ6K.js.map
+//# sourceMappingURL=chunk-WN2DASTS.js.map

package/dist/chunk-WZU5AGO6.js

@@ -0,0 +1,38 @@
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/access-observe-stage-timing.ts
+var OBSERVE_SLOW_LOG_MS = 1e4;
+function createObserveStageTimer() {
+  const startedAtMs = performance.now();
+  const stageMs = {};
+  const formatStages = () => Object.entries(stageMs).map(([stage, ms]) => `${stage}Ms=${Math.round(ms)}`).join(" ");
+  return {
+    async timed(stage, fn) {
+      const stageStartMs = performance.now();
+      try {
+        return await fn();
+      } finally {
+        stageMs[stage] = (stageMs[stage] ?? 0) + (performance.now() - stageStartMs);
+      }
+    },
+    logSlow(messages) {
+      const totalMs = Math.round(performance.now() - startedAtMs);
+      if (totalMs < OBSERVE_SLOW_LOG_MS) return;
+      log.warn(
+        `access-observe-slow totalMs=${totalMs} messages=${messages} ${formatStages()}`
+      );
+    },
+    logFailed(messages) {
+      log.warn(
+        `access-observe-failed totalMs=${Math.round(performance.now() - startedAtMs)} messages=${messages} ${formatStages()}`
+      );
+    }
+  };
+}
+
+export {
+  createObserveStageTimer
+};
+//# sourceMappingURL=chunk-WZU5AGO6.js.map

package/dist/chunk-WZU5AGO6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/access-observe-stage-timing.ts"],"sourcesContent":["/**\n * Noncontent stage timing for the observe surface.\n *\n * Durations only — never message content, session keys, namespaces or\n * principals. A monotonic clock (`performance.now`) keeps phase durations\n * sane under wall-clock corrections.\n *\n * A slow observe logs `access-observe-slow`; a failed observe always logs\n * `access-observe-failed`, so a 25s-class stall attributes to a phase\n * instead of a guess.\n */\nimport { log } from \"./logger.js\";\n\n/** Observes slower than this log `access-observe-slow` with per-stage durations. */\nconst OBSERVE_SLOW_LOG_MS = 10_000;\n\nexport interface ObserveStageTimer {\n  /** Run one stage, recording its duration even when the stage rejects. */\n  timed<T>(stage: string, fn: () => Promise<T>): Promise<T>;\n  /** Log a slow successful observe with per-stage durations. */\n  logSlow(messages: number): void;\n  /** Log a failed observe with per-stage durations. */\n  logFailed(messages: number): void;\n}\n\n/** Timer for one observe request. */\nexport function createObserveStageTimer(): ObserveStageTimer {\n  const startedAtMs = performance.now();\n  const stageMs: Record<string, number> = {};\n\n  const formatStages = (): string =>\n    Object.entries(stageMs)\n      .map(([stage, ms]) => `${stage}Ms=${Math.round(ms)}`)\n      .join(\" \");\n\n  return {\n    async timed<T>(stage: string, fn: () => Promise<T>): Promise<T> {\n      const stageStartMs = performance.now();\n      try {\n        return await fn();\n      } finally {\n        stageMs[stage] = (stageMs[stage] ?? 0) + (performance.now() - stageStartMs);\n      }\n    },\n    logSlow(messages: number): void {\n      const totalMs = Math.round(performance.now() - startedAtMs);\n      if (totalMs < OBSERVE_SLOW_LOG_MS) return;\n      log.warn(\n        `access-observe-slow totalMs=${totalMs} messages=${messages} ${formatStages()}`,\n      );\n    },\n    logFailed(messages: number): void {\n      log.warn(\n        `access-observe-failed totalMs=${Math.round(performance.now() - startedAtMs)} messages=${messages} ${formatStages()}`,\n      );\n    },\n  };\n}\n"],"mappings":";;;;;AAcA,IAAM,sBAAsB;AAYrB,SAAS,0BAA6C;AAC3D,QAAM,cAAc,YAAY,IAAI;AACpC,QAAM,UAAkC,CAAC;AAEzC,QAAM,eAAe,MACnB,OAAO,QAAQ,OAAO,EACnB,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,EACnD,KAAK,GAAG;AAEb,SAAO;AAAA,IACL,MAAM,MAAS,OAAe,IAAkC;AAC9D,YAAM,eAAe,YAAY,IAAI;AACrC,UAAI;AACF,eAAO,MAAM,GAAG;AAAA,MAClB,UAAE;AACA,gBAAQ,KAAK,KAAK,QAAQ,KAAK,KAAK,MAAM,YAAY,IAAI,IAAI;AAAA,MAChE;AAAA,IACF;AAAA,IACA,QAAQ,UAAwB;AAC9B,YAAM,UAAU,KAAK,MAAM,YAAY,IAAI,IAAI,WAAW;AAC1D,UAAI,UAAU,oBAAqB;AACnC,UAAI;AAAA,QACF,+BAA+B,OAAO,aAAa,QAAQ,IAAI,aAAa,CAAC;AAAA,MAC/E;AAAA,IACF;AAAA,IACA,UAAU,UAAwB;AAChC,UAAI;AAAA,QACF,iCAAiC,KAAK,MAAM,YAAY,IAAI,IAAI,WAAW,CAAC,aAAa,QAAQ,IAAI,aAAa,CAAC;AAAA,MACrH;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-UVYI6VIX.js → chunk-X7Y7WX73.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-UVYI6VIX.js.map
+//# sourceMappingURL=chunk-X7Y7WX73.js.map

package/dist/{chunk-5Y6VA6X2.js → chunk-XDUP6SWG.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-NHWDTOBN.js";
+} from "./chunk-ILD7N3XC.js";
 import {
   composeMemoryEnvelope
 } from "./chunk-JRVMCZE3.js";
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-5Y6VA6X2.js.map
+//# sourceMappingURL=chunk-XDUP6SWG.js.map

package/dist/{chunk-GHHQLSSY.js → chunk-XR4QR3JT.js}

@@ -8,11 +8,11 @@ import {
 } from "./chunk-YUTT4ZTI.js";
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-5UM4H64E.js";
+} from "./chunk-D3AGBN6G.js";
 import {
   StorageManager,
   readRawMemoryDocument
-} from "./chunk-NHWDTOBN.js";
+} from "./chunk-ILD7N3XC.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1869,4 +1869,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-GHHQLSSY.js.map
+//# sourceMappingURL=chunk-XR4QR3JT.js.map

package/dist/{chunk-64S6X4IU.js → chunk-XTN54NML.js}

@@ -1,3 +1,6 @@
+import {
+  ClaudeCodeAdapter
+} from "./chunk-3JKYQBLC.js";
 import {
   CodexAdapter
 } from "./chunk-7RKSJVOQ.js";
@@ -7,9 +10,6 @@ import {
 import {
   ReplitAdapter
 } from "./chunk-SI36RWC3.js";
-import {
-  ClaudeCodeAdapter
-} from "./chunk-3JKYQBLC.js";
 import {
   headerValue
 } from "./chunk-NJAIR57U.js";
@@ -110,4 +110,4 @@ export {
   OpenCodeAdapter,
   AdapterRegistry
 };
-//# sourceMappingURL=chunk-64S6X4IU.js.map
+//# sourceMappingURL=chunk-XTN54NML.js.map

package/dist/{chunk-QGFR73SN.js → chunk-YIG4HPY4.js}

@@ -1,6 +1,6 @@
 import {
   defineOperation
-} from "./chunk-6WKWL53V.js";
+} from "./chunk-B7YAIHAV.js";
 import {
   EngramAccessInputError
 } from "./chunk-LGEH473S.js";
@@ -92,4 +92,4 @@ defineOperation({
     };
   }
 });
-//# sourceMappingURL=chunk-QGFR73SN.js.map
+//# sourceMappingURL=chunk-YIG4HPY4.js.map

package/dist/{chunk-UYUFDTIX.js → chunk-YIXWY4OZ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-AJG2TAMR.js";
 import {
   deepRecallRequestSchema
-} from "./chunk-H6VJSITJ.js";
+} from "./chunk-CIL4GHMD.js";
 import {
   EngramAccessInputError
 } from "./chunk-LGEH473S.js";
@@ -40,4 +40,4 @@ async function respondDeepRecall(req, res, respondJson, readJsonBody, service, s
 export {
   respondDeepRecall
 };
-//# sourceMappingURL=chunk-UYUFDTIX.js.map
+//# sourceMappingURL=chunk-YIXWY4OZ.js.map

package/dist/{chunk-GJ4HU6LK.js → chunk-YLMTFRZR.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportError,
   getOperation
-} from "./chunk-6WKWL53V.js";
+} from "./chunk-B7YAIHAV.js";
 import {
   abortError,
   isAbortError
@@ -499,4 +499,4 @@ export {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers
 };
-//# sourceMappingURL=chunk-GJ4HU6LK.js.map
+//# sourceMappingURL=chunk-YLMTFRZR.js.map

package/dist/{chunk-GGD2YDS6.js → chunk-YRMSHA7H.js}

@@ -1,7 +1,7 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-6WKWL53V.js";
+} from "./chunk-B7YAIHAV.js";
 import {
   SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
 } from "./chunk-PWPIERBM.js";
@@ -343,4 +343,4 @@ export {
   parseSupportPassportModelJob,
   SupportPassportModelBridge
 };
-//# sourceMappingURL=chunk-GGD2YDS6.js.map
+//# sourceMappingURL=chunk-YRMSHA7H.js.map

package/dist/{chunk-Y7427SL7.js → chunk-ZG4GNPRE.js}

@@ -1,6 +1,15 @@
+import {
+  LcmSummarizer
+} from "./chunk-AQNHEDXP.js";
+import {
+  LcmArchive
+} from "./chunk-SDL22RRW.js";
+import {
+  LcmDag
+} from "./chunk-7N4KAIGN.js";
 import {
   LcmWorkQueue
-} from "./chunk-MMCO4SRG.js";
+} from "./chunk-QNN4FYBD.js";
 import {
   assembleCompressedHistoryWithTrace
 } from "./chunk-UXPUUL3G.js";
@@ -8,15 +17,6 @@ import {
   ensureLcmStateDir,
   openLcmDatabase
 } from "./chunk-DDA47TES.js";
-import {
-  LcmSummarizer
-} from "./chunk-KOLJJN5G.js";
-import {
-  LcmArchive
-} from "./chunk-WVP2I6C5.js";
-import {
-  LcmDag
-} from "./chunk-7N4KAIGN.js";
 import {
   nativeBindingRecoveryHint
 } from "./chunk-LD72P4YS.js";
@@ -74,6 +74,9 @@ var EMPTY_LCM_STATS = {
   totalSummaryNodes: 0,
   maxDepth: -1
 };
+var LCM_SUMMARIZE_MAX_LEAF_BATCHES_PER_JOB = 16;
+var LCM_SUMMARIZE_RETRY_BASE_MS = 500;
+var LCM_SUMMARIZE_RETRY_MAX_MS = 3e4;
 var LcmEngine = class {
   constructor(pluginConfig, summarizeFn) {
     this.summarizeFn = summarizeFn;
@@ -90,6 +93,14 @@ var LcmEngine = class {
   config;
   memoryDir;
   initPromise = null;
+  summarizeRetryTimers = /* @__PURE__ */ new Map();
+  summarizeRetryAttempts = /* @__PURE__ */ new Map();
+  /** Resolved when the session's pending retry timer has fired or been cleared. */
+  summarizeRetryWaiters = /* @__PURE__ */ new Map();
+  /** Explicit idle waiters per session; referenced only while nonzero. */
+  summarizeRetryIdleWaiters = /* @__PURE__ */ new Map();
+  /** Base backoff delay; tests shrink it to keep the retry loop fast. */
+  summarizeRetryBaseMs = LCM_SUMMARIZE_RETRY_BASE_MS;
   pendingObserveInitCounts = /* @__PURE__ */ new Map();
   pendingObserveInitWaiters = /* @__PURE__ */ new Map();
   pendingObserveInitIdleWaiters = [];
@@ -130,8 +141,8 @@ var LcmEngine = class {
     );
     const observeQueue = new LcmWorkQueue({
       concurrency: this.config.observeConcurrency,
-      worker: async (sessionId, messages) => {
-        await this.processObserveMessages(sessionId, messages);
+      worker: async (sessionId) => {
+        await this.processSummarizeJob(sessionId);
       },
       hooks: {
         onJobStart: ({ sessionId, depth, inFlight, waitMs }) => {
@@ -169,47 +180,73 @@ var LcmEngine = class {
     this.dag = dag;
     this.summarizer = summarizer;
     this.observeQueue = observeQueue;
+    this.resumeOutstandingSummaries();
     log.info("LCM engine initialized");
   }
   /**
-   * Enqueue messages from agent_end hook.
-   * The queue worker performs the archive append and incremental summarization.
+   * Restart resume: sessions whose durable archive still holds complete
+   * unsummarized batches get a summary job without any new observe call.
+   * Only session references are queued — the content already lives in SQLite.
+   */
+  resumeOutstandingSummaries() {
+    if (!this.archive || !this.observeQueue) return;
+    const sessions = this.archive.listSessionsWithUnsummarizedTurns(
+      this.config.leafBatchSize
+    );
+    if (sessions.length === 0) return;
+    for (const sessionId of sessions) this.observeQueue.enqueue(sessionId);
+    log.info(`LCM resume scheduled summary jobs: sessions=${sessions.length}`);
+  }
+  /**
+   * Archive observed messages and schedule background summarization.
+   *
+   * The archive append completes BEFORE this resolves: an accepted observe is
+   * already durable in SQLite, so a crash cannot lose it. Only the
+   * summarization is background work, and it resumes from the durable archive.
    */
   async observeMessages(sessionId, messages) {
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return;
-    this.enqueueObserveMessages(normalizedSessionId, messages);
+    await this.enqueueObserveMessages(normalizedSessionId, messages);
   }
-  /** Enqueue an observe job without waiting for worker completion. */
-  enqueueObserveMessages(sessionId, messages) {
-    if (!this.config.enabled || this.closed) return;
+  /**
+   * Durably archive messages, then queue a metadata-only summary job.
+   *
+   * Rejects when the archive append fails — callers must not treat a failed
+   * archive as an accepted observation.
+   */
+  async enqueueObserveMessages(sessionId, messages) {
+    if (!this.config.enabled) return;
+    if (this.closed) throw new Error("LCM engine is closed");
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return;
     if (messages.length === 0) return;
     this.reservePendingObserveInit(normalizedSessionId);
-    void this.ensureInitialized().then(() => {
-      if (this.closed || !this.observeQueue) return;
-      this.observeQueue.enqueue(normalizedSessionId, messages);
+    try {
+      await this.ensureInitialized();
+      if (this.closed) throw new Error("LCM engine is closed");
+      if (!this.archive || !this.observeQueue) {
+        throw new Error("LCM engine is not initialized");
+      }
+      const archived = this.archiveObservedMessages(normalizedSessionId, messages);
+      this.observeQueue.enqueue(normalizedSessionId);
       log.debug(
-        `LCM observe enqueued: session=${normalizedSessionId}, depth=${this.observeQueue.depth}, inFlight=${this.observeQueue.inFlightCount}`
+        `LCM observe archived: session=${normalizedSessionId}, messages=${archived}, depth=${this.observeQueue.depth}, inFlight=${this.observeQueue.inFlightCount}`
       );
-    }).catch((err) => {
-      if (this.closed) return;
+    } catch (err) {
       log.error(
-        `LCM observe enqueue initialization error: ${err}${nativeBindingRecoveryHint(err)}`
+        `LCM observe archive failed: session=${normalizedSessionId}, error=${err}${nativeBindingRecoveryHint(err)}`
       );
-    }).finally(() => {
+      throw err;
+    } finally {
       this.releasePendingObserveInit(normalizedSessionId);
-    });
+    }
   }
-  async processObserveMessages(sessionId, messages) {
-    if (this.closed) return;
-    await this.ensureInitialized();
-    if (this.closed || !this.archive || !this.summarizer) return;
-    if (messages.length === 0) return;
+  /** Append observed messages to the archive; returns the number of rows. */
+  archiveObservedMessages(sessionId, messages) {
     const currentMax = this.archive.getMaxTurnIndex(sessionId);
     const { messagePartsEnabled } = this.config;
-    const newMessages = messages.map((m, i) => ({
+    const rows = messages.map((m, i) => ({
       turnIndex: currentMax + 1 + i,
       role: m.role,
       content: m.content,
@@ -217,14 +254,90 @@ var LcmEngine = class {
       rawContent: messagePartsEnabled ? m.rawContent : void 0,
       sourceFormat: messagePartsEnabled ? m.sourceFormat : void 0
     }));
-    this.archive.appendMessages(sessionId, newMessages, {
-      messagePartsEnabled
-    });
+    this.archive.appendMessages(sessionId, rows, { messagePartsEnabled });
+    return rows.length;
+  }
+  /**
+   * Summarize one session's durable backlog.
+   *
+   * The pass is capped so a long backlog never holds a job open indefinitely;
+   * remaining batches stay durable and the job re-queues itself.
+   */
+  async processSummarizeJob(sessionId) {
+    if (this.closed) return;
+    await this.ensureInitialized();
+    if (this.closed || !this.archive || !this.summarizer || !this.observeQueue)
+      return;
     try {
-      await this.summarizer.summarizeIncremental(sessionId);
+      await this.summarizer.summarizeIncremental(sessionId, {
+        maxLeafBatches: LCM_SUMMARIZE_MAX_LEAF_BATCHES_PER_JOB
+      });
     } catch (err) {
-      log.debug(`LCM incremental summarization error: ${err}`);
+      log.error(`LCM incremental summarization failed: session=${sessionId}, error=${err}`);
+      this.scheduleSummarizeRetry(sessionId);
+      return;
+    }
+    this.clearSummarizeRetry(sessionId);
+    if (this.hasCompleteBatchPending(sessionId)) {
+      this.observeQueue.enqueue(sessionId);
+    }
+  }
+  /**
+   * Schedule a metadata-only retry for a failed summary pass.
+   *
+   * The retry keeps trying for as long as the engine is open and complete
+   * batches remain — a transient failure must never strand durable work.
+   * What is bounded is the RATE, not the ability to retry: one pending timer
+   * per session, exponential backoff capped at
+   * {@link LCM_SUMMARIZE_RETRY_MAX_MS}, and an unreferenced timer that is
+   * cleared when the engine closes.
+   */
+  scheduleSummarizeRetry(sessionId) {
+    if (this.closed || this.summarizeRetryTimers.has(sessionId)) return;
+    const attempt = (this.summarizeRetryAttempts.get(sessionId) ?? 0) + 1;
+    this.summarizeRetryAttempts.set(sessionId, attempt);
+    const delayMs = Math.min(
+      LCM_SUMMARIZE_RETRY_MAX_MS,
+      this.summarizeRetryBaseMs * 2 ** Math.min(attempt - 1, 16)
+    );
+    const retry = Promise.withResolvers();
+    this.summarizeRetryWaiters.set(sessionId, retry);
+    const timer = setTimeout(() => {
+      this.summarizeRetryTimers.delete(sessionId);
+      this.summarizeRetryWaiters.delete(sessionId);
+      if (this.closed) {
+        retry.resolve();
+        return;
+      }
+      if (!this.hasCompleteBatchPending(sessionId)) {
+        this.summarizeRetryAttempts.delete(sessionId);
+        retry.resolve();
+        return;
+      }
+      this.observeQueue?.enqueue(sessionId);
+      retry.resolve();
+    }, delayMs);
+    timer.unref?.();
+    this.summarizeRetryTimers.set(sessionId, timer);
+  }
+  /** True when the session still holds a complete unsummarized batch. */
+  hasCompleteBatchPending(sessionId) {
+    if (!this.archive) return false;
+    return this.archive.countUnsummarizedMessages(sessionId) >= this.config.leafBatchSize;
+  }
+  /** Drop a pending retry, its attempt counter, and release idle waiters. */
+  clearSummarizeRetry(sessionId) {
+    const timer = this.summarizeRetryTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.summarizeRetryTimers.delete(sessionId);
+    }
+    const waiter = this.summarizeRetryWaiters.get(sessionId);
+    if (waiter) {
+      this.summarizeRetryWaiters.delete(sessionId);
+      waiter.resolve();
     }
+    this.summarizeRetryAttempts.delete(sessionId);
   }
   get observeQueueDepth() {
     return this.observeQueue?.depth ?? 0;
@@ -232,12 +345,21 @@ var LcmEngine = class {
   get observeQueueInFlightCount() {
     return this.observeQueue?.inFlightCount ?? 0;
   }
-  async waitForObserveQueueIdle() {
+  async waitForObserveQueueIdle(abortSignal) {
+    abortSignal?.throwIfAborted();
     if (!this.config.enabled || this.closed) return;
     await this.ensureInitialized();
+    abortSignal?.throwIfAborted();
     if (this.closed) return;
-    await this.waitForPendingObserveInitIdle();
-    await this.observeQueue?.whenIdle();
+    for (; ; ) {
+      abortSignal?.throwIfAborted();
+      await this.waitForPendingObserveInitIdle(void 0, abortSignal);
+      await this.observeQueue?.whenIdle(abortSignal);
+      abortSignal?.throwIfAborted();
+      const entry = [...this.summarizeRetryWaiters.entries()][0];
+      if (!entry) return;
+      await this.awaitSummarizeRetry(entry[0], entry[1], abortSignal);
+    }
   }
   async waitForSessionObserveIdle(sessionId, abortSignal) {
     abortSignal?.throwIfAborted();
@@ -247,8 +369,34 @@ var LcmEngine = class {
     await this.ensureInitialized();
     abortSignal?.throwIfAborted();
     if (this.closed) return;
-    await this.waitForPendingObserveInitIdle(normalizedSessionId, abortSignal);
-    await this.observeQueue?.whenSessionIdle(normalizedSessionId, abortSignal) ?? Promise.resolve();
+    for (; ; ) {
+      await this.waitForPendingObserveInitIdle(normalizedSessionId, abortSignal);
+      await this.observeQueue?.whenSessionIdle(normalizedSessionId, abortSignal) ?? Promise.resolve();
+      const waiter = this.summarizeRetryWaiters.get(normalizedSessionId);
+      if (!waiter) return;
+      await this.awaitSummarizeRetry(normalizedSessionId, waiter, abortSignal);
+    }
+  }
+  /**
+   * Park an explicit idle wait on a pending retry. While any wait is parked,
+   * the retry timer is referenced so a one-shot host cannot exit under the
+   * wait; with no waiters the timer stays unreferenced background work.
+   */
+  async awaitSummarizeRetry(sessionId, waiter, abortSignal) {
+    const waiters = (this.summarizeRetryIdleWaiters.get(sessionId) ?? 0) + 1;
+    this.summarizeRetryIdleWaiters.set(sessionId, waiters);
+    this.summarizeRetryTimers.get(sessionId)?.ref?.();
+    try {
+      await abortOnSignal(abortSignal, waiter.promise);
+    } finally {
+      const remaining = (this.summarizeRetryIdleWaiters.get(sessionId) ?? 1) - 1;
+      if (remaining <= 0) {
+        this.summarizeRetryIdleWaiters.delete(sessionId);
+        this.summarizeRetryTimers.get(sessionId)?.unref?.();
+      } else {
+        this.summarizeRetryIdleWaiters.set(sessionId, remaining);
+      }
+    }
   }
   reservePendingObserveInit(sessionId) {
     const count = this.pendingObserveInitCounts.get(sessionId) ?? 0;
@@ -296,8 +444,18 @@ var LcmEngine = class {
       return;
     }
     if (this.pendingObserveInitCounts.size === 0) return;
-    await new Promise((resolve) => {
-      this.pendingObserveInitIdleWaiters.push(resolve);
+    await new Promise((resolve, reject) => {
+      const finish = () => {
+        abortSignal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      const onAbort = () => {
+        const remaining = this.pendingObserveInitIdleWaiters.filter((waiter) => waiter !== finish);
+        this.pendingObserveInitIdleWaiters.splice(0, this.pendingObserveInitIdleWaiters.length, ...remaining);
+        reject(abortSignal?.reason instanceof Error ? abortSignal.reason : new DOMException("Aborted", "AbortError"));
+      };
+      this.pendingObserveInitIdleWaiters.push(finish);
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
     });
   }
   /** Build the compressed history recall section for a session. */
@@ -536,22 +694,24 @@ ${preview}`,
     };
   }
   /** Clear all LCM archive and summary state for one session. */
-  async clearSession(sessionId) {
+  async clearSession(sessionId, abortSignal) {
     if (!this.config.enabled || this.closed) return;
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return;
     await this.ensureInitialized();
     if (this.closed || !this.archive || !this.dag) return;
-    await this.waitForSessionObserveIdle(normalizedSessionId);
+    await this.waitForSessionObserveIdle(normalizedSessionId, abortSignal);
+    abortSignal?.throwIfAborted();
     this.dag.deleteSession(normalizedSessionId);
     this.archive.deleteSession(normalizedSessionId);
   }
   /** Clear all LCM archive and summary state without closing the engine. */
-  async clearAll() {
+  async clearAll(abortSignal) {
     if (!this.config.enabled || this.closed) return;
     await this.ensureInitialized();
     if (this.closed || !this.archive || !this.dag) return;
-    await this.waitForObserveQueueIdle();
+    await this.waitForObserveQueueIdle(abortSignal);
+    abortSignal?.throwIfAborted();
     this.dag.deleteAll();
     this.archive.deleteAll();
   }
@@ -570,6 +730,12 @@ ${preview}`,
   /** Close the database connection. */
   close() {
     this.closed = true;
+    for (const timer of this.summarizeRetryTimers.values()) clearTimeout(timer);
+    this.summarizeRetryTimers.clear();
+    this.summarizeRetryAttempts.clear();
+    for (const retry of this.summarizeRetryWaiters.values()) retry.resolve();
+    this.summarizeRetryWaiters.clear();
+    this.summarizeRetryIdleWaiters.clear();
     if (this.db) {
       this.db.close();
     }
@@ -602,4 +768,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-Y7427SL7.js.map
+//# sourceMappingURL=chunk-ZG4GNPRE.js.map