@martian-engineering/lossless-claw 0.6.1 → 0.6.2

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.
 

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.2",
   "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

@@ -3020,8 +3020,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,

package/src/plugin/index.ts

@@ -1171,6 +1171,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,

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;