pi-ui-extend 0.1.6 → 0.1.8

package/dist/app/extension-ui-controller.js

@@ -207,6 +207,7 @@ export class ExtensionUiController {
             setHeader: () => undefined,
             setTitle: (title) => {
                 process.title = title;
+                renderIfRunning();
             },
             custom: (async (factory) => await this.showCustomUi(factory)),
             pasteToEditor: (text) => {

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

@@ -67,6 +67,9 @@ export class AppSessionLifecycleController {
     async bindCurrentSession() {
         const runtime = this.requireRuntime();
         this.unsubscribe?.();
+        this.unsubscribe = runtime.session.subscribe((event) => {
+            this.host.handleSessionEvent(event);
+        });
         this.host.closeSdkMenuForBind();
         this.host.clearExtensionWidgets();
         await runtime.session.bindExtensions({
@@ -75,9 +78,6 @@ export class AppSessionLifecycleController {
             shutdownHandler: this.host.extensionShutdownHandler(),
             onError: (error) => this.host.handleExtensionError(error),
         });
-        this.unsubscribe = runtime.session.subscribe((event) => {
-            this.host.handleSessionEvent(event);
-        });
     }
     unsubscribeSession() {
         this.unsubscribe?.();

package/external/pi-tools-suite/README.md

@@ -2,11 +2,10 @@
 
 Local all-in-one Pi extension package.
 
-This package keeps the former standalone extensions as ordinary source folders under `src/` and registers them through one entrypoint.
+This package keeps shared Pi tools as ordinary source folders under `src/` and registers them through one entrypoint.
 
 - `src/ast-grep` — `ast_grep` / `ast_apply`
 - `src/async-subagents` — `subagents` tool and sub-agent slash commands, including oh-my-openagent-style `/ultrawork` (`/ulw`) and `/hyperplan` orchestration prompts, plus config-defined sub-agent model/thinking/args presets selected via `/subagent-preset` from `asyncSubagents` in `~/.config/pi/pi-tools-suite.jsonc`; includes the `frontend` profile for Gemini-friendly UI/UX and visual frontend work plus the `vision` profile for screenshot/image description via `openai-codex/gpt-5.4-mini`; enforces a 30-minute per-agent execution timeout, project-wide `maxConcurrent` queueing, optional retry/backoff, and `result.json` structured metadata/chaining fields next to raw `result.md`; stores project-local run files and a registry under `.pi/subagents/` so result/status collection can recover after compaction or reload while the main session remains alive
-- `src/terminal-bell` — terminal bell, macOS attention sound, and best-effort OS notification when the main agent session returns to idle; defers the alert while sub-agents are still running or the main agent is waiting for sub-agent results
 - `src/lsp` — shared LSP diagnostics hook/library that enriches mutating tool results with diagnostics and shuts down language servers on session shutdown
 - `src/repo-discovery` — `/idx-init`, `/idx-update`, and indexed-only `repo_architecture` / `repo_structure` / `repo_ast` / `repo_search` / `repo_explain` / `repo_deps`; tools register only when the launch project has `.indexer-cli`
 - `src/antigravity-auth` — `antigravity` custom provider with Google Antigravity OAuth login, startup account list, `/antigravity-import` credential migration from opencode, `/antigravity-add-account` OAuth append into rotation, `/antigravity-account` status display, account rotation/failover, Antigravity plus Gemini CLI model registration, and streaming through the Cloud Code Assist unified gateway
@@ -19,7 +18,7 @@ This package keeps the former standalone extensions as ordinary source folders u
 
 `index.ts` is intentionally only a thin auto-discovery shim that re-exports `src/index.ts`. There is no `pi.extensions` manifest here, so local Pi auto-discovery loads the suite once via `~/.pi/agent/extensions/pi-tools-suite/index.ts` and does not double-register tools.
 
-Registration order is preserved in `src/index.ts`: ast-grep, async-subagents, terminal-bell, lsp, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
+Registration order is preserved in `src/index.ts`: ast-grep, async-subagents, lsp, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
 
 ## Disabling modules
 
@@ -27,14 +26,14 @@ Disable suite modules without editing `src/index.ts` via config or environment v
 
 ```jsonc
 {
-  "disabledModules": ["terminal-bell", "web-search"]
+  "disabledModules": ["web-search"]
 }
 ```
 
 Environment overrides are applied last:
 
 ```bash
-PI_TOOLS_SUITE_DISABLED_MODULES=terminal-bell,web-search pi ...
+PI_TOOLS_SUITE_DISABLED_MODULES=web-search pi ...
 PI_TOOLS_SUITE_DISABLED=1 pi ...   # disables all pi-tools-suite modules
 ```
 
@@ -152,50 +151,6 @@ Troubleshooting:
 
 Do not send secrets, tokens, private repository text, or credential-bearing URLs through these tools; Ollama may query external web services to satisfy the request.
 
-## Terminal bell / idle alert
-
-`src/terminal-bell` alerts the user when the main Pi agent returns to idle. It does not alert while sub-agents are still running or while the main agent is waiting for sub-agent results.
-
-Disable it entirely for headless runs:
-
-```bash
-HEADLESS=1 pi ...
-# or
-PI_TERMINAL_BELL_DISABLED=1 pi ...
-```
-
-Common environment options:
-
-| Variable | Effect |
-| --- | --- |
-| `PI_TERMINAL_BELL=0` | Disable terminal `\x07` bell only |
-| `PI_TERMINAL_BELL_FORCE=1` | Emit terminal bell even without TTY |
-| `PI_TERMINAL_BELL_DELAY_MS=250` | Delay before alerting after idle |
-| `PI_TERMINAL_BELL_SOUND=0` | Disable macOS `afplay` attention sound |
-| `PI_TERMINAL_BELL_SOUND=Glass` | macOS sound name or absolute `.aiff` path |
-| `PI_TERMINAL_BELL_NOTIFY=0` | Disable OS notification only |
-| `PI_TERMINAL_BELL_NOTIFY=1` | Force OS notification even outside UI mode |
-| `PI_TERMINAL_BELL_NOTIFY_TITLE=Pi` | Notification title |
-| `PI_TERMINAL_BELL_NOTIFY_MESSAGE="Session stopped"` | Notification body |
-
-macOS clickable notifications require `terminal-notifier`:
-
-```bash
-brew install terminal-notifier
-```
-
-At extension startup, the module resolves the app to activate on click from `PI_TERMINAL_BELL_NOTIFY_ACTIVATE`, `__CFBundleIdentifier`, or `TERM_PROGRAM` (Zed, iTerm2, Terminal, WezTerm, Warp, Ghostty, Kitty, Alacritty, VS Code). The resolved bundle id is passed to `terminal-notifier -activate` and to an explicit `open -b <bundleId>` click action.
-
-macOS-specific notification options:
-
-| Variable | Effect |
-| --- | --- |
-| `PI_TERMINAL_BELL_NOTIFY_ACTIVATE=dev.zed.Zed` | Override click activation bundle id |
-| `PI_TERMINAL_BELL_NOTIFY_ACTIVATE=0` | Disable click activation |
-| `PI_TERMINAL_BELL_NOTIFIER=/path/to/terminal-notifier` | Use a custom notifier binary |
-| `PI_TERMINAL_BELL_NOTIFY_SENDER=1` | Also pass `-sender <bundleId>` (can break click handling on some macOS versions) |
-| `PI_TERMINAL_BELL_NOTIFY_OSASCRIPT=1` | Use the `osascript` fallback when `terminal-notifier` is missing; clicking these notifications can open Script Editor |
-
 ## Layout
 
 ```text
@@ -206,7 +161,6 @@ pi-tools-suite/
     index.ts
     ast-grep/
     async-subagents/
-    terminal-bell/
     lsp/
     repo-discovery/
     antigravity-auth/

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

@@ -673,7 +673,6 @@ function subagentEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
 		PI_TOOLS_SUITE_DISABLED_MODULES: appendEnvList(env.PI_TOOLS_SUITE_DISABLED_MODULES, [
 			"async-subagents",
 			"question",
-			"terminal-bell",
 		]),
 	};
 }

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -5,7 +5,6 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
   "disabledModules": [
     // "ast-grep",
     // "async-subagents",
-    // "terminal-bell",
     // "lsp",
     // "repo-discovery",
     // "antigravity-auth",
@@ -16,7 +15,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
     // "dcp"
   ],
 
-  // Terminal bell notification settings.
+  // Renderer bundled terminal-bell notification settings.
   "terminalBell": {
     // Toggle terminal-bell attention signals across supported OSes:
     // terminal BEL, macOS notification sound, and system notifications

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

@@ -12,7 +12,6 @@ type ExtensionModule = {
 const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },
-	{ name: "terminal-bell", load: () => import("./terminal-bell/index") },
 	{ name: "lsp", load: () => import("./lsp/index") },
 	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
 	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },

package/external/pi-tools-suite/src/lsp/_shared/config.ts

@@ -1,12 +1,19 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parse as parseJsonc } from "jsonc-parser";
+import { getPiToolsSuiteUserConfigPath } from "../../config";
 import { findUp } from "./paths";
 import { askProjectConfigTrust, sha256 } from "./trust";
 import type { ConfigLayer, LoadedConfig, LspConfigFile, LspServerConfig, MatchableConfig } from "./types";
 
-function defaultAgentDir(): string {
-  return process.env.PI_AGENT_DIR ?? path.join(process.env.HOME ?? "", ".pi", "agent");
+function getPiConfigDir(): string | undefined {
+  const configured = process.env.PI_CONFIG_DIR;
+  return configured && configured.trim() !== "" ? configured : undefined;
+}
+
+function findProjectSuiteConfig(startDir: string): string | undefined {
+  return findUp(startDir, path.join(".pi", "pi-tools-suite.jsonc"));
 }
 
 function asObject(value: unknown): Record<string, unknown> | undefined {
@@ -78,9 +85,16 @@ function parseLspItems(parsed: unknown): LspServerConfig[] {
   return out;
 }
 
-async function readJsonLayer<TItem extends MatchableConfig>(options: {
+function extractLspConfig(parsed: unknown): unknown {
+  const root = asObject(parsed);
+  if (!root) return undefined;
+  return root.lsp;
+}
+
+async function readJsoncLayer<TItem extends MatchableConfig>(options: {
   scope: "global" | "project";
   filePath: string;
+  selectConfig?: (parsed: unknown) => unknown;
   parseItems: (parsed: unknown) => TItem[];
 }): Promise<ConfigLayer<TItem> | undefined> {
   let raw: string;
@@ -91,14 +105,19 @@ async function readJsonLayer<TItem extends MatchableConfig>(options: {
     throw error;
   }
 
-  const parsed = JSON.parse(raw) as unknown;
+  const parsed = parseJsonc(raw) as unknown;
+  const selected = options.selectConfig ? options.selectConfig(parsed) : parsed;
+  if (selected === undefined) return undefined;
+  const items = options.parseItems(selected);
+  if (items.length === 0) return undefined;
+
   return {
     scope: options.scope,
     path: options.filePath,
     dir: path.dirname(options.filePath),
     raw,
     hash: sha256(raw),
-    items: options.parseItems(parsed),
+    items,
   };
 }
 
@@ -123,19 +142,25 @@ function binariesForLsp(items: LspServerConfig[]): string[] {
 export async function loadLspConfig(ctx: ExtensionContext): Promise<LoadedConfig<LspServerConfig>> {
   const warnings: string[] = [];
   const layers: ConfigLayer<LspServerConfig>[] = [];
-  const globalPath = path.join(defaultAgentDir(), "lsp.json");
+  const piConfigDir = getPiConfigDir();
+  const globalPaths = [
+    getPiToolsSuiteUserConfigPath(process.env.HOME),
+    piConfigDir ? path.join(piConfigDir, "pi-tools-suite.jsonc") : undefined,
+  ].filter((item): item is string => typeof item === "string");
 
-  try {
-    const globalLayer = await readJsonLayer({ scope: "global", filePath: globalPath, parseItems: parseLspItems });
-    if (globalLayer) layers.push(globalLayer);
-  } catch (error) {
-    warnings.push(`Failed to load global lsp config: ${(error as Error).message}`);
+  for (const globalPath of globalPaths) {
+    try {
+      const globalLayer = await readJsoncLayer({ scope: "global", filePath: globalPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
+      if (globalLayer) layers.push(globalLayer);
+    } catch (error) {
+      warnings.push(`Failed to load global lsp config ${globalPath}: ${(error as Error).message}`);
+    }
   }
 
-  const projectPath = findUp(ctx.cwd, path.join(".pi", "lsp.json"));
+  const projectPath = findProjectSuiteConfig(ctx.cwd);
   if (projectPath) {
     try {
-      const projectLayer = await readJsonLayer({ scope: "project", filePath: projectPath, parseItems: parseLspItems });
+      const projectLayer = await readJsoncLayer({ scope: "project", filePath: projectPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
       if (projectLayer) {
         const decision = await askProjectConfigTrust({
           ctx,

package/external/pi-tools-suite/src/lsp/_shared/paths.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import type { CommandConfig, PathPlaceholders, ResolvedCommand } from "./types";
 import { applyTemplate, applyTemplateArray, applyTemplateRecord } from "./template";
+import { matchesGlob } from "./glob";
 
 export function expandHome(input: string): string {
   if (input === "~") return process.env.HOME ?? input;
@@ -26,7 +27,16 @@ export function isSubPathOrSame(parent: string, child: string): boolean {
 }
 
 export function markerExists(candidateDir: string, marker: string): boolean {
-  return fs.existsSync(path.resolve(candidateDir, marker));
+  if (!/[?*[]/.test(marker)) return fs.existsSync(path.resolve(candidateDir, marker));
+
+  const markerDir = path.dirname(marker);
+  const markerPattern = path.basename(marker);
+  const absoluteMarkerDir = path.resolve(candidateDir, markerDir === "." ? "" : markerDir);
+  try {
+    return fs.readdirSync(absoluteMarkerDir).some((entry) => matchesGlob(markerPattern, entry));
+  } catch {
+    return false;
+  }
 }
 
 export function findProjectRoot(filePath: string, rootMarkers: string[] | undefined, fallbackRoot: string): string | undefined {

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

@@ -18,12 +18,17 @@ export function delay(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
-export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string, signal?: AbortSignal): Promise<T> {
+  if (signal?.aborted) throw new Error("aborted");
   let timeout: NodeJS.Timeout | undefined;
+  let abort: (() => void) | undefined;
   const timeoutPromise = new Promise<never>((_resolve, reject) => {
     timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    abort = () => reject(new Error("aborted"));
+    signal?.addEventListener("abort", abort, { once: true });
   });
   return Promise.race([promise, timeoutPromise]).finally(() => {
     if (timeout) clearTimeout(timeout);
+    if (abort) signal?.removeEventListener("abort", abort);
   });
 }

package/external/pi-tools-suite/src/lsp/child-process.ts

@@ -10,6 +10,7 @@ function canWriteToChild(child: ChildProcessWithoutNullStreams): boolean {
 }
 
 export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): boolean {
+  let signaled = false;
   try {
     if (process.platform === "win32" && child.pid) {
       const result = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
@@ -19,9 +20,22 @@ export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.
       });
       if (!result.error && result.status === 0) return true;
     }
-    return child.kill(signal);
+
+    if (child.pid) {
+      try {
+        // LSP clients are spawned in their own process group on POSIX. Kill the
+        // whole group so wrapper scripts also lose children such as Godot and nc.
+        process.kill(-child.pid, signal);
+        signaled = true;
+      } catch {
+        // Fall back to the direct child below. The process may not be detached
+        // or may have already exited.
+      }
+    }
+
+    return child.kill(signal) || signaled;
   } catch {
-    return false;
+    return signaled;
   }
 }
 

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

@@ -1,13 +1,16 @@
 import path from "node:path";
+import fs from "node:fs/promises";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { MessageConnection } from "vscode-jsonrpc";
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
 import {
   DefinitionRequest,
+  DiagnosticRefreshRequest,
   DidChangeConfigurationNotification,
   DidChangeTextDocumentNotification,
   DidOpenTextDocumentNotification,
   DidSaveTextDocumentNotification,
+  DocumentDiagnosticRequest,
   DocumentSymbolRequest,
   ExecuteCommandRequest,
   HoverRequest,
@@ -16,6 +19,7 @@ import {
   PublishDiagnosticsNotification,
   ReferencesRequest,
   type Diagnostic,
+  type DocumentDiagnosticReport,
   type InitializeResult,
   type ServerCapabilities,
 } from "vscode-languageserver-protocol";
@@ -24,11 +28,38 @@ import { bestEffortWriteJsonRpc, isChildRunning, killChild, terminateChild } fro
 import { DEFAULT_STARTUP_TIMEOUT_MS, REQUEST_TIMEOUT_MS } from "./constants";
 import { DocumentStore } from "./documents";
 import type { DiagnosticsStore } from "./diagnostics-store";
-import { filePathToUri } from "./_shared/paths";
+import { filePathToUri, uriToFilePath } from "./_shared/paths";
 import { isExecutableAvailable } from "./_shared/runner";
 import type { LspServerConfig, ResolvedCommand } from "./_shared/types";
 import { supportsSave } from "./lsp-utils";
 import type { OpenDocument } from "./types";
+
+interface MarkdownToken {
+  type: string;
+  markup: string;
+  content: string;
+  map: number[] | null;
+  children: MarkdownToken[] | null;
+}
+
+function markdownTextToken(content: string): MarkdownToken {
+  return { type: "text", markup: "", content, map: null, children: null };
+}
+
+function parseMarkdownTokens(text: string): MarkdownToken[] {
+  const tokens: MarkdownToken[] = [];
+  const lines = text.split(/\r?\n/);
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
+    const line = lines[lineNumber];
+    const heading = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (!heading) continue;
+    const [, markup, content] = heading;
+    tokens.push({ type: "heading_open", markup, content: "", map: [lineNumber, lineNumber + 1], children: null });
+    tokens.push({ type: "inline", markup: "", content, map: [lineNumber, lineNumber + 1], children: [markdownTextToken(content.trim())] });
+    tokens.push({ type: "heading_close", markup, content: "", map: null, children: null });
+  }
+  return tokens;
+}
 import { tsserverDiagnosticToLsp, tsserverDiagnosticsFromResponse } from "./tsserver";
 
 export class LspClient {
@@ -40,6 +71,8 @@ export class LspClient {
   private initialized = false;
   private unavailableReason: string | undefined;
   private stderrTail = "";
+  private readonly dynamicDiagnosticProviders = new Map<string, string | undefined>();
+  private diagnosticProviderWaiters: Array<() => void> = [];
 
   constructor(
     private readonly server: LspServerConfig,
@@ -76,6 +109,7 @@ export class LspClient {
     const child = spawn(this.command.bin, this.command.args, {
       cwd: this.command.cwd,
       env: this.command.env ? { ...process.env, ...this.command.env } : process.env,
+      detached: process.platform !== "win32",
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
     });
@@ -113,6 +147,7 @@ export class LspClient {
       Promise.race([connection.sendRequest(InitializeRequest.method, this.initializeParams()), startupFailure]),
       this.server.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
       `${this.server.id} initialize`,
+      signal,
     )) as InitializeResult;
     this.capabilities = initializeResult.capabilities;
     failStartup = undefined;
@@ -136,10 +171,12 @@ export class LspClient {
         window: { workDoneProgress: true },
         workspace: {
           configuration: true,
+          diagnostics: { refreshSupport: true },
           workspaceFolders: true,
           didChangeWatchedFiles: { dynamicRegistration: true },
         },
         textDocument: {
+          diagnostic: { dynamicRegistration: true, relatedDocumentSupport: true },
           synchronization: {
             didOpen: true,
             didChange: true,
@@ -178,8 +215,67 @@ export class LspClient {
       return items.map(() => this.server.settings ?? {});
     });
     anyConnection.onRequest("workspace/workspaceFolders", () => [{ name: path.basename(this.root), uri: filePathToUri(this.root) }]);
-    anyConnection.onRequest("client/registerCapability", () => null);
-    anyConnection.onRequest("client/unregisterCapability", () => null);
+    anyConnection.onRequest("markdown/parse", async (params: unknown) => {
+      const request = params as { uri?: unknown; text?: unknown } | undefined;
+      const text = typeof request?.text === "string"
+        ? request.text
+        : typeof request?.uri === "string"
+          ? this.documents.get(uriToFilePath(request.uri))?.text ?? await fs.readFile(uriToFilePath(request.uri), "utf8")
+          : "";
+      return parseMarkdownTokens(text);
+    });
+    anyConnection.onRequest("markdown/fs/readFile", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      return [...await fs.readFile(uriToFilePath(uri))];
+    });
+    anyConnection.onRequest("markdown/fs/stat", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return undefined;
+      try {
+        const stat = await fs.stat(uriToFilePath(uri));
+        return { isDirectory: stat.isDirectory() };
+      } catch {
+        return undefined;
+      }
+    });
+    anyConnection.onRequest("markdown/fs/readDirectory", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      try {
+        const entries = await fs.readdir(uriToFilePath(uri), { withFileTypes: true });
+        return entries.map((entry) => [entry.name, { isDirectory: entry.isDirectory() }]);
+      } catch {
+        return [];
+      }
+    });
+    anyConnection.onRequest("markdown/fs/watcher/create", () => null);
+    anyConnection.onRequest("markdown/fs/watcher/delete", () => null);
+    anyConnection.onRequest("markdown/findMarkdownFilesInWorkspace", () => []);
+    anyConnection.onRequest("client/registerCapability", (params: unknown) => {
+      const registrations = (params as { registrations?: unknown[] } | undefined)?.registrations;
+      if (!Array.isArray(registrations)) return null;
+
+      for (const registration of registrations) {
+        const item = registration as { id?: unknown; method?: unknown; registerOptions?: unknown };
+        if (typeof item.id !== "string" || item.method !== DocumentDiagnosticRequest.method) continue;
+        const options = item.registerOptions as { identifier?: unknown } | undefined;
+        this.dynamicDiagnosticProviders.set(item.id, typeof options?.identifier === "string" ? options.identifier : undefined);
+      }
+      this.resolveDiagnosticProviderWaiters();
+      return null;
+    });
+    anyConnection.onRequest("client/unregisterCapability", (params: unknown) => {
+      const unregisterations = (params as { unregisterations?: unknown[] } | undefined)?.unregisterations;
+      if (!Array.isArray(unregisterations)) return null;
+
+      for (const registration of unregisterations) {
+        const item = registration as { id?: unknown; method?: unknown };
+        if (typeof item.id === "string" && item.method === DocumentDiagnosticRequest.method) this.dynamicDiagnosticProviders.delete(item.id);
+      }
+      return null;
+    });
+    anyConnection.onRequest(DiagnosticRefreshRequest.method, () => null);
     anyConnection.onRequest("window/workDoneProgress/create", () => null);
     anyConnection.onNotification("window/logMessage", () => undefined);
     anyConnection.onNotification("telemetry/event", () => undefined);
@@ -226,7 +322,50 @@ export class LspClient {
     return Array.isArray(commands) && commands.includes("typescript.tsserverRequest");
   }
 
-  async tsserverDiagnostics(file: string, text: string, timeoutMs: number): Promise<Diagnostic[] | undefined> {
+  private supportsPullDiagnostics(): boolean {
+    return !!this.capabilities?.diagnosticProvider || this.dynamicDiagnosticProviders.size > 0;
+  }
+
+  private resolveDiagnosticProviderWaiters(): void {
+    const waiters = this.diagnosticProviderWaiters;
+    this.diagnosticProviderWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+
+  private async waitForPullDiagnosticsSupport(timeoutMs: number, signal?: AbortSignal): Promise<void> {
+    if (this.supportsPullDiagnostics() || timeoutMs <= 0) return;
+    await withTimeout(new Promise<void>((resolve) => {
+      this.diagnosticProviderWaiters.push(resolve);
+    }), timeoutMs, `${this.server.id} diagnostic registration`, signal).catch(() => undefined);
+  }
+
+  private diagnosticProviderIdentifiers(): Array<string | undefined> {
+    const identifiers: Array<string | undefined> = [];
+    const provider = this.capabilities?.diagnosticProvider;
+    if (provider) {
+      identifiers.push(
+        typeof provider === "object" && "identifier" in provider && typeof provider.identifier === "string"
+          ? provider.identifier
+          : undefined,
+      );
+    }
+    for (const identifier of this.dynamicDiagnosticProviders.values()) identifiers.push(identifier);
+
+    const seen = new Set<string>();
+    return identifiers.filter((identifier) => {
+      const key = identifier ?? "";
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  private diagnosticsFromReport(report: DocumentDiagnosticReport | null | undefined): Diagnostic[] | undefined {
+    if (!report || report.kind !== "full") return undefined;
+    return report.items;
+  }
+
+  async tsserverDiagnostics(file: string, text: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
     const connection = this.connection;
     if (!connection || !this.supportsTsserverDiagnostics()) return undefined;
 
@@ -252,11 +391,51 @@ export class LspClient {
       }),
       timeoutMs,
       `${this.server.id} ${request.command}`,
+      signal,
     )));
 
     return responses.flatMap((response) => tsserverDiagnosticsFromResponse(response).map((diagnostic) => tsserverDiagnosticToLsp(diagnostic, text)));
   }
 
+  async pullDiagnostics(file: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
+    const connection = this.connection;
+    if (!connection) return undefined;
+    if (!this.supportsPullDiagnostics()) {
+      await this.waitForPullDiagnosticsSupport(this.server.id === "csharp" ? Math.min(timeoutMs, 5_000) : 250, signal);
+    }
+    if (!this.supportsPullDiagnostics()) return undefined;
+    const identifiers = this.diagnosticProviderIdentifiers();
+    if (identifiers.length === 0) return undefined;
+
+    const uri = filePathToUri(file);
+    const settled = await Promise.allSettled(identifiers.map(async (identifier) => {
+      const report = (await withTimeout(
+        connection.sendRequest(DocumentDiagnosticRequest.method, {
+          textDocument: { uri },
+          identifier,
+        }),
+        timeoutMs,
+        `${this.server.id} textDocument/diagnostic${identifier ? ` (${identifier})` : ""}`,
+        signal,
+      )) as DocumentDiagnosticReport | null;
+      return this.diagnosticsFromReport(report) ?? [];
+    }));
+
+    const fulfilled = settled.filter((result): result is PromiseFulfilledResult<Diagnostic[]> => result.status === "fulfilled");
+    if (fulfilled.length === 0) {
+      const firstError = settled.find((result): result is PromiseRejectedResult => result.status === "rejected")?.reason;
+      throw firstError instanceof Error ? firstError : new Error(String(firstError ?? "pull diagnostics failed"));
+    }
+
+    const seen = new Set<string>();
+    return fulfilled.flatMap((result) => result.value).filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
   async hover(file: string, line: number, character: number): Promise<unknown> {
     if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
     return withTimeout(

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

@@ -9,6 +9,7 @@ import { filePathToUri, findProjectRoot, normalizeRelativePath, resolveCommand,
 import { formatLspDiagnostics, formatWarnings, joinSections } from "./_shared/output";
 import type { LspServerConfig, StoredDiagnostics } from "./_shared/types";
 import { clientKey, couldMatchBeforeRoot, fileSizeAllowed, languageIdForFile, readTextFile } from "./lsp-utils";
+import { localMarkdownDiagnostics } from "./markdown-diagnostics";
 import type { MatchedServer } from "./types";
 
 function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: number, version: number | undefined): entry is StoredDiagnostics {
@@ -17,6 +18,27 @@ function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: nu
     && (entry.version === undefined || version === undefined || entry.version >= version);
 }
 
+function diagnosticsWithLocalFallback(serverId: string, file: string, text: string, diagnostics: StoredDiagnostics["diagnostics"]): StoredDiagnostics["diagnostics"] {
+  if (serverId !== "markdown") return diagnostics;
+  const hasLanguageServerLinkDiagnostics = diagnostics.some((diagnostic) => typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  const localDiagnostics = localMarkdownDiagnostics(file, text).filter((diagnostic) => {
+    if (!hasLanguageServerLinkDiagnostics) return true;
+    return !(typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  });
+  if (localDiagnostics.length === 0) return diagnostics;
+
+  const seen = new Set(diagnostics.map((diagnostic) => JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message])));
+  return [
+    ...diagnostics,
+    ...localDiagnostics.filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  ];
+}
+
 export class LspManager {
   private readonly diagnostics = new DiagnosticsStore();
   private readonly clients = new Map<string, LspClient>();
@@ -115,16 +137,30 @@ export class LspManager {
         // diagnostics don't degrade into a misleading publishDiagnostics timeout.
         let tsserverFallbackError: string | undefined;
         try {
-          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs);
+          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
           if (tsserverDiagnostics !== undefined) {
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), tsserverDiagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, tsserverDiagnostics, match.root));
+            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) {
           tsserverFallbackError = (error as Error).message;
         }
 
+        let pullDiagnosticsError: string | undefined;
+        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;
+        }
+
         const entry = await this.diagnostics.waitForFile(
           match.server.id,
           match.root,
@@ -136,10 +172,13 @@ export class LspManager {
         );
         if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
           const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
-          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}`);
+          const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
+          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
           continue;
         }
-        lines.push(formatLspDiagnostics(match.server.id, file, entry.diagnostics, match.root));
+        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(`⚠️ ${match.server.id}: ${(error as Error).message}`);
       }

package/external/pi-tools-suite/src/lsp/markdown-diagnostics.ts

@@ -0,0 +1,157 @@
+import path from "node:path";
+import fs from "node:fs";
+import type { Diagnostic } from "vscode-languageserver-protocol";
+
+interface LineOffsets {
+  readonly text: string;
+  readonly starts: number[];
+}
+
+function lineOffsets(text: string): LineOffsets {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") starts.push(index + 1);
+  }
+  return { text, starts };
+}
+
+function positionAt(offsets: LineOffsets, offset: number): { line: number; character: number } {
+  let low = 0;
+  let high = offsets.starts.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (offsets.starts[mid] <= offset) low = mid + 1;
+    else high = mid - 1;
+  }
+  const line = Math.max(0, high);
+  return { line, character: Math.max(0, offset - offsets.starts[line]) };
+}
+
+function diagnostic(offsets: LineOffsets, start: number, end: number, message: string, code: string, severity: Diagnostic["severity"] = 1): Diagnostic {
+  return {
+    severity,
+    source: "pi-markdown",
+    code,
+    message,
+    range: {
+      start: positionAt(offsets, start),
+      end: positionAt(offsets, Math.max(end, start + 1)),
+    },
+  };
+}
+
+function addMarkdownLinkDiagnostics(file: string, text: string, offsets: LineOffsets, out: Diagnostic[]): void {
+  const definitions = new Map<string, Array<{ start: number; end: number }>>();
+  const usedReferences = new Set<string>();
+
+  for (const match of text.matchAll(/^\s{0,3}\[([^\]\r\n]+)\]:\s*(\S+)/gm)) {
+    const ref = match[1].trim().toLocaleLowerCase();
+    const start = (match.index ?? 0) + match[0].indexOf(match[1]);
+    const end = start + match[1].length;
+    const existing = definitions.get(ref) ?? [];
+    existing.push({ start, end });
+    definitions.set(ref, existing);
+  }
+
+  for (const [ref, locations] of definitions) {
+    if (locations.length <= 1) continue;
+    for (const location of locations) {
+      out.push(diagnostic(offsets, location.start, location.end, `Duplicate link definition: '${ref}'`, "link.duplicate-definition", 2));
+    }
+  }
+
+  for (const match of text.matchAll(/(?<!!)(?:\[[^\]\r\n]+\]\[([^\]\r\n]*)\]|\[([^\]\r\n]+)\]\[\])/g)) {
+    const full = match[0];
+    const explicit = match[1];
+    const collapsed = match[2];
+    const ref = (explicit === "" ? collapsed : explicit)?.trim();
+    if (!ref) continue;
+    const normalized = ref.toLocaleLowerCase();
+    usedReferences.add(normalized);
+    if (definitions.has(normalized)) continue;
+    const start = (match.index ?? 0) + full.lastIndexOf(ref);
+    out.push(diagnostic(offsets, start, start + ref.length, `No link definition found: '${ref}'`, "link.no-such-reference"));
+  }
+
+  for (const [ref, locations] of definitions) {
+    if (usedReferences.has(ref)) continue;
+    for (const location of locations) {
+      out.push(diagnostic(offsets, location.start, location.end, "Link definition is unused", "link.unused-definition", 4));
+    }
+  }
+
+  const fileLinkPattern = /(?<!!)\[[^\]\r\n]+\]\(([^)\s]+)(?:\s+[^)]*)?\)/g;
+  for (const match of text.matchAll(fileLinkPattern)) {
+    const href = match[1];
+    if (!href || /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("#")) continue;
+    const [targetPath] = href.split("#", 1);
+    if (!targetPath || targetPath.startsWith("mailto:")) continue;
+    const decoded = decodeURIComponent(targetPath);
+    const absolute = path.resolve(path.dirname(file), decoded);
+    try {
+      if (!fs.existsSync(absolute)) {
+        const start = (match.index ?? 0) + match[0].indexOf(href);
+        out.push(diagnostic(offsets, start, start + href.length, `File does not exist: '${href}'`, "link.no-such-file"));
+      }
+    } catch {
+      // Ignore malformed/unsupported local paths.
+    }
+  }
+}
+
+const mermaidStarters = /^(?:---|graph\s+(?:TB|BT|RL|LR|TD)|flowchart\s+(?:TB|BT|RL|LR|TD)|sequenceDiagram|classDiagram(?:-v2)?|stateDiagram(?:-v2)?|erDiagram|journey|gantt|pie(?:\s+title\b)?|gitGraph|mindmap|timeline|quadrantChart|requirementDiagram|C4Context|C4Container|C4Component|C4Dynamic|sankey-beta|xyChart-beta|block-beta|packet-beta|architecture-beta)\b/i;
+
+function mermaidBlocks(text: string): Array<{ content: string; startOffset: number; fenceStart: number; fenceEnd: number }> {
+  const blocks: Array<{ content: string; startOffset: number; fenceStart: number; fenceEnd: number }> = [];
+  const fencePattern = /^(```|~~~)\s*(?:mermaid|mmd)\b[^\r\n]*\r?\n([\s\S]*?)^\1\s*$/gim;
+  for (const match of text.matchAll(fencePattern)) {
+    const fenceStart = match.index ?? 0;
+    const contentStart = fenceStart + match[0].indexOf(match[2]);
+    blocks.push({ content: match[2], startOffset: contentStart, fenceStart, fenceEnd: fenceStart + match[0].length });
+  }
+  return blocks;
+}
+
+function addMermaidDiagnostics(file: string, text: string, offsets: LineOffsets, out: Diagnostic[]): void {
+  const extension = path.extname(file).toLocaleLowerCase();
+  const blocks = [".mmd", ".mermaid"].includes(extension)
+    ? [{ content: text, startOffset: 0, fenceStart: 0, fenceEnd: text.length }]
+    : mermaidBlocks(text);
+
+  for (const block of blocks) {
+    const lines = block.content.split(/\r?\n/);
+    const firstIndex = lines.findIndex((line) => {
+      const trimmed = line.trim();
+      return trimmed.length > 0 && !trimmed.startsWith("%%");
+    });
+    if (firstIndex === -1) {
+      out.push(diagnostic(offsets, block.fenceStart, block.fenceEnd, "Mermaid diagram is empty", "mermaid.empty"));
+      continue;
+    }
+
+    const beforeFirst = lines.slice(0, firstIndex).join("\n");
+    const firstOffset = block.startOffset + (beforeFirst ? beforeFirst.length + 1 : 0) + (lines[firstIndex].match(/^\s*/)?.[0].length ?? 0);
+    const firstLine = lines[firstIndex].trim();
+    if (!mermaidStarters.test(firstLine)) {
+      out.push(diagnostic(offsets, firstOffset, firstOffset + firstLine.length, "Mermaid diagram should start with a supported diagram type such as 'flowchart TD'", "mermaid.missing-diagram-type"));
+      continue;
+    }
+
+    let runningOffset = block.startOffset;
+    for (const line of lines) {
+      const arrow = /\b[A-Za-z0-9_]+\s*->\s*[A-Za-z0-9_]+\b/.exec(line);
+      if (arrow) {
+        out.push(diagnostic(offsets, runningOffset + arrow.index, runningOffset + arrow.index + arrow[0].length, "Mermaid flowchart arrows use '-->' or another Mermaid arrow form, not '->'", "mermaid.invalid-arrow"));
+      }
+      runningOffset += line.length + 1;
+    }
+  }
+}
+
+export function localMarkdownDiagnostics(file: string, text: string): Diagnostic[] {
+  const offsets = lineOffsets(text);
+  const diagnostics: Diagnostic[] = [];
+  addMarkdownLinkDiagnostics(file, text, offsets, diagnostics);
+  addMermaidDiagnostics(file, text, offsets, diagnostics);
+  return diagnostics;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "bin": {

package/external/pi-tools-suite/src/terminal-bell/index.ts

@@ -1,339 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter, isAbsolute, join } from "node:path";
-import { parse as parseJsonc } from "jsonc-parser";
-
-const BELL = "\x07";
-const DEFAULT_IDLE_DELAY_MS = 250;
-const IDLE_RETRY_DELAY_MS = 100;
-const MAX_IDLE_RETRIES = 40;
-const SUBAGENTS_LIVE_COUNT_EVENT = "pi-tools-suite:async-subagents:live-count";
-const DEFAULT_NOTIFICATION_TITLE = "Pi";
-const DEFAULT_NOTIFICATION_MESSAGE = "Session stopped";
-const DEFAULT_ASK_USER_NOTIFICATION_MESSAGE = "Waiting for your answer";
-const DEFAULT_MAC_SOUND = "Glass";
-const TERMINAL_BELL_CONFIG_KEY = "terminalBell";
-const SOUND_CONFIG_KEY = "sound";
-
-const TERM_PROGRAM_BUNDLE_IDS: Record<string, string> = {
-	Apple_Terminal: "com.apple.Terminal",
-	iTerm: "com.googlecode.iterm2",
-	"iTerm.app": "com.googlecode.iterm2",
-	WezTerm: "com.github.wez.wezterm",
-	WarpTerminal: "dev.warp.Warp-Stable",
-	ghostty: "com.mitchellh.ghostty",
-	Ghostty: "com.mitchellh.ghostty",
-	kitty: "net.kovidgoyal.kitty",
-	Alacritty: "org.alacritty",
-	vscode: "com.microsoft.VSCode",
-	"vscode-insiders": "com.microsoft.VSCodeInsiders",
-	zed: "dev.zed.Zed",
-};
-
-type Timer = ReturnType<typeof setTimeout>;
-
-type SubagentsLiveCountEvent = {
-	count?: unknown;
-};
-
-function parseDelayMs(value: string | undefined): number {
-	if (value === undefined || value.trim() === "") return DEFAULT_IDLE_DELAY_MS;
-	const parsed = Number(value);
-	return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_IDLE_DELAY_MS;
-}
-
-function isTruthyEnv(value: string | undefined): boolean {
-	if (value === undefined) return false;
-	return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-
-function extensionDisabled(): boolean {
-	return isTruthyEnv(process.env.HEADLESS) || isTruthyEnv(process.env.PI_TERMINAL_BELL_DISABLED);
-}
-
-function getPiToolsSuiteUserConfigPath(homeDir = homedir()): string {
-	return join(homeDir, ".config", "pi", "pi-tools-suite.jsonc");
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-export function readTerminalBellSoundConfig(configPath = getPiToolsSuiteUserConfigPath()): boolean | undefined {
-	if (!existsSync(configPath)) return undefined;
-	try {
-		const parsed = parseJsonc(readFileSync(configPath, "utf-8")) as unknown;
-		if (!isRecord(parsed)) return undefined;
-		const terminalBell = parsed[TERMINAL_BELL_CONFIG_KEY];
-		if (!isRecord(terminalBell)) return undefined;
-		const sound = terminalBell[SOUND_CONFIG_KEY];
-		return typeof sound === "boolean" ? sound : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-export function terminalBellSoundEnabled(ctx: Pick<ExtensionContext, "hasUI">, configPath = getPiToolsSuiteUserConfigPath()): boolean {
-	if (process.env.PI_TERMINAL_BELL_SOUND === "0") return false;
-	if (process.env.PI_TERMINAL_BELL_SOUND === "1") return true;
-	const configured = readTerminalBellSoundConfig(configPath);
-	if (configured !== undefined) return configured;
-	return ctx.hasUI === true;
-}
-
-export function terminalBellNotificationsEnabled(ctx: Pick<ExtensionContext, "hasUI">, configPath = getPiToolsSuiteUserConfigPath()): boolean {
-	if (!terminalBellSoundEnabled(ctx, configPath)) return false;
-	if (process.env.PI_TERMINAL_BELL_NOTIFY === "0") return false;
-	if (process.env.PI_TERMINAL_BELL_NOTIFY === "1") return true;
-	return ctx.hasUI === true;
-}
-
-export function canRingTerminal(ctx: Pick<ExtensionContext, "hasUI">, configPath = getPiToolsSuiteUserConfigPath()): boolean {
-	if (!terminalBellSoundEnabled(ctx, configPath)) return false;
-	if (process.env.PI_TERMINAL_BELL === "0") return false;
-	if (process.env.PI_TERMINAL_BELL_FORCE === "1") return true;
-	return Boolean(process.stdout.isTTY || process.stderr.isTTY);
-}
-
-function writeBell(): void {
-	const stream = process.stdout.isTTY || !process.stderr.isTTY ? process.stdout : process.stderr;
-	stream.write(BELL);
-}
-
-function appleScriptString(value: string): string {
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-
-function shellSingleQuote(value: string): string {
-	return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-
-function spawnDetached(command: string, args: string[]): void {
-	try {
-		const child = spawn(command, args, { detached: true, stdio: "ignore" });
-		child.on("error", () => {});
-		child.unref();
-	} catch {
-		// Best-effort user attention signal. Missing notification backends should not
-		// affect the agent loop or suppress the terminal bell.
-	}
-}
-
-function findExecutable(command: string): string | undefined {
-	if (command.includes("/")) return existsSync(command) ? command : undefined;
-	for (const dir of (process.env.PATH ?? "").split(delimiter)) {
-		if (!dir) continue;
-		const candidate = join(dir, command);
-		if (existsSync(candidate)) return candidate;
-	}
-	return undefined;
-}
-
-function resolveMacSoundPath(sound: string): string {
-	if (isAbsolute(sound)) return sound;
-	const fileName = sound.endsWith(".aiff") ? sound : `${sound}.aiff`;
-	return `/System/Library/Sounds/${fileName}`;
-}
-
-function detectMacActivationBundleId(): string | undefined {
-	const explicit = process.env.PI_TERMINAL_BELL_NOTIFY_ACTIVATE;
-	if (explicit === "0" || explicit === "false") return undefined;
-	if (explicit && explicit.trim() !== "") return explicit.trim();
-
-	// GUI apps that launch shells on macOS commonly export their own bundle id.
-	// This catches Terminal.app, iTerm2, Zed's terminal, VS Code terminals, etc.
-	const inheritedBundleId = process.env.__CFBundleIdentifier;
-	if (inheritedBundleId && inheritedBundleId.trim() !== "") return inheritedBundleId.trim();
-
-	const termProgram = process.env.TERM_PROGRAM;
-	if (!termProgram) return undefined;
-	return TERM_PROGRAM_BUNDLE_IDS[termProgram];
-}
-
-function playAttentionSound(ctx: ExtensionContext): void {
-	if (!terminalBellSoundEnabled(ctx)) return;
-	if (process.platform !== "darwin") return;
-	const sound = process.env.PI_TERMINAL_BELL_SOUND && process.env.PI_TERMINAL_BELL_SOUND !== "1"
-		? process.env.PI_TERMINAL_BELL_SOUND
-		: DEFAULT_MAC_SOUND;
-	const soundPath = resolveMacSoundPath(sound);
-	if (!existsSync(soundPath)) return;
-	spawnDetached("/usr/bin/afplay", [soundPath]);
-}
-
-function notifySessionStopped(
-	ctx: ExtensionContext,
-	macActivationBundleId: string | undefined,
-	message = process.env.PI_TERMINAL_BELL_NOTIFY_MESSAGE ?? DEFAULT_NOTIFICATION_MESSAGE,
-): void {
-	if (!terminalBellNotificationsEnabled(ctx)) return;
-	const title = process.env.PI_TERMINAL_BELL_NOTIFY_TITLE ?? DEFAULT_NOTIFICATION_TITLE;
-
-	if (process.platform === "darwin") {
-		const terminalNotifier = findExecutable(process.env.PI_TERMINAL_BELL_NOTIFIER ?? "terminal-notifier");
-		if (terminalNotifier) {
-			const args = ["-title", title, "-message", message];
-			const activate = macActivationBundleId;
-			if (activate) {
-				args.push("-activate", activate);
-				args.push("-execute", `/usr/bin/open -b ${shellSingleQuote(activate)}`);
-
-				// Do not pass -sender by default. On recent macOS versions it can make the
-				// notification look like it came from the target app, but then clicking the
-				// “Show” button may be handled as that app's own notification instead of
-				// terminal-notifier's -activate/-execute action.
-				if (process.env.PI_TERMINAL_BELL_NOTIFY_SENDER === "1") {
-					args.push("-sender", activate);
-				}
-			}
-			spawnDetached(terminalNotifier, args);
-			return;
-		}
-
-		// Bare osascript notifications are sent by Script Editor/osascript on macOS;
-		// clicking them can open Script Editor's file picker. Keep that backend opt-in
-		// and prefer terminal-notifier for clickable system notifications.
-		if (process.env.PI_TERMINAL_BELL_NOTIFY_OSASCRIPT !== "1") return;
-		spawnDetached("/usr/bin/osascript", [
-			"-e",
-			`display notification ${appleScriptString(message)} with title ${appleScriptString(title)}`,
-		]);
-		return;
-	}
-
-	if (process.platform === "linux") {
-		spawnDetached("notify-send", [title, message]);
-	}
-}
-
-const ASK_USER_TOOL_NAMES = new Set(["ask_user", "ask_user_question", "question"]);
-
-function isAskUserToolName(toolName: string): boolean {
-	return ASK_USER_TOOL_NAMES.has(toolName);
-}
-
-function isSubagentsWaitTool(toolName: string, args: unknown): boolean {
-	if (toolName === "async_subagents_wait") return true;
-	if (toolName !== "subagents") return false;
-	if (!args || typeof args !== "object") return false;
-	const action = (args as { action?: unknown }).action;
-	return typeof action === "string" && action.trim().toLowerCase() === "wait";
-}
-
-function normalizeLiveCount(event: SubagentsLiveCountEvent): number | undefined {
-	if (typeof event.count !== "number" || !Number.isFinite(event.count)) return undefined;
-	return Math.max(0, Math.floor(event.count));
-}
-
-export default function terminalBell(pi: ExtensionAPI) {
-	if (extensionDisabled()) return;
-
-	let timer: Timer | undefined;
-	let lastCtx: ExtensionContext | undefined;
-	let deferredUntilSubagentsFinish = false;
-	let liveSubagentCount = 0;
-	const activeSubagentWaitToolCallIds = new Set<string>();
-	const notifiedAskUserToolCallIds = new Set<string>();
-	const idleDelayMs = parseDelayMs(process.env.PI_TERMINAL_BELL_DELAY_MS);
-	const macActivationBundleId = process.platform === "darwin" ? detectMacActivationBundleId() : undefined;
-
-	function clearTimer(): void {
-		if (!timer) return;
-		clearTimeout(timer);
-		timer = undefined;
-	}
-
-	function hasSubagentWork(): boolean {
-		return liveSubagentCount > 0 || activeSubagentWaitToolCallIds.size > 0;
-	}
-
-	function notifyAttention(ctx: ExtensionContext, message?: string): void {
-		if (canRingTerminal(ctx)) writeBell();
-		playAttentionSound(ctx);
-		notifySessionStopped(ctx, macActivationBundleId, message);
-	}
-
-	function attemptBell(ctx: ExtensionContext, attempt: number): void {
-		timer = undefined;
-
-		if (!ctx.isIdle()) {
-			if (attempt < MAX_IDLE_RETRIES) scheduleBell(ctx, IDLE_RETRY_DELAY_MS, attempt + 1);
-			return;
-		}
-
-		if (ctx.hasPendingMessages()) return;
-
-		if (hasSubagentWork()) {
-			deferredUntilSubagentsFinish = true;
-			return;
-		}
-
-		deferredUntilSubagentsFinish = false;
-		notifyAttention(ctx);
-	}
-
-	function scheduleBell(ctx: ExtensionContext, delayMs = idleDelayMs, attempt = 0): void {
-		lastCtx = ctx;
-		clearTimer();
-		timer = setTimeout(() => attemptBell(ctx, attempt), delayMs);
-		timer.unref?.();
-	}
-
-	function notifyAskUserWaiting(toolCallId: string, ctx: ExtensionContext): void {
-		if (notifiedAskUserToolCallIds.has(toolCallId)) return;
-		notifiedAskUserToolCallIds.add(toolCallId);
-		notifyAttention(ctx, process.env.PI_TERMINAL_BELL_ASK_USER_NOTIFY_MESSAGE ?? DEFAULT_ASK_USER_NOTIFICATION_MESSAGE);
-	}
-
-	pi.events.on(SUBAGENTS_LIVE_COUNT_EVENT, (data: unknown) => {
-		const event = data && typeof data === "object" ? data as SubagentsLiveCountEvent : {};
-		const count = normalizeLiveCount(event);
-		if (count === undefined) return;
-		liveSubagentCount = count;
-		if (count === 0 && deferredUntilSubagentsFinish && lastCtx) {
-			scheduleBell(lastCtx);
-		}
-	});
-
-	pi.on("agent_start", async () => {
-		clearTimer();
-		deferredUntilSubagentsFinish = false;
-		activeSubagentWaitToolCallIds.clear();
-		notifiedAskUserToolCallIds.clear();
-	});
-
-	pi.on("tool_execution_start", async (event, ctx) => {
-		if (isSubagentsWaitTool(event.toolName, event.args)) {
-			activeSubagentWaitToolCallIds.add(event.toolCallId);
-		}
-		if (isAskUserToolName(event.toolName)) {
-			notifyAskUserWaiting(event.toolCallId, ctx);
-		}
-	});
-
-	pi.on("tool_call", async (event, ctx) => {
-		if (isAskUserToolName(event.toolName)) {
-			notifyAskUserWaiting(event.toolCallId, ctx);
-		}
-	});
-
-	pi.on("tool_execution_end", async (event) => {
-		activeSubagentWaitToolCallIds.delete(event.toolCallId);
-		notifiedAskUserToolCallIds.delete(event.toolCallId);
-	});
-
-	pi.on("agent_end", async (_event, ctx) => {
-		scheduleBell(ctx);
-	});
-
-	pi.on("session_shutdown", async () => {
-		clearTimer();
-		lastCtx = undefined;
-		deferredUntilSubagentsFinish = false;
-		liveSubagentCount = 0;
-		activeSubagentWaitToolCallIds.clear();
-		notifiedAskUserToolCallIds.clear();
-	});
-}