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

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.6",
-  "gitSha": "11c9ac87f792e61b1bc31b1ef2aeacb48a6334d4",
-  "builtAt": "2026-09-16T11:49:07.558Z"
+  "version": "0.44.0-next.7",
+  "gitSha": "561015cd071b2aba74c823716703e756d2236929",
+  "builtAt": "2026-09-16T18:31:45.598Z"
 }

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/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) {

package/dist/worker/console/chat/pi-runtime.js

@@ -191,6 +191,25 @@ async function bindSessionExtensions(session) {
         return;
     await session.bindExtensions(createConsoleExtensionBindings());
 }
+export function branchForkedSessionManager(sessionManager, throughUserMessageIndex) {
+    const userEntries = (sessionManager.getBranch?.() ?? []).filter((entry) => {
+        if (!entry || typeof entry !== "object")
+            return false;
+        const candidate = entry;
+        return candidate.type === "message" && candidate.message?.role === "user";
+    });
+    const target = userEntries[throughUserMessageIndex];
+    if (!target || typeof target.id !== "string") {
+        throw new Error("FORK_MESSAGE_ENTRY_NOT_FOUND");
+    }
+    sessionManager.branch(target.id);
+    if (typeof sessionManager.appendCustomEntry !== "function") {
+        throw new Error("FORK_MESSAGE_ENTRY_PERSIST_UNSUPPORTED");
+    }
+    sessionManager.appendCustomEntry("loop-agent-fork-point", {
+        throughUserMessageIndex,
+    });
+}
 function pinOperatorChatTools(session, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
     session.setActiveToolsByName(computeChatActiveToolNames(session, sessionMode));
 }
@@ -1198,6 +1217,9 @@ export class ConsolePiRuntime {
             targetSessionDir: this.options.sessionDir,
             targetSessionId: sessionId,
         });
+        if (init.throughUserMessageIndex !== undefined) {
+            branchForkedSessionManager(sessionManager, init.throughUserMessageIndex);
+        }
         const built = await this.buildSessionWithServices({
             sessionId,
             sessionManager,
@@ -2692,6 +2714,18 @@ export function mapSdkEvent(sessionId, event, compactionId, step = 1) {
                     ? { parentToolCallId: event.parentToolCallId }
                     : {}),
             };
+        case "tool_execution_update":
+            return {
+                type: "tool_update",
+                sessionId,
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                partialResult: event.partialResult,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
+            };
         case "tool_execution_end":
             return {
                 type: "tool_result",