pi-ui-extend 0.1.28 → 0.1.31

package/dist/app/session/tabs-controller.js

@@ -12,6 +12,7 @@ const BACKGROUND_PREWARM_TAB_LIMIT = 2;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
 const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
 const DEFAULT_SESSION_TITLE_PATTERN = /^session [0-9a-f]{8}$/iu;
+const SESSION_TITLE_HEAD_SCAN_MAX_BYTES = 256 * 1024;
 const SESSION_TITLE_SCAN_MAX_BYTES = 2 * 1024 * 1024;
 export class AppTabsController {
     host;
@@ -23,6 +24,7 @@ export class AppTabsController {
     historyReloadTimersByTabId = new Map();
     inputStatesByTabId = new Map();
     deferredUserMessagesByTabId = new Map();
+    sessionViewsByTabId = new Map();
     tabIdsNeedingHistoryReload = new Set();
     activeTabId;
     pendingActiveTabId;
@@ -576,6 +578,7 @@ export class AppTabsController {
         const previousRuntime = runtime;
         const previousTargetActivity = target.activity;
         this.storeActiveRuntime(runtime);
+        this.storeActiveSessionView();
         this.storeActiveInputState();
         this.storeActiveDeferredUserMessages();
         this.activeTabId = target.id;
@@ -584,8 +587,6 @@ export class AppTabsController {
         this.clearTabAttention(target);
         this.restoreInputState(target.id);
         this.host.closeMenusForTabSwitch?.();
-        this.host.resetSessionView();
-        this.restoreDeferredUserMessages(target.id);
         this.host.setStatus("switching tab");
         this.host.setSessionActivity("thinking");
         this.host.render();
@@ -633,7 +634,18 @@ export class AppTabsController {
         this.restoreInputState(target.id);
         void this.saveTabs();
         this.scheduleTabPrewarm();
-        await this.loadActiveSessionHistory(targetRuntime);
+        const cachedView = this.sessionViewsByTabId.get(target.id);
+        if (cachedView && this.host.restoreSessionView) {
+            this.host.restoreSessionView(cachedView);
+            this.restoreDeferredUserMessages(target.id);
+            this.host.setSessionStatus(targetRuntime.session);
+            this.host.setSessionActivity(this.sessionActivity(targetRuntime.session));
+            this.host.render();
+        }
+        else {
+            await this.loadActiveSessionHistory(targetRuntime);
+            this.tabIdsNeedingHistoryReload.delete(target.id);
+        }
         this.scheduleDelayedHistoryReload(target.id, targetRuntime);
     }
     async closeTab(tabId) {
@@ -809,6 +821,11 @@ export class AppTabsController {
             return;
         this.setRuntimeForTab(this.activeTabId, runtime);
     }
+    storeActiveSessionView() {
+        if (!this.activeTabId || !this.host.captureSessionView)
+            return;
+        this.sessionViewsByTabId.set(this.activeTabId, this.host.captureSessionView());
+    }
     setRuntimeForTab(tabId, runtime) {
         this.runtimesByTabId.set(tabId, runtime);
         this.observeRuntimeForTab(tabId, runtime);
@@ -816,6 +833,7 @@ export class AppTabsController {
     deleteRuntimeForTab(tabId) {
         this.runtimesByTabId.delete(tabId);
         this.runtimeLoadsByTabId.delete(tabId);
+        this.sessionViewsByTabId.delete(tabId);
         this.clearRuntimeRefreshTimers(tabId);
         this.clearHistoryReloadTimers(tabId);
         this.tabIdsNeedingHistoryReload.delete(tabId);
@@ -900,11 +918,15 @@ export class AppTabsController {
             return;
         if (tabId !== this.activeTabId || this.pendingActiveTabId !== undefined)
             return;
+        if (this.sessionActivity(runtime.session) === "running") {
+            this.clearHistoryReloadTimers(tabId);
+            return;
+        }
         this.clearHistoryReloadTimers(tabId);
         for (const delayMs of [150, 1000, 3000]) {
             const timer = setTimeout(() => {
                 this.historyReloadTimersByTabId.get(tabId)?.delete(timer);
-                void this.reloadActiveTabHistoryIfNeeded(tabId, runtime, delayMs === 3000);
+                void this.reloadActiveTabHistoryIfNeeded(tabId, runtime);
             }, delayMs);
             timer.unref?.();
             let timers = this.historyReloadTimersByTabId.get(tabId);
@@ -915,13 +937,15 @@ export class AppTabsController {
             timers.add(timer);
         }
     }
-    async reloadActiveTabHistoryIfNeeded(tabId, runtime, finalAttempt) {
+    async reloadActiveTabHistoryIfNeeded(tabId, runtime) {
         if (tabId !== this.activeTabId || this.pendingActiveTabId !== undefined || this.host.runtime() !== runtime)
             return;
         if (!this.tabIdsNeedingHistoryReload.has(tabId))
             return;
+        if (this.sessionActivity(runtime.session) === "running")
+            return;
         await this.loadActiveSessionHistory(runtime);
-        if (finalAttempt && tabId === this.activeTabId && this.host.runtime() === runtime) {
+        if (tabId === this.activeTabId && this.host.runtime() === runtime) {
             this.tabIdsNeedingHistoryReload.delete(tabId);
         }
     }
@@ -1027,6 +1051,7 @@ export class AppTabsController {
         this.clearRuntimeSubscriptions();
         this.inputStatesByTabId.clear();
         this.deferredUserMessagesByTabId.clear();
+        this.sessionViewsByTabId.clear();
         const seen = new Set();
         for (const tab of tabs) {
             const sessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
@@ -1505,28 +1530,14 @@ async function readLatestSessionTitle(sessionPath) {
         const { size } = await file.stat();
         if (size <= 0)
             return undefined;
-        const byteCount = Math.min(size, SESSION_TITLE_SCAN_MAX_BYTES);
-        const buffer = Buffer.alloc(byteCount);
-        await file.read(buffer, 0, byteCount, size - byteCount);
-        const text = buffer.toString("utf8");
-        const lines = text.split("\n");
-        if (size > byteCount)
-            lines.shift();
-        for (let index = lines.length - 1; index >= 0; index -= 1) {
-            const line = lines[index]?.trim();
-            if (!line)
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (!isRecord(parsed) || parsed.type !== "session_info" || typeof parsed.name !== "string")
-                continue;
-            return validSessionTitle(parsed.name);
-        }
+        const tailByteCount = Math.min(size, SESSION_TITLE_SCAN_MAX_BYTES);
+        const tailTitle = await readSessionTitleChunk(file, size - tailByteCount, tailByteCount, { dropFirstLine: size > tailByteCount });
+        if (tailTitle)
+            return tailTitle;
+        if (size <= tailByteCount)
+            return undefined;
+        const headByteCount = Math.min(size - tailByteCount, SESSION_TITLE_HEAD_SCAN_MAX_BYTES);
+        return await readSessionTitleChunk(file, 0, headByteCount, { dropLastLine: headByteCount < size });
     }
     catch {
         return undefined;
@@ -1534,6 +1545,32 @@ async function readLatestSessionTitle(sessionPath) {
     finally {
         await file?.close();
     }
+}
+async function readSessionTitleChunk(file, position, byteCount, options = {}) {
+    if (byteCount <= 0)
+        return undefined;
+    const buffer = Buffer.alloc(byteCount);
+    await file.read(buffer, 0, byteCount, position);
+    const lines = buffer.toString("utf8").split("\n");
+    if (options.dropFirstLine)
+        lines.shift();
+    if (options.dropLastLine)
+        lines.pop();
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index]?.trim();
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(parsed) || parsed.type !== "session_info" || typeof parsed.name !== "string")
+            continue;
+        return validSessionTitle(parsed.name);
+    }
     return undefined;
 }
 function validSessionTitle(value) {

package/external/pi-tools-suite/package.json

@@ -41,9 +41,6 @@
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
     "typebox": "*"
   },
   "devDependencies": {

package/external/pi-tools-suite/src/async-subagents/commands.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {

package/external/pi-tools-suite/src/async-subagents/core/tool-guard.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const SUBAGENT_DENIED_TOOLS = new Set([
 	"question",

package/external/pi-tools-suite/src/async-subagents/index.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {

package/external/pi-tools-suite/src/async-subagents/render.ts

@@ -1,4 +1,4 @@
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentState } from "./lib.js";
 import { modelName, plural, statusGlyph, statusLabel } from "./format.js";
 import type { AgentTaskPreview, SubagentRunRenderDetails } from "./types.js";

package/external/pi-tools-suite/src/async-subagents/tools/cleanup.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";

package/external/pi-tools-suite/src/async-subagents/tools/result.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
 import * as path from "node:path";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import { readResult, resolveSubagentAgentRunDir, validateBasename } from "../lib.js";

package/external/pi-tools-suite/src/async-subagents/tools/spawn.ts

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
-import { Text } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import type { AgentCompletionHandler, AgentTask, ResolvedAgentTaskConfig, Semaphore, SpawnedAgent } from "../lib.js";
 import {

package/external/pi-tools-suite/src/async-subagents/tools/status.ts

@@ -1,6 +1,6 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
-import { Text } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import { getRunState, resolveSubagentRunDir, validateBasename } from "../lib.js";
 import { INLINE_RENDERING } from "../constants.js";

package/external/pi-tools-suite/src/async-subagents/tools/stop.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import { getRunState, resolveSubagentRunDir, stopAgents, validateBasename, validateStopSignal } from "../lib.js";
 import { INLINE_RENDERING } from "../constants.js";

package/external/pi-tools-suite/src/async-subagents/tools/subagents.ts

@@ -1,6 +1,6 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
-import { Text } from "@mariozechner/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
 import { asyncSubagentToolDescriptions } from "../../tool-descriptions.js";
 import { hasIndexedProjectRoot } from "../../lib/project.js";
 import type { AgentCompletionHandler } from "../lib.js";

package/external/pi-tools-suite/src/async-subagents/tools/wait.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
 import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import { resolveSubagentRunDir, validateBasename } from "../lib.js";
 import { INLINE_RENDERING } from "../constants.js";

package/external/pi-tools-suite/src/async-subagents/ui.ts

@@ -1,4 +1,4 @@
-import { Container } from "@mariozechner/pi-tui";
+import { Container } from "@earendil-works/pi-tui";
 
 export function emptyToolSlot(): Container {
 	return new Container();

package/external/pi-tools-suite/src/dcp/commands.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent"
-import type { AutocompleteItem } from "@mariozechner/pi-tui"
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent"
+import type { AutocompleteItem } from "@earendil-works/pi-tui"
 import type { DcpState } from "./state.js"
 import type { DcpConfig } from "./config.js"
 import type { DcpNudgeType } from "./pruner-types.js"

package/external/pi-tools-suite/src/dcp/compress-tool.ts

@@ -3,7 +3,7 @@
 // ---------------------------------------------------------------------------
 
 import { Type } from "typebox"
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import type { DcpState } from "./state.js"
 import type { DcpConfig } from "./config.js"
 import { clearDcpNudgeAnchors } from "./pruner.js"

package/external/pi-tools-suite/src/dcp/index.ts

@@ -2,7 +2,7 @@
 // Dynamic Context Pruning (DCP) — module entry point for pi-tools-suite
 // ---------------------------------------------------------------------------
 
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
 import { loadConfig } from "./config.js"
 import {
 	createState,

package/external/pi-tools-suite/src/lsp/constants.ts

@@ -1,6 +1,7 @@
 export const DEFAULT_STARTUP_TIMEOUT_MS = 45_000;
 export const DEFAULT_DIAGNOSTICS_WAIT_MS = 10_000;
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+export const DEFAULT_IDLE_SHUTDOWN_MS = 30_000;
 export const REQUEST_TIMEOUT_MS = 30_000;
 export const SHUTDOWN_WRITE_TIMEOUT_MS = 100;
 export const SHUTDOWN_TERM_TIMEOUT_MS = 2_000;

package/external/pi-tools-suite/src/lsp/manager.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_DIAGNOSTICS_WAIT_MS, DEFAULT_MAX_FILE_SIZE_BYTES, LSP_MANAGER_GLOBAL_KEY } from "./constants";
+import { DEFAULT_DIAGNOSTICS_WAIT_MS, DEFAULT_IDLE_SHUTDOWN_MS, DEFAULT_MAX_FILE_SIZE_BYTES, LSP_MANAGER_GLOBAL_KEY } from "./constants";
 import { DiagnosticsStore } from "./diagnostics-store";
 import { LspClient } from "./client";
 import { loadLspConfig } from "./_shared/config";
@@ -43,12 +43,51 @@ export class LspManager {
   private readonly diagnostics = new DiagnosticsStore();
   private readonly clients = new Map<string, LspClient>();
   private readonly backoff = new Map<string, { retryAt: number; attempts: number; reason: string }>();
+  private idleShutdownTimer: ReturnType<typeof setTimeout> | undefined;
+  private activeOperations = 0;
+  private handlingSignal = false;
   private readonly handleProcessExit = () => {
     this.shutdownAllSync();
   };
+  private readonly handleProcessSignal = (signal: NodeJS.Signals) => {
+    this.shutdownAllSync();
+
+    // Restore the platform default for the terminating signal. LSP servers are
+    // spawned detached so they can otherwise outlive Pi when the process is
+    // killed by a terminal/editor without a session_shutdown event.
+    if (this.handlingSignal) return;
+    this.handlingSignal = true;
+    process.kill(process.pid, signal);
+  };
 
   constructor() {
     process.once("exit", this.handleProcessExit);
+    process.once("SIGINT", this.handleProcessSignal);
+    process.once("SIGTERM", this.handleProcessSignal);
+    process.once("SIGHUP", this.handleProcessSignal);
+  }
+
+  private clearIdleShutdownTimer(): void {
+    if (!this.idleShutdownTimer) return;
+    clearTimeout(this.idleShutdownTimer);
+    this.idleShutdownTimer = undefined;
+  }
+
+  private beginOperation(): void {
+    this.activeOperations += 1;
+    this.clearIdleShutdownTimer();
+  }
+
+  private endOperation(): void {
+    this.activeOperations = Math.max(0, this.activeOperations - 1);
+    if (this.activeOperations > 0 || this.clients.size === 0) return;
+
+    this.clearIdleShutdownTimer();
+    this.idleShutdownTimer = setTimeout(() => {
+      if (this.activeOperations > 0 || this.clients.size === 0) return;
+      void this.shutdownAll();
+    }, DEFAULT_IDLE_SHUTDOWN_MS);
+    this.idleShutdownTimer.unref?.();
   }
 
   async matchingServers(ctx: ExtensionContext, file: string): Promise<{ matches: MatchedServer[]; warnings: string[]; workspace: string }> {
@@ -104,93 +143,98 @@ export class LspManager {
   }
 
   async updateDiagnosticsForFile(ctx: ExtensionContext, file: string): Promise<string> {
-    const { matches, warnings, workspace } = await this.matchingServers(ctx, file);
-    if (matches.length === 0) return formatWarnings("LSP diagnostics", warnings);
-
-    const lines: string[] = [];
-    for (const match of matches) {
-      try {
-        const maxFileSizeBytes = match.server.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
-        if (!(await fileSizeAllowed(file, maxFileSizeBytes))) {
-          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: skipped ${match.relFile}; file exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
-          continue;
-        }
+    this.beginOperation();
+    try {
+      const { matches, warnings, workspace } = await this.matchingServers(ctx, file);
+      if (matches.length === 0) return formatWarnings("LSP diagnostics", warnings);
 
-        // Clear stale diagnostics before refreshing this file. The synchronous
-        // wait below must observe a fresh publishDiagnostics notification, not an
-        // old error from a previous document version. Empty diagnostics published
-        // by the server are stored, but this local clear is not.
-        this.diagnostics.clear(match.server.id, match.root, filePathToUri(file));
-
-        const text = await readTextFile(file);
-        const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
-        const languageId = languageIdForFile(match.server, file);
-        const startedAt = Date.now();
-        const doc = await client.openOrChange(file, languageId, text, ctx.signal);
-        await client.didSave(file);
-        const diagnosticsWaitMs = match.server.diagnosticsWaitMs ?? DEFAULT_DIAGNOSTICS_WAIT_MS;
-
-        // typescript-language-server sometimes does not emit a fresh
-        // textDocument/publishDiagnostics notification after didChange/didSave,
-        // even though tsserver can answer diagnostics synchronously. Prefer the
-        // explicit tsserver request when the server exposes it, so post-edit
-        // diagnostics don't degrade into a misleading publishDiagnostics timeout.
-        let tsserverFallbackError: string | undefined;
+      const lines: string[] = [];
+      for (const match of matches) {
         try {
-          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
-          if (tsserverDiagnostics !== undefined) {
-            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+          const maxFileSizeBytes = match.server.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+          if (!(await fileSizeAllowed(file, maxFileSizeBytes))) {
+            lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: skipped ${match.relFile}; file exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
             continue;
           }
-        } catch (error) {
-          tsserverFallbackError = (error as Error).message;
-        }
 
-        let pullDiagnosticsError: string | undefined;
-        if (match.server.pullDiagnostics !== false) {
+          // Clear stale diagnostics before refreshing this file. The synchronous
+          // wait below must observe a fresh publishDiagnostics notification, not an
+          // old error from a previous document version. Empty diagnostics published
+          // by the server are stored, but this local clear is not.
+          this.diagnostics.clear(match.server.id, match.root, filePathToUri(file));
+
+          const text = await readTextFile(file);
+          const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
+          const languageId = languageIdForFile(match.server, file);
+          const startedAt = Date.now();
+          const doc = await client.openOrChange(file, languageId, text, ctx.signal);
+          await client.didSave(file);
+          const diagnosticsWaitMs = match.server.diagnosticsWaitMs ?? DEFAULT_DIAGNOSTICS_WAIT_MS;
+
+          // typescript-language-server sometimes does not emit a fresh
+          // textDocument/publishDiagnostics notification after didChange/didSave,
+          // even though tsserver can answer diagnostics synchronously. Prefer the
+          // explicit tsserver request when the server exposes it, so post-edit
+          // diagnostics don't degrade into a misleading publishDiagnostics timeout.
+          let tsserverFallbackError: string | undefined;
           try {
-            const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
-            if (pulledDiagnostics !== undefined) {
-              const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+            const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
+            if (tsserverDiagnostics !== undefined) {
+              const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
               this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
               lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
               continue;
             }
           } catch (error) {
-            pullDiagnosticsError = (error as Error).message;
+            tsserverFallbackError = (error as Error).message;
           }
-        }
 
-        if (match.server.waitForPublishDiagnostics === false || diagnosticsWaitMs <= 0) {
-          continue;
-        }
+          let pullDiagnosticsError: string | undefined;
+          if (match.server.pullDiagnostics !== false) {
+            try {
+              const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
+              if (pulledDiagnostics !== undefined) {
+                const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+                this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+                lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+                continue;
+              }
+            } catch (error) {
+              pullDiagnosticsError = (error as Error).message;
+            }
+          }
+
+          if (match.server.waitForPublishDiagnostics === false || diagnosticsWaitMs <= 0) {
+            continue;
+          }
 
-        const entry = await this.diagnostics.waitForFile(
-          match.server.id,
-          match.root,
-          file,
-          startedAt,
-          doc.version,
-          diagnosticsWaitMs,
-          ctx.signal,
-        );
-        if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
-          const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
-          const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
-          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
-          continue;
+          const entry = await this.diagnostics.waitForFile(
+            match.server.id,
+            match.root,
+            file,
+            startedAt,
+            doc.version,
+            diagnosticsWaitMs,
+            ctx.signal,
+          );
+          if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
+            const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
+            const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
+            lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
+            continue;
+          }
+          const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
+          if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+          lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+        } catch (error) {
+          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: ${(error as Error).message}`);
         }
-        const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
-        if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
-        lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
-      } catch (error) {
-        lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: ${(error as Error).message}`);
       }
-    }
 
-    return [formatWarnings("LSP diagnostics", warnings), joinSections("LSP diagnostics", lines)].filter(Boolean).join("\n\n");
+      return [formatWarnings("LSP diagnostics", warnings), joinSections("LSP diagnostics", lines)].filter(Boolean).join("\n\n");
+    } finally {
+      this.endOperation();
+    }
   }
 
   async ensureDocumentForTool(ctx: ExtensionContext, inputPath: string): Promise<{ file: string; match: MatchedServer; client: LspClient; workspace: string } | undefined> {
@@ -215,15 +259,20 @@ export class LspManager {
   }
 
   async shutdownAll(): Promise<void> {
+    this.clearIdleShutdownTimer();
     const clients = [...this.clients.values()];
     this.clients.clear();
     await Promise.allSettled(clients.map((client) => client.shutdown()));
   }
 
   shutdownAllSync(): void {
+    this.clearIdleShutdownTimer();
     const clients = [...this.clients.values()];
     this.clients.clear();
     process.off("exit", this.handleProcessExit);
+    process.off("SIGINT", this.handleProcessSignal);
+    process.off("SIGTERM", this.handleProcessSignal);
+    process.off("SIGHUP", this.handleProcessSignal);
     for (const client of clients) client.shutdownSync();
   }
 }

package/external/pi-tools-suite/src/model-tools/apply-patch.ts

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { mkdir, mkdtemp, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { isPathInside } from "./path-utils";
 
 export interface ApplyPatchResult {

package/external/pi-tools-suite/src/model-tools/index.ts

@@ -11,7 +11,7 @@ import {
   type ExtensionContext,
   type ToolDefinition,
   type ToolRenderResultOptions,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { Type, type TSchema } from "typebox";

package/external/pi-tools-suite/src/todo/tool/response-envelope.ts

@@ -145,7 +145,7 @@ function appendWorkflowReminder(text: string, op: Op, state: TaskState): string
 	const lines = [text];
 	if (op.kind === "create" || op.kind === "batch_create") {
 		lines.push(
-			"Reminder: if this is a multi-step task, include a final todo item for the user-facing final report before completion. Give that final-report todo an explicit description/acceptance criteria: summarize changed files and behavior, list verification commands/results, mention any remaining manual action, and never replace the user-facing report with a compression/housekeeping note.",
+			"Reminder: if this is a multi-step task, include a final todo item for the user-facing final report before completion. Give that final-report todo an explicit description/acceptance criteria: summarize changed files and behavior, list verification commands/results, mention any remaining manual action, and never replace the user-facing report with a compression/housekeeping note. Close that report todo immediately before sending the report.",
 		);
 		const createdIds = new Set(op.kind === "create" ? [op.taskId] : op.ids);
 		const hasOlderUnfinished = !op.replacedCount && state.tasks.some((task) => {
@@ -167,7 +167,7 @@ function appendWorkflowReminder(text: string, op: Op, state: TaskState): string
 	}
 	if (hasInProgress) {
 		lines.push(
-			"Reminder: before your final response, update any finished todo items to completed. Treat the final user-facing report step like any other todo: mark it completed immediately before sending the report.",
+			"Reminder: before your final response, update any finished todo items to completed. If one todo is the final user-facing report step, mark it completed immediately before sending the report.",
 		);
 	}
 	return lines.join("\n\n");