@tea-agent/loop-agent 0.44.0-next.5 → 0.44.0-next.7

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.5",
-  "gitSha": "da4e19a774406e1fe79611807fd241e56e6e4c17",
-  "builtAt": "2026-09-16T02:11:12.294Z"
+  "version": "0.44.0-next.7",
+  "gitSha": "561015cd071b2aba74c823716703e756d2236929",
+  "builtAt": "2026-09-16T18:31:45.598Z"
 }

package/dist/executors/pi-sdk-executor.js

@@ -40,21 +40,21 @@ export async function installPiProviderRequestBudget(session, reserve, onFailure
     const agent = session.agent;
     const original = agent?.streamFunction;
     if (!agent || typeof original !== "function")
-        throw Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
+        throw new Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
     const { createAssistantMessageEventStream } = await import("@earendil-works/pi-ai");
     agent.streamFunction = async (...args) => {
         try {
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+                throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
             if (capacity) {
                 const measurement = measureFrontendRequestEnvelope(args[1], args[0], capacity.policy);
                 capacity.observe(measurement);
                 if (measurement.exceedsEstimate)
-                    throw Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
+                    throw new Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
             }
             await reserve();
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+                throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -124,7 +124,7 @@ export function setPiSdkImportOverrideForTests(fn) {
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.84.4 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -140,10 +140,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.84.4 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
+        return { ok: true, detail: "pi SDK 0.84.4 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/infrastructure/console/operation-store.js

@@ -6,6 +6,24 @@ import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finali
 import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
 export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
+/**
+ * Operation states that hold an admission slot. needs-reconcile requires
+ * inspection but does not itself prove a live operation; callers still check
+ * DAG/Worker/chat activity separately. restarting is the terminal receipt of
+ * a successful Console handoff, retained across boots, not a live slot.
+ */
+export const OCCUPIED_OPERATION_STATES = new Set(["queued", "starting", "running"]);
+/** True when the state can still make progress and therefore holds the slot. */
+export function isOperationOccupied(state) {
+    return OCCUPIED_OPERATION_STATES.has(state);
+}
+/**
+ * True when no further state transition will ever occur: a business terminal
+ * (succeeded/failed/timed-out/restarting) or a stranded needs-reconcile.
+ */
+export function isOperationSettled(state) {
+    return TERMINAL_OPERATION_STATES.has(state) || state === "needs-reconcile";
+}
 function operationFile(appData, operationId) {
     return path.join(appData.operations, `${operationId}.json`);
 }
@@ -359,14 +377,11 @@ export class OperationStore {
         for (const op of await this.list()) {
             if (TERMINAL_OPERATION_STATES.has(op.state))
                 continue;
-            // A consoleUpdateAndInit whose record already proves a requested
-            // handoff died before writing its terminal state: the update and
-            // restart themselves succeeded — the booting process IS the
-            // handoff target. Mark it succeeded instead of surfacing the
-            // generic needs-reconcile failure copy to the operator.
+            // A consoleUpdateAndInit that proved its handoff before the process
+            // died must not be reported as a stranded failure: the booting
+            // process IS the handoff target, so the update actually succeeded.
             if (op.action === "consoleUpdateAndInit" &&
-                op.state === "needs-reconcile" &&
-                isProvenConsoleUpdateHandoff(op.result)) {
+                isProvenConsoleUpdateHandoff(op)) {
                 changed.push(await this.update(op.operationId, {
                     state: "succeeded",
                     errorCode: undefined,
@@ -398,17 +413,34 @@ export function isTerminalOperationState(state) {
     return TERMINAL_OPERATION_STATES.has(state);
 }
 /**
- * True when a consoleUpdateAndInit result proves the handoff was requested
- * (install verified + init clean + new Console spawned). Used by boot
- * reconcile to close the record as succeeded even though the old process
- * died before writing its terminal state.
+ * True when a consoleUpdateAndInit record proves the handoff actually
+ * succeeded (install verified + new Console spawned), so boot reconcile can
+ * close it as succeeded even though the dying process never wrote its
+ * terminal state.
+ *
+ * The proof reads the maintenance projection rather than only `result.state`.
+ * The old check required `result.state === "restarting"`, but the executor
+ * writes `state` and `maintenance` together (`console-update-and-init.ts`),
+ * so any path that recorded the handoff proof together with a non-restarting
+ * `state` — most importantly the `needs-reconcile` record that
+ * `acceptConsoleUpdateAndInit` writes when the executor throws *after* a
+ * successful handoff — could never satisfy it. Such records were stranded
+ * forever: boot reconcile skipped them and they blocked later updates.
+ *
+ * `handoff.status === "requested"` is only ever set on the success path, and
+ * `package.status === "failed"` explicitly disqualifies a record, so this
+ * stays fail-closed for genuine failures.
  */
-function isProvenConsoleUpdateHandoff(result) {
+export function isProvenConsoleUpdateHandoff(operation) {
+    if (!operation || operation.action !== "consoleUpdateAndInit")
+        return false;
+    const result = operation.result;
     if (!result || typeof result !== "object")
         return false;
     const shape = result;
-    return (shape.state === "restarting" &&
-        shape.maintenance?.handoff?.status === "requested");
+    if (shape.maintenance?.handoff?.status !== "requested")
+        return false;
+    return shape.maintenance?.package?.status !== "failed";
 }
 export function clipPreview(text, max = 4096) {
     if (text.length <= max)

package/dist/shared/git-workspace-status.js

@@ -133,6 +133,8 @@ export function unquoteGitPath(value) {
  * shell-quoting hazards). Returns [] when the file is absent or empty.
  */
 export async function readSubmoduleRegistrations(rootCwd, dependencies = DEFAULT_WORKSPACE_STATUS_DEPENDENCIES) {
+    if (!(await hasGitmodulesFile(rootCwd)))
+        return [];
     const result = await dependencies.runGit(rootCwd, [
         "config",
         "-f",

package/dist/shared/wizard-local-telemetry.js

@@ -12,7 +12,8 @@ function deleteHeaderCaseInsensitive(headers, name) {
 }
 function configuredHeader(headers, name) {
     const key = Object.keys(headers ?? {}).find((entry) => entry.toLowerCase() === name.toLowerCase());
-    return key ? headers?.[key] : undefined;
+    const value = key ? headers?.[key] : undefined;
+    return typeof value === "string" ? value : undefined;
 }
 function setStaticHeader(headers, configured, name, defaultValue) {
     deleteHeaderCaseInsensitive(headers, name);

package/dist/worker/console/chat/assistant-content.js

@@ -102,43 +102,14 @@ export function splitFinalAssistantBlocks(blocks, options = {}) {
     // after text that is already visible. Keep the whole live message in the
     // chronological process subtree so that update appends the tool in place
     // instead of reparenting the earlier text from answer -> process.
-    if (options.isStreaming) {
-        return { answerBlocks: [], processBlocks: displayable };
-    }
-    let lastProcessIndex = -1;
-    for (let i = displayable.length - 1; i >= 0; i--) {
-        if (!isFinalAnswerBlock(displayable[i])) {
-            lastProcessIndex = i;
-            break;
-        }
-    }
-    if (lastProcessIndex === -1) {
-        return { answerBlocks: displayable, processBlocks: [] };
-    }
-    const trailing = displayable.slice(lastProcessIndex + 1);
-    if (trailing.length > 0) {
-        return {
-            answerBlocks: trailing,
-            processBlocks: displayable.slice(0, lastProcessIndex + 1),
-        };
-    }
-    // The stage ends on a non-text block (a tool call after the prose, or a final
-    // thinking block). Returning an empty answer here hid the whole reply inside
-    // the collapsed process subtree; keep the last prose block as the visible
-    // answer instead (2026-09-08).
-    let lastTextIndex = -1;
-    for (let i = displayable.length - 1; i >= 0; i--) {
-        if (isFinalAnswerBlock(displayable[i])) {
-            lastTextIndex = i;
-            break;
-        }
-    }
-    if (lastTextIndex === -1) {
+    if (options.isStreaming ||
+        displayable.some((block) => block.type === "toolCall")) {
         return { answerBlocks: [], processBlocks: displayable };
     }
+    const answerBlocks = displayable.filter((block) => isFinalAnswerBlock(block) && block.text.trim() !== "");
     return {
-        answerBlocks: [displayable[lastTextIndex]],
-        processBlocks: displayable.filter((_block, index) => index !== lastTextIndex),
+        answerBlocks,
+        processBlocks: displayable.filter((block) => !isFinalAnswerBlock(block)),
     };
 }
 export function joinAssistantText(blocks) {

package/dist/worker/console/chat/chat-event-store.js

@@ -334,6 +334,18 @@ export function projectChatToolEventPayload(input) {
         };
     }
     const { preview, previewHash } = projectToolResultPreview(input.value);
+    if (input.kind === "tool_update") {
+        return {
+            toolCallId: input.toolCallId,
+            toolName: input.toolName,
+            resultPreview: preview,
+            previewHash,
+            ...(input.step === undefined ? {} : { step: input.step }),
+            ...(input.parentToolCallId
+                ? { parentToolCallId: input.parentToolCallId }
+                : {}),
+        };
+    }
     return {
         toolCallId: input.toolCallId,
         toolName: input.toolName,
@@ -438,22 +450,27 @@ function dropOneByPriority(ring) {
     return events.shift();
 }
 /**
- * D2 coalescing decision: merge an incoming `message_update` into the ring tail
- * only when the tail is also a same-turn `message_update` and the update landed
- * inside the coalescing window. Structural events close the window implicitly
- * (their presence makes the tail check fail), so an
- * update → tool_call → update sequence never merges across the tool boundary.
+ * D2 coalescing decision: merge high-frequency cumulative text/tool updates
+ * into a matching ring tail inside the coalescing window. Structural events
+ * close the window implicitly (their presence makes the tail check fail).
  * `partial.at` (when present) drives the clock so tests can inject window
  * boundaries deterministically without fake timers.
  */
 function shouldCoalesce(ring, turnId, partial) {
-    if (partial.kind !== "message_update")
-        return false;
     const tail = ring.events.at(-1);
-    if (!tail || tail.kind !== "message_update")
+    if (!tail || tail.kind !== partial.kind)
         return false;
     if (tail.turnId !== turnId)
         return false;
+    if (partial.kind === "tool_update") {
+        const currentId = partial.data.toolCallId;
+        const tailId = tail.data.toolCallId;
+        if (!currentId || currentId !== tailId)
+            return false;
+    }
+    else if (partial.kind !== "message_update") {
+        return false;
+    }
     const nowMs = partial.at ? Date.parse(partial.at) : Date.now();
     if (Number.isNaN(nowMs))
         return false;
@@ -1048,12 +1065,12 @@ export function createChatEventStore(options) {
                 ring.approxBytes += byteHint(live);
             }
             enforceBounds(sessionId, ring);
-            // B5-1: only high-frequency `message_update` appends defer the persist;
+            // B5-1: high-frequency cumulative updates defer the persist;
             // every other kind (message_end / tool_call / error / turn signals …)
             // still persists synchronously. Because persistNow writes the FULL
             // in-memory ring, one flush also lands any earlier pending updates in
             // order — no two-phase flush is needed.
-            if (partial.kind === "message_update") {
+            if (partial.kind === "message_update" || partial.kind === "tool_update") {
                 const atMs = partial.at ? Date.parse(partial.at) : Date.now();
                 if (!Number.isNaN(atMs)) {
                     persistDebounced(sessionId, ring, atMs);

package/dist/worker/console/chat/db-connections.js

@@ -525,7 +525,6 @@ export class DbConnectionRegistry {
     async listTables(name, selectedDatabase) {
         const config = this.getConfig(name);
         const effectiveDatabase = selectedDatabase?.trim() || config.database;
-        const handle = await this.connect(name, effectiveDatabase);
         const sql = config.engine === "sqlite"
             ? "SELECT name, type FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' ORDER BY name"
             : config.engine === "postgres"
@@ -533,7 +532,7 @@ export class DbConnectionRegistry {
                 : effectiveDatabase
                     ? "SELECT table_name AS name, CASE WHEN table_type = 'VIEW' THEN 'view' ELSE 'table' END AS type, table_schema AS schemaName FROM information_schema.tables WHERE table_schema = DATABASE() ORDER BY table_name"
                     : "SELECT table_name AS name, CASE WHEN table_type = 'VIEW' THEN 'view' ELSE 'table' END AS type, table_schema AS schemaName FROM information_schema.tables WHERE table_schema NOT IN ('information_schema','mysql','performance_schema','sys') ORDER BY table_schema, table_name";
-        const rows = await handle.query(sql);
+        const rows = await this.queryWithReconnect(name, (handle) => handle.query(sql), effectiveDatabase);
         return rows.map((row) => ({
             name: String(row.name ?? ""),
             type: String(row.type).toLowerCase() === "view" ? "view" : "table",
@@ -556,8 +555,7 @@ export class DbConnectionRegistry {
             ? `\`${table.schema.replaceAll("\`", "\`\`")}\`.${escapedName}`
             : escapedName;
         const columns = await this.describeTable(config, table.name, identifier, table.schema, selectedDatabase);
-        const handle = await this.connect(name, selectedDatabase);
-        const rows = await handle.query(`SELECT * FROM ${identifier} LIMIT ${safePageSize + 1} OFFSET ${offset}`);
+        const rows = await this.queryWithReconnect(name, (handle) => handle.query(`SELECT * FROM ${identifier} LIMIT ${safePageSize + 1} OFFSET ${offset}`), selectedDatabase);
         return {
             connection: name,
             table: requestedTable,
@@ -576,19 +574,18 @@ export class DbConnectionRegistry {
         return config;
     }
     async describeTable(config, table, identifier, schema, selectedDatabase) {
-        const handle = await this.connect(config.name, selectedDatabase);
         if (config.engine === "sqlite") {
-            const rows = await handle.query(`PRAGMA table_info(${identifier})`);
+            const rows = await this.queryWithReconnect(config.name, (h) => h.query(`PRAGMA table_info(${identifier})`), selectedDatabase);
             return rows.map((row) => ({ name: String(row.name), type: String(row.type ?? ""), nullable: Number(row.notnull ?? 0) !== 1, primaryKey: Number(row.pk ?? 0) > 0 }));
         }
         if (config.engine === "postgres") {
             const literal = table.replaceAll("'", "''");
-            const rows = await handle.query(`SELECT column_name AS name, data_type AS type, is_nullable AS nullable FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = '${literal}' ORDER BY ordinal_position`);
+            const rows = await this.queryWithReconnect(config.name, (h) => h.query(`SELECT column_name AS name, data_type AS type, is_nullable AS nullable FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = '${literal}' ORDER BY ordinal_position`), selectedDatabase);
             return rows.map((row) => ({ name: String(row.name), type: String(row.type ?? ""), nullable: String(row.nullable).toUpperCase() === "YES", primaryKey: false }));
         }
         const literal = table.replaceAll("'", "''");
         const schemaFilter = schema ? `'${schema.replaceAll("'", "''")}'` : "DATABASE()";
-        const rows = await handle.query(`SELECT column_name AS name, column_type AS type, is_nullable AS nullable, column_key AS columnKey FROM information_schema.columns WHERE table_schema = ${schemaFilter} AND table_name = '${literal}' ORDER BY ordinal_position`);
+        const rows = await this.queryWithReconnect(config.name, (h) => h.query(`SELECT column_name AS name, column_type AS type, is_nullable AS nullable, column_key AS columnKey FROM information_schema.columns WHERE table_schema = ${schemaFilter} AND table_name = '${literal}' ORDER BY ordinal_position`), selectedDatabase);
         return rows.map((row) => ({ name: String(row.name), type: String(row.type ?? ""), nullable: String(row.nullable).toUpperCase() === "YES", primaryKey: String(row.columnKey).toUpperCase() === "PRI" }));
     }
     async connect(name, databaseOverride) {
@@ -605,6 +602,42 @@ export class DbConnectionRegistry {
             this.handles.set(name, handle);
         return handle;
     }
+    /**
+     * Public read-only query entry point with transparent one-shot reconnect.
+     * Tools should prefer this over raw connect()+query so idle-killed
+     * sessions heal without operator intervention.
+     */
+    async query(name, sql) {
+        return this.queryWithReconnect(name, (handle) => handle.query(sql));
+    }
+    /**
+     * Drop the cached connection for `name` (if any) so the next connect()
+     * reopens it. Callers that hold a raw handle across queries can use this
+     * after a connection-level failure to force a fresh session.
+     */
+    evict(name) {
+        this.closeHandle(name);
+    }
+    /**
+     * Query through the cached connection for `name`, transparently reopening it
+     * once when the server has dropped the idle session (MySQL wait_timeout,
+     * TCP reset, pool death). Reopen uses the exact same config, so credential
+     * rules are unchanged; only connection-level failures trigger the retry.
+     */
+    async queryWithReconnect(name, run, databaseOverride) {
+        const handle = await this.connect(name, databaseOverride);
+        try {
+            return await run(handle);
+        }
+        catch (error) {
+            if (!isConnectionLossError(error))
+                throw error;
+            // Evict the dead cached handle and reopen once with the same config.
+            this.closeHandle(name);
+            const reopened = await this.connect(name, databaseOverride);
+            return run(reopened);
+        }
+    }
     async openHandle(config, databaseOverride) {
         if (config.engine === "sqlite") {
             const { DatabaseSync } = await import("node:sqlite");
@@ -727,6 +760,28 @@ function decryptCredentialDocument(serialized, key) {
         throw new Error("invalid encrypted credential entries");
     return document;
 }
+/** Errors that mean the underlying server session is gone and a reopen may heal it. */
+function isConnectionLossError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const code = typeof err.code === "string" ? err.code.toUpperCase() : "";
+    const message = typeof err.message === "string" ? err.message : "";
+    if (code === "ECONNRESET" ||
+        code === "EPIPE" ||
+        code === "ETIMEDOUT" ||
+        code === "ECONNREFUSED" ||
+        code === "PROTOCOL_CONNECTION_LOST" ||
+        code === "CONNECTION_LOST" ||
+        code === "57P01" || // postgres: admin_shutdown
+        code === "57P03" || // postgres: cannot_connect_now
+        code === "08003" || // SQLSTATE connection_does_not_exist
+        code === "08006" // SQLSTATE connection_failure
+    ) {
+        return true;
+    }
+    return /connection lost|connection closed|connection ended|connection terminated|server closed the connection unexpectedly/i.test(message);
+}
 /** PostgreSQL driver adapter (`pg`). */
 async function connectPostgres(driver, options) {
     const mod = driver;
@@ -770,6 +825,15 @@ async function connectMysql(driver, options) {
         password: options.password,
         ...(options.ssl ? { ssl: {} } : {}),
     });
+    // mysql2 emits 'error' asynchronously when the server kills an idle
+    // session; without a listener that becomes an unhandled 'error' event
+    // that can take the whole Console process down.
+    if (typeof conn.on === "function") {
+        conn.on("error", () => {
+            // Swallow: the query wrapper surfaces real failures and the
+            // registry reconnect logic reopens the connection on demand.
+        });
+    }
     return {
         async query(sql) {
             assertDatabaseReadOnlySql(sql);

package/dist/worker/console/chat/pi-runtime/custom-tools/sql-tools.js

@@ -309,6 +309,28 @@ export async function buildSqlTools(options) {
             throw new SqlToolError("DB_CONFIRMATION_REQUIRED", `the user rejected the confirmation for "${id}"`);
         }
     }
+    /** Run a registry operation, retrying exactly once when the underlying DB session died. */
+    async function withDbReconnect(registry, connection, op) {
+        try {
+            return await op();
+        }
+        catch (error) {
+            if (!isDbConnectionLoss(error))
+                throw error;
+            registry.evict(connection);
+            return op();
+        }
+    }
+    function isDbConnectionLoss(error) {
+        if (!error || typeof error !== "object")
+            return false;
+        const err = error;
+        const code = typeof err.code === "string" ? err.code.toUpperCase() : "";
+        const message = typeof err.message === "string" ? err.message : "";
+        if (["ECONNRESET", "EPIPE", "ETIMEDOUT", "PROTOCOL_CONNECTION_LOST", "CONNECTION_LOST", "57P01", "57P03", "08003", "08006"].includes(code))
+            return true;
+        return /connection lost|connection closed|connection ended|connection terminated|server closed the connection unexpectedly/i.test(message);
+    }
     async function envelope(operation, timeoutMs) {
         let result;
         try {
@@ -378,21 +400,25 @@ export async function buildSqlTools(options) {
                     }
                     assertSingleStatement(statements);
                     assertReadOnlyStatement(statements[0]);
-                    const handle = await registry.connect(params.connection);
                     const limit = Math.min(Math.max(params.maxRows ?? SQL_MAX_ROWS_DEFAULT, 1), SQL_MAX_ROWS_LIMIT);
                     // sqlite exposes column metadata via prepare(); pg/mysql derive it
-                    // from the first result row.
-                    let columns;
-                    let all;
-                    if (isSqliteHandle(handle)) {
-                        const stmt = handle.prepare(params.sql.trim());
-                        columns = stmt.columns().map((c) => c.name);
-                        all = stmt.all();
-                    }
-                    else {
-                        all = await handle.query(params.sql.trim());
-                        columns = all.length > 0 ? Object.keys(all[0]) : [];
-                    }
+                    // from the first result row. The whole fetch retries once on a
+                    // dead session (idle timeout) via withDbReconnect.
+                    const { columns, all } = await withDbReconnect(registry, params.connection, async () => {
+                        const handle = await registry.connect(params.connection);
+                        if (isSqliteHandle(handle)) {
+                            const stmt = handle.prepare(params.sql.trim());
+                            return {
+                                columns: stmt.columns().map((c) => c.name),
+                                all: stmt.all(),
+                            };
+                        }
+                        const rows = await handle.query(params.sql.trim());
+                        return {
+                            columns: rows.length > 0 ? Object.keys(rows[0]) : [],
+                            all: rows,
+                        };
+                    });
                     const truncated = all.length > limit;
                     const rows = truncated ? all.slice(0, limit) : all;
                     const format = params.format ?? "json";
@@ -445,13 +471,12 @@ export async function buildSqlTools(options) {
             }, { additionalProperties: false }),
             async execute(_toolCallId, params) {
                 return envelope(async () => {
-                    const handle = await registry.connect(params.connection);
                     if (params.table === undefined || params.table.trim() === "") {
-                        const rows = (await handle.query("SELECT name, type FROM sqlite_master WHERE type IN ('table','view') ORDER BY name"));
+                        const rows = await withDbReconnect(registry, params.connection, async () => (await registry.connect(params.connection)).query("SELECT name, type FROM sqlite_master WHERE type IN ('table','view') ORDER BY name"));
                         return { ok: true, connection: params.connection, tables: rows };
                     }
                     const table = assertSafeIdentifier(params.table);
-                    const rows = await handle.query(`PRAGMA table_info(${table})`);
+                    const rows = await withDbReconnect(registry, params.connection, async () => (await registry.connect(params.connection)).query(`PRAGMA table_info(${table})`));
                     return {
                         ok: true,
                         connection: params.connection,
@@ -474,14 +499,17 @@ export async function buildSqlTools(options) {
             parameters: Type.Object({ connection: connectionParameter }, { additionalProperties: false }),
             async execute(_toolCallId, params) {
                 return envelope(async () => {
-                    const handle = await registry.connect(params.connection);
-                    const tables = (await handle.query("SELECT name FROM sqlite_master WHERE type IN ('table','view') ORDER BY name"));
-                    const rowsByTable = {};
-                    for (const t of tables) {
-                        const name = assertSafeIdentifier(t.name);
-                        const countRows = await handle.query(`SELECT COUNT(*) AS n FROM ${name}`);
-                        rowsByTable[name] = Number(countRows[0]?.n ?? 0);
-                    }
+                    const { tables, rowsByTable } = await withDbReconnect(registry, params.connection, async () => {
+                        const handle = await registry.connect(params.connection);
+                        const tables = (await handle.query("SELECT name FROM sqlite_master WHERE type IN ('table','view') ORDER BY name"));
+                        const rowsByTable = {};
+                        for (const t of tables) {
+                            const name = assertSafeIdentifier(t.name);
+                            const countRows = await handle.query(`SELECT COUNT(*) AS n FROM ${name}`);
+                            rowsByTable[name] = Number(countRows[0]?.n ?? 0);
+                        }
+                        return { tables, rowsByTable };
+                    });
                     const config = registry.get(params.connection);
                     let sizeBytes;
                     if (config?.path) {