@martian-engineering/lossless-claw 0.6.1 → 0.6.3

package/README.md

@@ -115,7 +115,8 @@ Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
           ],
           "summaryModel": "anthropic/claude-haiku-4-5",
           "expansionModel": "anthropic/claude-haiku-4-5",
-          "delegationTimeoutMs": 300000
+          "delegationTimeoutMs": 300000,
+          "summaryTimeoutMs": 60000
         }
       }
     }
@@ -123,7 +124,7 @@ Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
 }
 ```
 
-`leafChunkTokens` controls how many source tokens can accumulate in a leaf compaction chunk before summarization is triggered. The default is `20000`, but quota-limited summary providers may benefit from a larger value to reduce compaction frequency. `summaryModel` and `summaryProvider` let you pin compaction summarization to a cheaper or faster model than your main OpenClaw session model. `expansionModel` does the same for `lcm_expand_query` sub-agent calls (drilling into summaries to recover detail). `delegationTimeoutMs` controls how long `lcm_expand_query` waits for that delegated sub-agent to finish before returning a timeout error; it defaults to `120000` (120s). When unset, the model settings still fall back to OpenClaw's configured default model/provider. See [Expansion model override requirements](#expansion-model-override-requirements) for the required `subagent` trust policy when using `expansionModel`.
+`leafChunkTokens` controls how many source tokens can accumulate in a leaf compaction chunk before summarization is triggered. The default is `20000`, but quota-limited summary providers may benefit from a larger value to reduce compaction frequency. `summaryModel` and `summaryProvider` let you pin compaction summarization to a cheaper or faster model than your main OpenClaw session model. `expansionModel` does the same for `lcm_expand_query` sub-agent calls (drilling into summaries to recover detail). `delegationTimeoutMs` controls how long `lcm_expand_query` waits for that delegated sub-agent to finish before returning a timeout error; it defaults to `120000` (120s). `summaryTimeoutMs` controls the per-call timeout for model-backed LCM summarization; it defaults to `60000` (60s). When unset, the model settings still fall back to OpenClaw's configured default model/provider. See [Expansion model override requirements](#expansion-model-override-requirements) for the required `subagent` trust policy when using `expansionModel`.
 
 ### Environment variables
 
@@ -154,6 +155,7 @@ Add a `lossless-claw` entry under `plugins.entries` in your OpenClaw config:
 | `LCM_EXPANSION_MODEL` | *(from OpenClaw)* | Model override for `lcm_expand_query` sub-agent (e.g. `anthropic/claude-haiku-4-5`) |
 | `LCM_EXPANSION_PROVIDER` | *(from OpenClaw)* | Provider override for `lcm_expand_query` sub-agent |
 | `LCM_DELEGATION_TIMEOUT_MS` | `120000` | Max time to wait for delegated `lcm_expand_query` sub-agent completion |
+| `LCM_SUMMARY_TIMEOUT_MS` | `60000` | Max time to wait for a single model-backed LCM summarizer call |
 | `LCM_PRUNE_HEARTBEAT_OK` | `false` | Retroactively delete `HEARTBEAT_OK` turn cycles from LCM storage |
 
 ### Expansion model override requirements
@@ -198,6 +200,7 @@ Plugin config equivalents:
 - `summaryModel`
 - `summaryProvider`
 - `delegationTimeoutMs`
+- `summaryTimeoutMs`
 
 Environment variables still win over plugin config when both are set.
 
@@ -243,7 +246,7 @@ Lossless-claw distinguishes OpenClaw's two session-reset commands:
 - `2`: keep d2+ summaries; recommended default
 - `3+`: keep only deeper, more abstract summaries
 
-Lossless-claw currently applies these storage semantics through the `before_reset` hook only. User-facing confirmation text after `/new` or `/reset` must be emitted by OpenClaw's command handlers.
+Lossless-claw applies `/new` pruning through `before_reset` and uses `session_end` to catch transcript rollovers such as `/reset`, idle or daily session rotation, compaction session replacement, and deletions. User-facing confirmation text after `/new` or `/reset` must still be emitted by OpenClaw's command handlers.
 
 Use `ignoreSessionPatterns` or `LCM_IGNORE_SESSION_PATTERNS` to keep low-value sessions completely out of LCM. Matching sessions do not create conversations, do not store messages, and do not participate in compaction or delegated expansion grants.
 

package/docs/configuration.md

@@ -159,7 +159,7 @@ Lossless-claw treats the two OpenClaw reset commands differently:
 - `/reset` archives the active conversation row and creates a fresh active row for the same stable `sessionKey`.
 
 This preserves lossless history while still giving users a real clean-slate command.
-OpenClaw's command handlers still own the user-facing post-command disclosure text; lossless-claw applies only the underlying storage transition through `before_reset`.
+Lossless-claw applies `/new` through `before_reset`, then uses `session_end` to catch the broader rollover cases OpenClaw can emit: `/reset`, idle or daily session rotation, compaction-driven session replacement, and deletions. OpenClaw's command handlers still own the user-facing post-command disclosure text.
 
 Use `ignoreSessionPatterns` or `LCM_IGNORE_SESSION_PATTERNS` to keep low-value sessions completely out of LCM. Matching sessions do not create conversations, do not store messages, and do not participate in compaction or delegated expansion grants.
 

package/openclaw.plugin.json

@@ -84,6 +84,10 @@
       "label": "Delegation Timeout (ms)",
       "help": "Maximum time to wait for delegated lcm_expand_query sub-agent completion before timing out"
     },
+    "summaryTimeoutMs": {
+      "label": "Summary Timeout (ms)",
+      "help": "Maximum time to wait for a single model-backed LCM summarizer call before timing out"
+    },
     "maxAssemblyTokenBudget": {
       "label": "Max Assembly Token Budget",
       "help": "Hard ceiling for assembly token budget — caps runtime-provided and fallback budgets. Set for smaller context-window models (e.g., 30000 for 32k models)"
@@ -205,6 +209,10 @@
         "type": "integer",
         "minimum": 1
       },
+      "summaryTimeoutMs": {
+        "type": "integer",
+        "minimum": 1
+      },
       "maxAssemblyTokenBudget": {
         "type": "integer",
         "minimum": 1000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with incremental compaction",
   "type": "module",
   "main": "index.ts",

package/src/compaction.ts

@@ -1379,45 +1379,47 @@ export class CompactionEngine {
     const summaryId = generateSummaryId(summary.content);
     const tokenCount = estimateTokens(summary.content);
 
-    await this.summaryStore.insertSummary({
-      summaryId,
-      conversationId,
-      kind: "leaf",
-      depth: 0,
-      content: summary.content,
-      tokenCount,
-      fileIds,
-      earliestAt:
-        messageContents.length > 0
-          ? new Date(Math.min(...messageContents.map((message) => message.createdAt.getTime())))
-          : undefined,
-      latestAt:
-        messageContents.length > 0
-          ? new Date(Math.max(...messageContents.map((message) => message.createdAt.getTime())))
-          : undefined,
-      descendantCount: 0,
-      descendantTokenCount: 0,
-      sourceMessageTokenCount: messageContents.reduce(
-        (sum, message) => sum + Math.max(0, Math.floor(message.tokenCount)),
-        0,
-      ),
-      model: summaryModel,
-    });
+    await this.summaryStore.withTransaction(async () => {
+      await this.summaryStore.insertSummary({
+        summaryId,
+        conversationId,
+        kind: "leaf",
+        depth: 0,
+        content: summary.content,
+        tokenCount,
+        fileIds,
+        earliestAt:
+          messageContents.length > 0
+            ? new Date(Math.min(...messageContents.map((message) => message.createdAt.getTime())))
+            : undefined,
+        latestAt:
+          messageContents.length > 0
+            ? new Date(Math.max(...messageContents.map((message) => message.createdAt.getTime())))
+            : undefined,
+        descendantCount: 0,
+        descendantTokenCount: 0,
+        sourceMessageTokenCount: messageContents.reduce(
+          (sum, message) => sum + Math.max(0, Math.floor(message.tokenCount)),
+          0,
+        ),
+        model: summaryModel,
+      });
 
-    // Link to source messages
-    const messageIds = messageContents.map((m) => m.messageId);
-    await this.summaryStore.linkSummaryToMessages(summaryId, messageIds);
+      // Link to source messages before the context swap becomes visible.
+      const messageIds = messageContents.map((m) => m.messageId);
+      await this.summaryStore.linkSummaryToMessages(summaryId, messageIds);
 
-    // Replace the message range in context with the new summary
-    const ordinals = messageItems.map((ci) => ci.ordinal);
-    const startOrdinal = Math.min(...ordinals);
-    const endOrdinal = Math.max(...ordinals);
+      // Replace the message range in context with the new summary.
+      const ordinals = messageItems.map((ci) => ci.ordinal);
+      const startOrdinal = Math.min(...ordinals);
+      const endOrdinal = Math.max(...ordinals);
 
-    await this.summaryStore.replaceContextRangeWithSummary({
-      conversationId,
-      startOrdinal,
-      endOrdinal,
-      summaryId,
+      await this.summaryStore.replaceContextRangeWithSummary({
+        conversationId,
+        startOrdinal,
+        endOrdinal,
+        summaryId,
+      });
     });
 
     return { summaryId, level: summary.level, content: summary.content };
@@ -1487,72 +1489,76 @@ export class CompactionEngine {
     const summaryId = generateSummaryId(condensed.content);
     const tokenCount = estimateTokens(condensed.content);
 
-    await this.summaryStore.insertSummary({
-      summaryId,
-      conversationId,
-      kind: "condensed",
-      depth: targetDepth + 1,
-      content: condensed.content,
-      tokenCount,
-      fileIds,
-      earliestAt:
-        summaryRecords.length > 0
-          ? new Date(
-              Math.min(
-                ...summaryRecords.map((summary) =>
-                  (summary.earliestAt ?? summary.createdAt).getTime(),
+    await this.summaryStore.withTransaction(async () => {
+      await this.summaryStore.insertSummary({
+        summaryId,
+        conversationId,
+        kind: "condensed",
+        depth: targetDepth + 1,
+        content: condensed.content,
+        tokenCount,
+        fileIds,
+        earliestAt:
+          summaryRecords.length > 0
+            ? new Date(
+                Math.min(
+                  ...summaryRecords.map((summary) =>
+                    (summary.earliestAt ?? summary.createdAt).getTime(),
+                  ),
                 ),
-              ),
-            )
-          : undefined,
-      latestAt:
-        summaryRecords.length > 0
-          ? new Date(
-              Math.max(
-                ...summaryRecords.map((summary) => (summary.latestAt ?? summary.createdAt).getTime()),
-              ),
-            )
-          : undefined,
-      descendantCount: summaryRecords.reduce((count, summary) => {
-        const childDescendants =
-          typeof summary.descendantCount === "number" && Number.isFinite(summary.descendantCount)
-            ? Math.max(0, Math.floor(summary.descendantCount))
-            : 0;
-        return count + childDescendants + 1;
-      }, 0),
-      descendantTokenCount: summaryRecords.reduce((count, summary) => {
-        const childDescendantTokens =
-          typeof summary.descendantTokenCount === "number" &&
-          Number.isFinite(summary.descendantTokenCount)
-            ? Math.max(0, Math.floor(summary.descendantTokenCount))
-            : 0;
-        return count + Math.max(0, Math.floor(summary.tokenCount)) + childDescendantTokens;
-      }, 0),
-      sourceMessageTokenCount: summaryRecords.reduce((count, summary) => {
-        const sourceTokens =
-          typeof summary.sourceMessageTokenCount === "number" &&
-          Number.isFinite(summary.sourceMessageTokenCount)
-            ? Math.max(0, Math.floor(summary.sourceMessageTokenCount))
-            : 0;
-        return count + sourceTokens;
-      }, 0),
-      model: summaryModel,
-    });
+              )
+            : undefined,
+        latestAt:
+          summaryRecords.length > 0
+            ? new Date(
+                Math.max(
+                  ...summaryRecords.map(
+                    (summary) => (summary.latestAt ?? summary.createdAt).getTime(),
+                  ),
+                ),
+              )
+            : undefined,
+        descendantCount: summaryRecords.reduce((count, summary) => {
+          const childDescendants =
+            typeof summary.descendantCount === "number" && Number.isFinite(summary.descendantCount)
+              ? Math.max(0, Math.floor(summary.descendantCount))
+              : 0;
+          return count + childDescendants + 1;
+        }, 0),
+        descendantTokenCount: summaryRecords.reduce((count, summary) => {
+          const childDescendantTokens =
+            typeof summary.descendantTokenCount === "number" &&
+            Number.isFinite(summary.descendantTokenCount)
+              ? Math.max(0, Math.floor(summary.descendantTokenCount))
+              : 0;
+          return count + Math.max(0, Math.floor(summary.tokenCount)) + childDescendantTokens;
+        }, 0),
+        sourceMessageTokenCount: summaryRecords.reduce((count, summary) => {
+          const sourceTokens =
+            typeof summary.sourceMessageTokenCount === "number" &&
+            Number.isFinite(summary.sourceMessageTokenCount)
+              ? Math.max(0, Math.floor(summary.sourceMessageTokenCount))
+              : 0;
+          return count + sourceTokens;
+        }, 0),
+        model: summaryModel,
+      });
 
-    // Link to parent summaries
-    const parentSummaryIds = summaryRecords.map((s) => s.summaryId);
-    await this.summaryStore.linkSummaryToParents(summaryId, parentSummaryIds);
+      // Link to parent summaries before the context swap becomes visible.
+      const parentSummaryIds = summaryRecords.map((s) => s.summaryId);
+      await this.summaryStore.linkSummaryToParents(summaryId, parentSummaryIds);
 
-    // Replace all summary items in context with the condensed summary
-    const ordinals = summaryItems.map((ci) => ci.ordinal);
-    const startOrdinal = Math.min(...ordinals);
-    const endOrdinal = Math.max(...ordinals);
+      // Replace all summary items in context with the condensed summary.
+      const ordinals = summaryItems.map((ci) => ci.ordinal);
+      const startOrdinal = Math.min(...ordinals);
+      const endOrdinal = Math.max(...ordinals);
 
-    await this.summaryStore.replaceContextRangeWithSummary({
-      conversationId,
-      startOrdinal,
-      endOrdinal,
-      summaryId,
+      await this.summaryStore.replaceContextRangeWithSummary({
+        conversationId,
+        startOrdinal,
+        endOrdinal,
+        summaryId,
+      });
     });
 
     return { summaryId, level: condensed.level };

package/src/db/config.ts

@@ -42,6 +42,8 @@ export type LcmConfig = {
   expansionModel: string;
   /** Max time to wait for delegated lcm_expand_query sub-agent completion. */
   delegationTimeoutMs: number;
+  /** Max time to wait for a single model-backed LCM summarizer call. */
+  summaryTimeoutMs: number;
   /** IANA timezone for timestamps in summaries (from TZ env or system default) */
   timezone: string;
   /** When true, retroactively delete HEARTBEAT_OK turn cycles from LCM storage. */
@@ -219,6 +221,9 @@ export function resolveLcmConfig(
     expansionModel:
       env.LCM_EXPANSION_MODEL?.trim() ?? toStr(pc.expansionModel) ?? "",
     delegationTimeoutMs: envDelegationTimeoutMs ?? toNumber(pc.delegationTimeoutMs) ?? 120000,
+    summaryTimeoutMs:
+      parseFiniteInt(env.LCM_SUMMARY_TIMEOUT_MS)
+        ?? toNumber(pc.summaryTimeoutMs) ?? 60000,
     timezone: env.TZ ?? toStr(pc.timezone) ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
     pruneHeartbeatOk:
       env.LCM_PRUNE_HEARTBEAT_OK !== undefined

package/src/engine.ts

@@ -48,6 +48,7 @@ import { compileSessionPatterns, matchesSessionPattern } from "./session-pattern
 import { logStartupBannerOnce } from "./startup-banner-log.js";
 import {
   ConversationStore,
+  type ConversationRecord,
   type CreateMessagePartInput,
   type MessagePartRecord,
   type MessagePartType,
@@ -1017,7 +1018,7 @@ function readFileSegment(sessionFile: string, offset: number): string | null {
   }
 }
 
-function readLastJsonlEntryBeforeOffset(sessionFile: string, offset: number): string | null {
+function readLastJsonlEntryBeforeOffset(sessionFile: string, offset: number, messageOnly = false): string | null {
   const chunkSize = 16_384;
   let fd: number | null = null;
   try {
@@ -1029,16 +1030,23 @@ function readLastJsonlEntryBeforeOffset(sessionFile: string, offset: number): st
     fd = openSync(sessionFile, "r");
     let cursor = safeOffset;
     let carry = "";
-    while (cursor > 0) {
-      const start = Math.max(0, cursor - chunkSize);
-      const length = cursor - start;
-      const buffer = Buffer.alloc(length);
-      readSync(fd, buffer, 0, length, start);
-      carry = buffer.toString("utf8") + carry;
+    let reachedStart = false;
+    while (cursor > 0 || (reachedStart && carry.length > 0)) {
+      if (!reachedStart) {
+        const start = Math.max(0, cursor - chunkSize);
+        const length = cursor - start;
+        const buffer = Buffer.alloc(length);
+        readSync(fd, buffer, 0, length, start);
+        carry = buffer.toString("utf8") + carry;
+        cursor = start;
+        if (start === 0) {
+          reachedStart = true;
+        }
+      }
 
       const trimmedEnd = carry.replace(/\s+$/u, "");
       if (!trimmedEnd) {
-        cursor = start;
+        if (reachedStart) break;
         carry = "";
         continue;
       }
@@ -1047,17 +1055,36 @@ function readLastJsonlEntryBeforeOffset(sessionFile: string, offset: number): st
       if (newlineIndex >= 0) {
         const candidate = trimmedEnd.slice(newlineIndex + 1).trim();
         if (candidate) {
+          if (messageOnly) {
+            let isMessage = false;
+            try {
+              isMessage = extractBootstrapMessageCandidate(JSON.parse(candidate)) != null;
+            } catch { /* not valid JSON, skip */ }
+            if (!isMessage) {
+              carry = trimmedEnd.slice(0, newlineIndex);
+              continue;
+            }
+          }
           return candidate;
         }
         carry = trimmedEnd.slice(0, newlineIndex);
-        cursor = start;
         continue;
       }
 
-      if (start === 0) {
-        return trimmedEnd.trim() || null;
+      // No newline found — entire trimmedEnd is one line
+      if (reachedStart) {
+        const firstLine = trimmedEnd.trim() || null;
+        if (firstLine && messageOnly) {
+          let isMessage = false;
+          try {
+            isMessage = extractBootstrapMessageCandidate(JSON.parse(firstLine)) != null;
+          } catch { /* not valid JSON */ }
+          if (!isMessage) return null;
+        }
+        return firstLine;
       }
-      cursor = start;
+      // Need more data from earlier in the file
+      continue;
     }
     return null;
   } catch {
@@ -1826,17 +1853,18 @@ export class LcmContextEngine implements ContextEngine {
     conversationId: number;
     historicalMessages: AgentMessage[];
   }): Promise<{
+    blockedByImportCap: boolean;
     importedMessages: number;
     hasOverlap: boolean;
   }> {
     const { sessionId, conversationId, historicalMessages } = params;
     if (historicalMessages.length === 0) {
-      return { importedMessages: 0, hasOverlap: false };
+      return { blockedByImportCap: false, importedMessages: 0, hasOverlap: false };
     }
 
     const latestDbMessage = await this.conversationStore.getLastMessage(conversationId);
     if (!latestDbMessage) {
-      return { importedMessages: 0, hasOverlap: false };
+      return { blockedByImportCap: false, importedMessages: 0, hasOverlap: false };
     }
 
     const storedHistoricalMessages = historicalMessages.map((message) => toStoredMessage(message));
@@ -1857,7 +1885,7 @@ export class LcmContextEngine implements ContextEngine {
         }
       }
       if (dbOccurrences === historicalOccurrences) {
-        return { importedMessages: 0, hasOverlap: true };
+        return { blockedByImportCap: false, importedMessages: 0, hasOverlap: true };
       }
     }
 
@@ -1909,13 +1937,20 @@ export class LcmContextEngine implements ContextEngine {
     }
 
     if (anchorIndex < 0) {
-      return { importedMessages: 0, hasOverlap: false };
+      return { blockedByImportCap: false, importedMessages: 0, hasOverlap: false };
     }
     if (anchorIndex >= historicalMessages.length - 1) {
-      return { importedMessages: 0, hasOverlap: true };
+      return { blockedByImportCap: false, importedMessages: 0, hasOverlap: true };
     }
 
     const missingTail = historicalMessages.slice(anchorIndex + 1);
+
+    const existingDbCount = await this.conversationStore.getMessageCount(conversationId);
+    if (existingDbCount > 0 && missingTail.length > Math.max(existingDbCount * 0.2, 50)) {
+      console.error(`[lcm] reconcileSessionTail: import cap exceeded — would import ${missingTail.length} messages (existing: ${existingDbCount}). Aborting to prevent flood.`);
+      return { blockedByImportCap: true, importedMessages: 0, hasOverlap: true };
+    }
+
     let importedMessages = 0;
     for (const message of missingTail) {
       const result = await this.ingestSingle({ sessionId, sessionKey: params.sessionKey, message });
@@ -1924,7 +1959,7 @@ export class LcmContextEngine implements ContextEngine {
       }
     }
 
-    return { importedMessages, hasOverlap: true };
+    return { blockedByImportCap: false, importedMessages, hasOverlap: true };
   }
 
   async bootstrap(params: {
@@ -2019,6 +2054,7 @@ export class LcmContextEngine implements ContextEngine {
             const tailEntryRaw = readLastJsonlEntryBeforeOffset(
               params.sessionFile,
               bootstrapState.lastProcessedOffset,
+              true,
             );
             const tailEntryMessage = readBootstrapMessageFromJsonLine(tailEntryRaw);
             const tailEntryHash = tailEntryMessage
@@ -2143,6 +2179,14 @@ export class LcmContextEngine implements ContextEngine {
             historicalMessages,
           });
 
+          if (reconcile.blockedByImportCap) {
+            return {
+              bootstrapped: false,
+              importedMessages: 0,
+              reason: "reconcile import capped",
+            };
+          }
+
           if (!conversation.bootstrappedAt) {
             await this.conversationStore.markConversationBootstrapped(conversationId);
           }
@@ -2405,9 +2449,34 @@ export class LcmContextEngine implements ContextEngine {
           };
         }
 
-        return params.runtimeContext.rewriteTranscriptEntries({
+        const result = await params.runtimeContext.rewriteTranscriptEntries({
           replacements,
         });
+
+        if (result.changed) {
+          try {
+            const fileStat = statSync(params.sessionFile);
+            const newSize = fileStat.size;
+            const newMtimeMs = Math.trunc(fileStat.mtimeMs);
+            const lastEntryRaw = readLastJsonlEntryBeforeOffset(params.sessionFile, newSize, true);
+            const lastEntryMsg = readBootstrapMessageFromJsonLine(lastEntryRaw);
+            const lastEntryHash = lastEntryMsg ? createBootstrapEntryHash(toStoredMessage(lastEntryMsg)) : null;
+            if (lastEntryHash) {
+              await this.summaryStore.upsertConversationBootstrapState({
+                conversationId: conversation.conversationId,
+                sessionFilePath: params.sessionFile,
+                lastSeenSize: newSize,
+                lastSeenMtimeMs: newMtimeMs,
+                lastProcessedOffset: newSize,
+                lastProcessedEntryHash: lastEntryHash,
+              });
+            }
+          } catch (e) {
+            console.error("[lcm] Failed to update bootstrap checkpoint after maintain:", e);
+          }
+        }
+
+        return result;
       },
     );
   }
@@ -3020,8 +3089,9 @@ export class LcmContextEngine implements ContextEngine {
           };
         }
 
-        const useSweep =
-          manualCompactionRequested || forceCompaction || params.compactionTarget === "threshold";
+        // Forced budget recovery should use the capped convergence loop so live
+        // overflow counts can drive recovery even when persisted context is already small.
+        const useSweep = manualCompactionRequested || params.compactionTarget === "threshold";
         if (useSweep) {
           const sweepResult = await this.compaction.compactFullSweep({
             conversationId,
@@ -3218,6 +3288,69 @@ export class LcmContextEngine implements ContextEngine {
     // The shared connection is managed for the lifetime of the plugin process.
   }
 
+  /** Detect the empty replacement row created during a prior lifecycle rollover. */
+  private async isFreshLifecycleConversation(conversation: ConversationRecord): Promise<boolean> {
+    const currentMessageCount = await this.conversationStore.getMessageCount(conversation.conversationId);
+    if (currentMessageCount !== 0) {
+      return false;
+    }
+    const currentContextItems = await this.summaryStore.getContextItems(conversation.conversationId);
+    return currentContextItems.length === 0 && !conversation.bootstrappedAt;
+  }
+
+  /**
+   * Archive the current active conversation and optionally create the replacement
+   * row that bootstrap should attach to for the next session transcript.
+   */
+  private async applySessionReplacement(params: {
+    reason: string;
+    sessionId?: string;
+    sessionKey?: string;
+    nextSessionId?: string;
+    nextSessionKey?: string;
+    createReplacement: boolean;
+    createReplacementWhenMissing?: boolean;
+  }): Promise<void> {
+    const current = await this.conversationStore.getConversationForSession({
+      sessionId: params.sessionId,
+      sessionKey: params.sessionKey,
+    });
+    if (!current && !params.createReplacementWhenMissing) {
+      return;
+    }
+
+    if (current?.active) {
+      if (params.createReplacement && await this.isFreshLifecycleConversation(current)) {
+        this.deps.log.info(
+          `[lcm] ${params.reason} lifecycle no-op for already fresh conversation ${current.conversationId}`,
+        );
+        return;
+      }
+      await this.conversationStore.archiveConversation(current.conversationId);
+    }
+
+    if (!params.createReplacement) {
+      this.deps.log.info(
+        `[lcm] ${params.reason} lifecycle archived conversation ${current?.conversationId ?? "(none)"}`,
+      );
+      return;
+    }
+
+    const nextSessionId = params.nextSessionId?.trim() || params.sessionId?.trim() || current?.sessionId;
+    if (!nextSessionId) {
+      this.deps.log.warn(`[lcm] ${params.reason} lifecycle skipped: no session identity available`);
+      return;
+    }
+    const nextSessionKey = params.nextSessionKey?.trim() || params.sessionKey?.trim() || current?.sessionKey;
+    const freshConversation = await this.conversationStore.createConversation({
+      sessionId: nextSessionId,
+      sessionKey: nextSessionKey,
+    });
+    this.deps.log.info(
+      `[lcm] ${params.reason} lifecycle archived prior conversation and created ${freshConversation.conversationId}`,
+    );
+  }
+
   /** Apply LCM lifecycle semantics for OpenClaw's /new and /reset commands. */
   async handleBeforeReset(params: {
     reason?: string;
@@ -3260,44 +3393,50 @@ export class LcmContextEngine implements ContextEngine {
             );
             return;
           }
-
-          const current = await this.conversationStore.getConversationForSession({
+          await this.applySessionReplacement({
+            reason: "/reset",
             sessionId: params.sessionId,
             sessionKey: params.sessionKey,
+            createReplacement: true,
+            createReplacementWhenMissing: true,
           });
-          if (current?.active) {
-            const currentMessageCount = await this.conversationStore.getMessageCount(
-              current.conversationId,
-            );
-            const currentContextItems = await this.summaryStore.getContextItems(
-              current.conversationId,
-            );
-            if (
-              currentMessageCount === 0
-              && currentContextItems.length === 0
-              && !current.bootstrappedAt
-            ) {
-              this.deps.log.info(
-                `[lcm] /reset no-op for already fresh conversation ${current.conversationId}`,
-              );
-              return;
-            }
-            await this.conversationStore.archiveConversation(current.conversationId);
-          }
+        }),
+    );
+  }
 
-          const nextSessionId = params.sessionId?.trim() || current?.sessionId;
-          if (!nextSessionId) {
-            this.deps.log.warn("[lcm] /reset skipped: no session identity available");
-            return;
-          }
+  /** Apply generic lifecycle semantics for session rollover and deletion hooks. */
+  async handleSessionEnd(params: {
+    reason?: string;
+    sessionId?: string;
+    sessionKey?: string;
+    nextSessionId?: string;
+    nextSessionKey?: string;
+  }): Promise<void> {
+    const reason = params.reason?.trim();
+    if (!reason || reason === "new" || reason === "unknown") {
+      return;
+    }
+    if (this.shouldIgnoreSession({ sessionId: params.sessionId, sessionKey: params.sessionKey })) {
+      return;
+    }
+    if (this.isStatelessSession(params.sessionKey ?? params.nextSessionKey)) {
+      return;
+    }
 
-          const freshConversation = await this.conversationStore.createConversation({
-            sessionId: nextSessionId,
-            sessionKey: params.sessionKey?.trim(),
+    const createReplacement = reason !== "deleted";
+    this.ensureMigrated();
+    await this.withSessionQueue(
+      this.resolveSessionQueueKey(params.nextSessionId ?? params.sessionId, params.sessionKey ?? params.nextSessionKey),
+      async () =>
+        this.conversationStore.withTransaction(async () => {
+          await this.applySessionReplacement({
+            reason: `session_end:${reason}`,
+            sessionId: params.sessionId,
+            sessionKey: params.sessionKey ?? params.nextSessionKey,
+            nextSessionId: params.nextSessionId,
+            nextSessionKey: params.nextSessionKey,
+            createReplacement,
           });
-          this.deps.log.info(
-            `[lcm] /reset archived prior conversation and created ${freshConversation.conversationId}`,
-          );
         }),
     );
   }
@@ -3445,3 +3584,6 @@ function createEmergencyFallbackSummarize(): (
     return text.slice(0, maxChars) + "\n[Truncated for context management]";
   };
 }
+
+/** @internal Exposed for unit tests only. */
+export const __testing = { readLastJsonlEntryBeforeOffset };

package/src/plugin/index.ts

@@ -66,6 +66,14 @@ type RuntimeModelAuthResult = {
   apiKey?: string;
 };
 
+type SessionEndLifecycleEvent = {
+  sessionId?: string;
+  sessionKey?: string;
+  reason?: string;
+  nextSessionId?: string;
+  nextSessionKey?: string;
+};
+
 type RuntimeModelAuthModel = {
   id: string;
   provider: string;
@@ -1171,6 +1179,13 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
 
   return {
     config,
+    isRuntimeManagedAuthProvider: (provider: string, providerApi?: string) => {
+      const normalizedProvider = normalizeProviderId(provider);
+      if (normalizedProvider === "openai-codex" || normalizedProvider === "github-copilot") {
+        return true;
+      }
+      return shouldOmitTemperatureForApi(providerApi);
+    },
     complete: async ({
       provider,
       model,
@@ -1522,9 +1537,9 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
     },
     agentLaneSubagent: "subagent",
     log: {
-      info: (msg) => api.logger.info(msg),
-      warn: (msg) => api.logger.warn(msg),
-      error: (msg) => api.logger.error(msg),
+      info: (msg) => console.error(msg),
+      warn: (msg) => console.error(msg),
+      error: (msg) => console.error(msg),
       debug: (msg) => api.logger.debug?.(msg),
     },
   };
@@ -1561,6 +1576,16 @@ const lcmPlugin = {
     api.on("before_prompt_build", () => ({
       prependSystemContext: LOSSLESS_RECALL_POLICY_PROMPT,
     }));
+    api.on("session_end", async (event) => {
+      const lifecycleEvent = event as SessionEndLifecycleEvent;
+      await lcm.handleSessionEnd({
+        reason: lifecycleEvent.reason,
+        sessionId: lifecycleEvent.sessionId,
+        sessionKey: lifecycleEvent.sessionKey,
+        nextSessionId: lifecycleEvent.nextSessionId,
+        nextSessionKey: lifecycleEvent.nextSessionKey,
+      });
+    });
     api.registerContextEngine("lossless-claw", () => lcm);
     api.registerContextEngine("default", () => lcm);
     api.registerTool((ctx) =>
@@ -1602,12 +1627,12 @@ const lcmPlugin = {
 
     logStartupBannerOnce({
       key: "plugin-loaded",
-      log: (message) => api.logger.info(message),
+      log: (message) => console.error(message),
       message: `[lcm] Plugin loaded (enabled=${deps.config.enabled}, db=${deps.config.databasePath}, threshold=${deps.config.contextThreshold})`,
     });
     logStartupBannerOnce({
       key: "compaction-model",
-      log: (message) => api.logger.info(message),
+      log: (message) => console.error(message),
       message: buildCompactionModelLog({
         config: deps.config,
         openClawConfig: api.config,

package/src/plugin/lcm-doctor-apply.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
+import { withDatabaseTransaction } from "../transaction-mutex.js";
 import { formatTimestamp } from "../compaction.js";
 import type { LcmConfig } from "../db/config.js";
 import type { LcmSummarizeFn } from "../summarize.js";
@@ -139,27 +140,22 @@ export async function applyScopedDoctorRepair(params: {
   }
 
   if (repairedSummaryIds.length > 0) {
-    params.db.exec("BEGIN IMMEDIATE");
-    try {
-      for (const summaryId of repairedSummaryIds) {
-        const override = overrides.get(summaryId);
-        if (!override) {
-          continue;
+    await withDatabaseTransaction(params.db, "BEGIN IMMEDIATE", async () => {
+        for (const summaryId of repairedSummaryIds) {
+          const override = overrides.get(summaryId);
+          if (!override) {
+            continue;
+          }
+          params.db
+            .prepare(
+              `UPDATE summaries
+               SET content = ?, token_count = ?
+               WHERE summary_id = ?`,
+            )
+            .run(override.content, override.tokenCount, summaryId);
+          updateSummaryFts(params.db, summaryId, override.content);
         }
-        params.db
-          .prepare(
-            `UPDATE summaries
-             SET content = ?, token_count = ?
-             WHERE summary_id = ?`,
-          )
-          .run(override.content, override.tokenCount, summaryId);
-        updateSummaryFts(params.db, summaryId, override.content);
-      }
-      params.db.exec("COMMIT");
-    } catch (error) {
-      params.db.exec("ROLLBACK");
-      throw error;
-    }
+    });
   }
 
   return {

package/src/store/conversation-store.ts

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
+import { withDatabaseTransaction } from "../transaction-mutex.js";
 import { sanitizeFts5Query } from "./fts5-sanitize.js";
 import { buildLikeSearchPlan, containsCjk, createFallbackSnippet } from "./full-text-fallback.js";
 import { parseUtcTimestamp, parseUtcTimestampOrNull } from "./parse-utc-timestamp.js";
@@ -270,15 +271,7 @@ export class ConversationStore {
   // ── Transaction helpers ──────────────────────────────────────────────────
 
   async withTransaction<T>(operation: () => Promise<T> | T): Promise<T> {
-    this.db.exec("BEGIN IMMEDIATE");
-    try {
-      const result = await operation();
-      this.db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      this.db.exec("ROLLBACK");
-      throw error;
-    }
+    return withDatabaseTransaction(this.db, "BEGIN IMMEDIATE", operation);
   }
 
   // ── Conversation operations ───────────────────────────────────────────────

package/src/store/summary-store.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
+import { withDatabaseTransaction } from "../transaction-mutex.js";
 import { sanitizeFts5Query } from "./fts5-sanitize.js";
 import { buildLikeSearchPlan, containsCjk, createFallbackSnippet } from "./full-text-fallback.js";
 import { parseUtcTimestamp, parseUtcTimestampOrNull } from "./parse-utc-timestamp.js";
@@ -820,6 +821,11 @@ export class SummaryStore {
     return rows.map((row) => row.depth);
   }
 
+  /** Serialize a multi-step summary write sequence on the shared database. */
+  async withTransaction<T>(operation: () => Promise<T> | T): Promise<T> {
+    return withDatabaseTransaction(this.db, "BEGIN", operation);
+  }
+
   async pruneForNewSession(conversationId: number, retainDepth: number): Promise<void> {
     if (Number.isFinite(retainDepth) && retainDepth < 0) {
       return;
@@ -919,56 +925,60 @@ export class SummaryStore {
     endOrdinal: number;
     summaryId: string;
   }): Promise<void> {
+    await this.withTransaction(() => {
+      this.replaceContextRangeWithSummaryInTransaction(input);
+    });
+  }
+
+  // Update the context slice in-place while the caller already owns the txn.
+  private replaceContextRangeWithSummaryInTransaction(input: {
+    conversationId: number;
+    startOrdinal: number;
+    endOrdinal: number;
+    summaryId: string;
+  }): void {
     const { conversationId, startOrdinal, endOrdinal, summaryId } = input;
 
-    this.db.exec("BEGIN");
-    try {
-      // 1. Delete context items in the range [startOrdinal, endOrdinal]
-      this.db
-        .prepare(
-          `DELETE FROM context_items
+    // 1. Delete context items in the range [startOrdinal, endOrdinal]
+    this.db
+      .prepare(
+        `DELETE FROM context_items
          WHERE conversation_id = ?
            AND ordinal >= ?
            AND ordinal <= ?`,
-        )
-        .run(conversationId, startOrdinal, endOrdinal);
+      )
+      .run(conversationId, startOrdinal, endOrdinal);
 
-      // 2. Insert the replacement summary item at startOrdinal
-      this.db
-        .prepare(
-          `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id)
+    // 2. Insert the replacement summary item at startOrdinal
+    this.db
+      .prepare(
+        `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id)
          VALUES (?, ?, 'summary', ?)`,
-        )
-        .run(conversationId, startOrdinal, summaryId);
+      )
+      .run(conversationId, startOrdinal, summaryId);
 
-      // 3. Resequence all ordinals to maintain contiguity (no gaps).
-      //    Fetch current items, then update ordinals in order.
-      const items = this.db
-        .prepare(
-          `SELECT ordinal FROM context_items
+    // 3. Resequence all ordinals to maintain contiguity (no gaps).
+    //    Fetch current items, then update ordinals in order.
+    const items = this.db
+      .prepare(
+        `SELECT ordinal FROM context_items
          WHERE conversation_id = ?
          ORDER BY ordinal`,
-        )
-        .all(conversationId) as unknown as { ordinal: number }[];
-
-      const updateStmt = this.db.prepare(
-        `UPDATE context_items
-         SET ordinal = ?
-         WHERE conversation_id = ? AND ordinal = ?`,
-      );
+      )
+      .all(conversationId) as unknown as { ordinal: number }[];
 
-      // Use negative temp ordinals first to avoid unique constraint conflicts
-      for (let i = 0; i < items.length; i++) {
-        updateStmt.run(-(i + 1), conversationId, items[i].ordinal);
-      }
-      for (let i = 0; i < items.length; i++) {
-        updateStmt.run(i, conversationId, -(i + 1));
-      }
+    const updateStmt = this.db.prepare(
+      `UPDATE context_items
+       SET ordinal = ?
+       WHERE conversation_id = ? AND ordinal = ?`,
+    );
 
-      this.db.exec("COMMIT");
-    } catch (err) {
-      this.db.exec("ROLLBACK");
-      throw err;
+    // Use negative temp ordinals first to avoid unique constraint conflicts.
+    for (let i = 0; i < items.length; i++) {
+      updateStmt.run(-(i + 1), conversationId, items[i].ordinal);
+    }
+    for (let i = 0; i < items.length; i++) {
+      updateStmt.run(i, conversationId, -(i + 1));
     }
   }
 

package/src/summarize.ts

@@ -105,7 +105,7 @@ export class LcmProviderAuthError extends Error {
  * context windows on slower providers, short enough to prevent the gateway
  * event loop from starving when a provider hangs.
  */
-const SUMMARIZER_TIMEOUT_MS = 60_000;
+const DEFAULT_SUMMARIZER_TIMEOUT_MS = 60_000;
 
 /** Error used to distinguish summarizer timeouts from provider failures. */
 class SummarizerTimeoutError extends Error {
@@ -1136,6 +1136,11 @@ export async function createLcmSummarizeFromLegacyParams(params: {
       ? params.deps.config.leafTargetTokens
       : DEFAULT_LEAF_TARGET_TOKENS;
 
+  const summarizerTimeoutMs =
+    Number.isFinite(params.deps.config.summaryTimeoutMs) && params.deps.config.summaryTimeoutMs > 0
+      ? params.deps.config.summaryTimeoutMs
+      : DEFAULT_SUMMARIZER_TIMEOUT_MS;
+
   const fn: LcmSummarizeFn = async (
     text: string,
     aggressive?: boolean,
@@ -1210,13 +1215,17 @@ export async function createLcmSummarizeFromLegacyParams(params: {
           ],
           maxTokens: targetTokens,
           ...(reasoning ? { reasoning } : {}),
-        }), SUMMARIZER_TIMEOUT_MS, label);
+        }), summarizerTimeoutMs, label);
 
       const retryWithoutModelAuth = async (
         failure: ProviderAuthFailure,
         reasoning?: string,
       ): Promise<Awaited<ReturnType<typeof params.deps.complete>>> => {
         const initialAuthError = new LcmProviderAuthError({ provider, model, failure });
+        const runtimeManagedAuth = params.deps.isRuntimeManagedAuthProvider?.(provider, providerApi) === true;
+        if (runtimeManagedAuth) {
+          throw initialAuthError;
+        }
         console.warn(initialAuthError.message);
         console.warn(
           `[lcm] summarizer auth retry: retrying ${provider}/${model} without runtime.modelAuth credentials.`,
@@ -1318,7 +1327,7 @@ export async function createLcmSummarizeFromLegacyParams(params: {
         const errMsg = err instanceof Error ? err.message : String(err);
         const isTimeout = errMsg.includes("summarizer timeout");
         console.warn(
-          `[lcm] summarizer ${isTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${SUMMARIZER_TIMEOUT_MS}ms; error=${errMsg}`,
+          `[lcm] summarizer ${isTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${summarizerTimeoutMs}ms; error=${errMsg}`,
         );
         if (nextCandidate) {
           console.warn(
@@ -1433,12 +1442,12 @@ export async function createLcmSummarizeFromLegacyParams(params: {
           const isRetryTimeout = retryErrMsg.includes("summarizer timeout");
           if (nextCandidate) {
             console.warn(
-              `[lcm] retry ${isRetryTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${SUMMARIZER_TIMEOUT_MS}ms; error=${retryErrMsg}; retrying with ${nextCandidate.provider}/${nextCandidate.model}`,
+              `[lcm] retry ${isRetryTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${summarizerTimeoutMs}ms; error=${retryErrMsg}; retrying with ${nextCandidate.provider}/${nextCandidate.model}`,
             );
             continue;
           }
           console.warn(
-            `[lcm] retry ${isRetryTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${SUMMARIZER_TIMEOUT_MS}ms; error=${retryErrMsg}; falling back to truncation`,
+            `[lcm] retry ${isRetryTimeout ? "timed out" : "failed"}; provider=${provider}; model=${model}; timeout=${summarizerTimeoutMs}ms; error=${retryErrMsg}; falling back to truncation`,
           );
           summary = initialSummary;
         }

package/src/transaction-mutex.ts

@@ -0,0 +1,136 @@
+/**
+ * Per-database async transaction mutex.
+ *
+ * Hotfix for https://github.com/Martian-Engineering/lossless-claw/issues/260
+ *
+ * Problem: Multiple async operations (from different sessions) share one
+ * synchronous DatabaseSync handle. SQLite does not support nested transactions.
+ * When two async code paths both try to BEGIN while an earlier BEGIN is still
+ * in-flight (awaiting async work inside the transaction), the second BEGIN
+ * fails with "cannot start a transaction within a transaction".
+ *
+ * Solution: A per-database async mutex that serializes all explicit transaction
+ * entry points. Uses a WeakMap keyed on the DatabaseSync instance so each
+ * database gets its own queue, and databases are garbage-collected normally.
+ */
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { DatabaseSync } from "node:sqlite";
+
+interface MutexState {
+  /** Tail of the promise chain — each acquirer appends to this. */
+  tail: Promise<void>;
+}
+
+const mutexMap = new WeakMap<DatabaseSync, MutexState>();
+const heldLockContext = new AsyncLocalStorage<Map<DatabaseSync, number>>();
+
+let nextSavepointId = 0;
+
+function getOrCreateMutex(db: DatabaseSync): MutexState {
+  let state = mutexMap.get(db);
+  if (!state) {
+    state = { tail: Promise.resolve() };
+    mutexMap.set(db, state);
+  }
+  return state;
+}
+
+function getHeldLockDepth(db: DatabaseSync): number {
+  return heldLockContext.getStore()?.get(db) ?? 0;
+}
+
+function nextSavepointName(): string {
+  nextSavepointId += 1;
+  return `lcm_txn_savepoint_${nextSavepointId}`;
+}
+
+/**
+ * Acquire exclusive async access to the database for a transaction.
+ *
+ * Direct lock acquisition is intentionally low-level and non-reentrant.
+ * Callers that need nested transaction scopes should use
+ * `withDatabaseTransaction()`, which reuses the held lock and isolates nested
+ * work with SQLite savepoints.
+ *
+ * Usage:
+ *   const release = await acquireTransactionLock(this.db);
+ *   try {
+ *     this.db.exec("BEGIN IMMEDIATE");
+ *     // ... do work ...
+ *     this.db.exec("COMMIT");
+ *   } catch (err) {
+ *     this.db.exec("ROLLBACK");
+ *     throw err;
+ *   } finally {
+ *     release();
+ *   }
+ *
+ * Returns a release function that MUST be called in a finally block.
+ */
+export function acquireTransactionLock(db: DatabaseSync): Promise<() => void> {
+  const mutex = getOrCreateMutex(db);
+
+  let releaseResolve!: () => void;
+  const releasePromise = new Promise<void>((resolve) => {
+    releaseResolve = resolve;
+  });
+
+  // Capture the current tail — we wait on it
+  const waitOn = mutex.tail;
+
+  // Advance the tail — next acquirer will wait on our release
+  mutex.tail = releasePromise;
+
+  // Wait for the previous holder to release, then return our release fn
+  return waitOn.then(() => releaseResolve);
+}
+
+export type BeginTransactionStatement = "BEGIN" | "BEGIN IMMEDIATE";
+
+/**
+ * Run an operation inside a serialized database transaction.
+ *
+ * The first scope on an async path acquires the per-database mutex and opens
+ * the requested transaction mode. Nested scopes on the same database reuse the
+ * held lock and isolate their work with a savepoint instead of hanging.
+ */
+export async function withDatabaseTransaction<T>(
+  db: DatabaseSync,
+  beginStatement: BeginTransactionStatement,
+  operation: () => Promise<T> | T,
+): Promise<T> {
+  if (getHeldLockDepth(db) > 0) {
+    const savepointName = nextSavepointName();
+    db.exec(`SAVEPOINT ${savepointName}`);
+    try {
+      const result = await operation();
+      db.exec(`RELEASE SAVEPOINT ${savepointName}`);
+      return result;
+    } catch (error) {
+      db.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+      db.exec(`RELEASE SAVEPOINT ${savepointName}`);
+      throw error;
+    }
+  }
+
+  const release = await acquireTransactionLock(db);
+  try {
+    const heldLocks = new Map(heldLockContext.getStore() ?? []);
+    heldLocks.set(db, (heldLocks.get(db) ?? 0) + 1);
+
+    return await heldLockContext.run(heldLocks, async () => {
+      db.exec(beginStatement);
+      try {
+        const result = await operation();
+        db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+    });
+  } finally {
+    release();
+  }
+}

package/src/types.ts

@@ -108,6 +108,9 @@ export interface LcmDependencies {
   /** LLM completion function for summarization */
   complete: CompleteFn;
 
+  /** Whether a provider uses runtime-managed OAuth / auth profiles instead of direct API keys. */
+  isRuntimeManagedAuthProvider?: (provider: string, providerApi?: string) => boolean;
+
   /** Gateway RPC call function (for subagent spawning, session ops) */
   callGateway: CallGatewayFn;