pi-web-ui 0.29.0 → 0.29.2

package/dist/server/agent-service.js

@@ -39,6 +39,19 @@ const STREAMING_SNAPSHOT_INTERVAL_MS = 2000;
 /** Deltas newer than this keep the streaming (low-frequency) snapshot cadence. */
 const DELTA_ACTIVE_WINDOW_MS = 1500;
 const WIDGET_REFRESH_MS = 2000;
+/** Model-stall watchdog: warn (don't abort — deep thinking can be legitimately
+ *  quiet for minutes) when a streaming run produced NO SDK events for this long.
+ *  Covers the failure class the per-tool watchdog cannot see: half-open API
+ *  connections / hung proxies where no tool is running and no error is thrown.
+ *  Override: PI_WEB_STALL_NOTIFY_MS (milliseconds; 0 disables). */
+const STALL_NOTIFY_MS = (() => {
+    const v = Number(process.env.PI_WEB_STALL_NOTIFY_MS);
+    return Number.isFinite(v) && v >= 0 ? v : 180_000;
+})();
+/** Serialization-cache cap per conversation (see serializeCached): cached
+ *  UiMessage objects are pure-function results, so eviction only costs a
+ *  recompute on next access. Bounds memory for marathon sessions. */
+const UI_MESSAGE_CACHE_CAP = 4096;
 /** Preview panel cap: only the first 512KB of a file is ever read/sent. */
 /** Thrown when the service is quiesced (draining) and the request is NEW work
  *  the admission controller refuses: a brand-new client attach, a prompt,
@@ -66,14 +79,14 @@ export class QuiesceRejectedError extends Error {
  *  programs wait for input that never comes. Legacy Chinese files are often
  *  GBK/GB2312 — read them with the right encoding, never paste mojibake into
  *  reasoning/answers. */
-const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
-
-
-
-- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
-- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
-- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
-
+const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
+
+
+
+- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
+- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
+- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
+
 Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK/GB2312 encoded: the read tool decodes UTF-8 only and will show mojibake (乱码) for them. If a file's content looks garbled, read it through the terminal instead: in Git Bash use \`cat file | iconv -f GBK -t UTF-8\` (or \`iconv -f GBK -t UTF-8 file\`); in cmd use \`chcp 65001 && type file\`; in PowerShell use \`Get-Content -Encoding Default file\`. Never paste mojibake into your reasoning or answer — describe the decoded content instead.`;
 /**
  * Killable bash tool: wraps the SDK bash tool with operations that register
@@ -346,6 +359,8 @@ export class ClientSession {
     /** Web-facing extension UI context (widgets, notifications). */
     webUi = new WebUIContext((msg) => this.emit(msg));
     widgetsTimer = null;
+    /** Model-stall watchdog interval (see startStallTimer). */
+    stallTimer = null;
     /** Connected sockets for this client (multiple tabs share the session). */
     sinks = new Set();
     pendingNotices = [];
@@ -355,6 +370,13 @@ export class ClientSession {
     lastDeltaAt = 0;
     sessionsTimer = null;
     version = 0;
+    /** Snapshot revision counter (see emitSnapshotNow / protocol snapshot_delta). */
+    snapRev = 0;
+    /** Messages array as of the last emitted snapshot/delta — identity-walked
+     *  against the current array to detect append-only growth. */
+    emittedMessages = null;
+    /** snapRev value at which emittedMessages was captured. */
+    emittedRev = 0;
     /**
      * Per-conversation serialization caches (stable message ids, UiMessage
      * object cache, message-array signature, queue counts) live inside each
@@ -552,6 +574,8 @@ export class ClientSession {
             listed: false,
             promptedSinceActive: false,
             lastActiveAt: Date.now(),
+            lastSdkEventAt: Date.now(),
+            stallNoticed: false,
             goal: this.makeGoalStatus(),
             goalGeneration: 0,
             goalReviewGeneration: 0,
@@ -570,6 +594,29 @@ export class ClientSession {
             toolWatchdogs: new Map(),
         };
     }
+    /** Summaries of conversations currently streaming — captured at shutdown
+     *  so the next attach can tell the user their run was interrupted. */
+    streamingSummaries() {
+        const out = [];
+        for (const conv of this.convs.values()) {
+            if (conv.session.isStreaming)
+                out.push({ title: conv.title, cwd: conv.cwd });
+        }
+        return out;
+    }
+    /** Tell the user about runs lost to the last server restart (once). */
+    notifyInterrupted(list) {
+        if (!list || list.length === 0)
+            return;
+        const names = list
+            .map((r) => `「${r.title}」（${r.cwd}）`)
+            .join("、");
+        this.pendingNotices.push({
+            type: "notice",
+            level: "warning",
+            text: `上次服务重启时有 ${list.length} 个进行中的对话被中断：${names}。可在历史对话中恢复继续。`,
+        });
+    }
     /** Add a socket to this client's broadcast set; flushes buffered startup notices. */
     attachSink(send) {
         this.sinks.add(send);
@@ -635,6 +682,7 @@ export class ClientSession {
         this.scheduleSnapshot();
         this.webUi.refresh();
         this.startWidgetsTimer();
+        this.startStallTimer();
     }
     /** Poll extension widgets so TUI-only overlays (e.g. rpiv-todo) stay live. */
     startWidgetsTimer() {
@@ -645,6 +693,32 @@ export class ClientSession {
                 this.webUi.refresh();
         }, WIDGET_REFRESH_MS);
     }
+    /** Model-stall watchdog: warn when a streaming run went completely silent
+     *  (no SDK events at all) for STALL_NOTIFY_MS. Deliberately does NOT abort:
+     *  deep-thinking models can legitimately be quiet for minutes — the notice
+     *  just tells the user the run looks stuck so they can Stop it themselves. */
+    startStallTimer() {
+        if (this.stallTimer || STALL_NOTIFY_MS === 0)
+            return;
+        this.stallTimer = setInterval(() => {
+            if (this.disposed)
+                return;
+            const now = Date.now();
+            for (const conv of this.convs.values()) {
+                if (!conv.stallNoticed &&
+                    conv.session.isStreaming &&
+                    now - conv.lastSdkEventAt > STALL_NOTIFY_MS) {
+                    conv.stallNoticed = true;
+                    const mins = Math.round((now - conv.lastSdkEventAt) / 60_000);
+                    this.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `对话「${conv.title}」已 ${mins} 分钟无任何响应，可能已失联（网络中断或服务端挂起）。可点击停止后重试。`,
+                    });
+                }
+            }
+        }, 30_000);
+    }
     /** Arm the hang-guard for a tool call: if it is still running after
      *  TOOL_WATCHDOG_TIMEOUT_MS, abort the session instead of letting the
      *  conversation hang forever (the SDK bash tool has no default timeout). */
@@ -684,6 +758,9 @@ export class ClientSession {
         conv.toolWatchdogs.clear();
     }
     onEvent(conv, event) {
+        // Any SDK event proves the run is alive — feeds the stall watchdog below.
+        conv.lastSdkEventAt = Date.now();
+        conv.stallNoticed = false;
         switch (event.type) {
             case "bash_execution_update": {
                 if (event.id) {
@@ -905,11 +982,42 @@ export class ClientSession {
             conv.userSeqByTs.set(ts, seq);
         }
         const msg = serializeMessage(m, seq);
-        if (msg)
+        if (msg) {
             conv.uiMessageCache.set(cacheKey, msg);
+            // Bound the cache (marathon sessions otherwise grow without limit;
+            // single messages can reach TEXT_CAP = 200K chars). Map iteration is
+            // insertion order, so dropping from the front evicts the oldest —
+            // recent messages (the ones every snapshot touches) always survive.
+            // Safe: a miss just recomputes an identical object on next access.
+            let excess = conv.uiMessageCache.size - UI_MESSAGE_CACHE_CAP;
+            while (excess-- > 0) {
+                const oldest = conv.uiMessageCache.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                conv.uiMessageCache.delete(oldest);
+            }
+        }
         return msg;
     }
-    snapshot() {
+    /** Current messages array (with the existing sig-reuse optimization).
+     *  Element objects are reference-stable (serializeCached cache), which is
+     *  what lets emitSnapshotNow detect append-only growth via identity walk. */
+    currentMessages() {
+        const conv = this.conv;
+        const rawMessages = conv.session.agent.state.messages
+            .map((m) => this.serializeCached(m))
+            .filter((m) => m !== null);
+        // Reuse the previous array when nothing changed: the element objects are
+        // cached (reference-stable) anyway, and a stable array reference lets the
+        // frontend memoize derived maps instead of rebuilding them every 60ms.
+        const sig = rawMessages.map((m) => m.id).join("\u0001");
+        const messages = conv.lastMessagesSig === sig ? conv.lastMessagesArray : rawMessages;
+        conv.lastMessagesSig = sig;
+        conv.lastMessagesArray = rawMessages;
+        return messages;
+    }
+    /** Build every UiState field EXCEPT messages (the expensive part). */
+    buildLightState(rev) {
         const conv = this.conv;
         const state = conv.session.agent.state;
         const model = state.model;
@@ -937,23 +1045,13 @@ export class ClientSession {
         catch {
             // stats are best-effort
         }
-        const rawMessages = state.messages
-            .map((m) => this.serializeCached(m))
-            .filter((m) => m !== null);
-        // Reuse the previous array when nothing changed: the element objects are
-        // cached (reference-stable) anyway, and a stable array reference lets the
-        // frontend memoize derived maps instead of rebuilding them every 60ms.
-        const sig = rawMessages.map((m) => m.id).join("\u0001");
-        const messages = conv.lastMessagesSig === sig ? conv.lastMessagesArray : rawMessages;
-        conv.lastMessagesSig = sig;
-        conv.lastMessagesArray = rawMessages;
         return {
             clientId: this.clientId,
             cwd: this.cwd,
             sessionId: this.session.sessionId,
             sessionFile: this.session.sessionFile,
             conversationId: this.activeId,
-            messages,
+            rev,
             // The in-progress assistant message lives in state.streamingMessage
             // (the SDK only pushes it into state.messages at message_end). Surfacing
             // it here is what makes thinking + text stream into the browser at
@@ -982,6 +1080,53 @@ export class ClientSession {
             stats,
         };
     }
+    /** Emit one snapshot update — incremental when possible, full otherwise.
+     *
+     *  Persisted messages are content-immutable with reference-stable objects
+     *  (serializeCached), so an IDENTITY WALK over the previous array detects
+     *  append-only growth in O(n) pointer compares. Appends travel as
+     *  snapshot_delta carrying only the new tail + light fields; any mid-array
+     *  change/truncation (switch session, edit fork, compaction) or a forced
+     *  resync falls back to a full snapshot. The 10MB-stringify-per-checkpoint
+     *  cost of big sessions collapses to a few hundred bytes for the common
+     *  "nothing but stats/version changed" checkpoint. */
+    emitSnapshotNow(forceFull = false) {
+        if (this.disposed)
+            return;
+        const cur = this.currentMessages();
+        const prev = this.emittedMessages;
+        let incremental = !forceFull && prev !== null && prev.length <= cur.length;
+        if (incremental && prev) {
+            for (let i = 0; i < prev.length; i++) {
+                if (prev[i] !== cur[i]) {
+                    incremental = false;
+                    break;
+                }
+            }
+        }
+        const rev = ++this.snapRev;
+        if (incremental && prev) {
+            const baseRev = this.emittedRev;
+            this.emittedMessages = cur;
+            this.emittedRev = rev;
+            this.emit({
+                type: "snapshot_delta",
+                conversationId: this.activeId,
+                rev,
+                baseRev,
+                appended: cur.slice(prev.length),
+                state: this.buildLightState(rev),
+            });
+        }
+        else {
+            this.emittedMessages = cur;
+            this.emittedRev = rev;
+            this.emit({
+                type: "snapshot",
+                state: { ...this.buildLightState(rev), messages: cur },
+            });
+        }
+    }
     /** Resolve a browser-bridged dialog (select/confirm/input) for this session. */
     resolveDialog(id, value) {
         this.webUi.resolveDialog(id, value);
@@ -1270,14 +1415,16 @@ export class ClientSession {
         }
         this.flushSnapshot();
     }
-    /** Send a snapshot immediately (cancels any pending throttled one). */
-    flushSnapshot() {
+    /** Send a snapshot immediately (cancels any pending throttled one).
+     *  forceFull skips the incremental path — used by get_state so a (re)
+     *  connecting or desynced client always receives an authoritative full
+     *  state it can rebuild from. */
+    flushSnapshot(forceFull = false) {
         if (this.snapshotTimer) {
             clearTimeout(this.snapshotTimer);
             this.snapshotTimer = null;
         }
-        if (!this.disposed)
-            this.emit({ type: "snapshot", state: this.snapshot() });
+        this.emitSnapshotNow(forceFull);
     }
     scheduleSnapshot() {
         if (this.snapshotTimer || this.disposed)
@@ -1290,8 +1437,7 @@ export class ClientSession {
             : SNAPSHOT_INTERVAL_MS;
         this.snapshotTimer = setTimeout(() => {
             this.snapshotTimer = null;
-            if (!this.disposed)
-                this.emit({ type: "snapshot", state: this.snapshot() });
+            this.emitSnapshotNow();
         }, interval);
     }
     /** Slash-command catalog + native command execution — 自包含模块，见
@@ -1485,6 +1631,9 @@ export class ClientSession {
         // per-project "most recently active" order used by set_cwd.)
         conv.promptedSinceActive = true;
         conv.lastActiveAt = Date.now();
+        // Fresh run — restart the stall watchdog window.
+        conv.lastSdkEventAt = Date.now();
+        conv.stallNoticed = false;
         this.flushSnapshot();
     }
     /**
@@ -2002,6 +2151,10 @@ export class ClientSession {
     async listFiles(relPath) {
         return this.files.listFiles(relPath);
     }
+    /** 全局搜索：递归文件名匹配（结果经 search_files_result 回推，reqId 匹配）。 */
+    async searchFiles(query, reqId) {
+        return this.files.searchFiles(query, reqId);
+    }
     /** SCM 只读查询（结构化 JSON，reqId 匹配）。 */
     async scmQuery(kind, reqId, arg) {
         return this.files.scmQuery(kind, reqId, arg);
@@ -2260,6 +2413,10 @@ export class ClientSession {
             clearInterval(this.widgetsTimer);
             this.widgetsTimer = null;
         }
+        if (this.stallTimer) {
+            clearInterval(this.stallTimer);
+            this.stallTimer = null;
+        }
         this.files.unwatchDir();
         this.files.unwatchGit();
         this.webUi.dispose();
@@ -2402,6 +2559,10 @@ export class AgentService {
                 }
             }
         }
+        // First attach after a restart: report runs that were interrupted when
+        // the previous process shut down (consumed once, then cleared). Queue
+        // BEFORE attachSink so the notice rides the initial pending-notice flush.
+        cs.notifyInterrupted(this.stateStore.takeInterrupted(clientId));
         cs.attachSink(send);
         // Forward hooks (set once by index.ts) to every session.
         cs.onUpdateReady = this.onUpdateReady;
@@ -2417,6 +2578,19 @@ export class AgentService {
         return this.clients.get(clientId);
     }
     async disposeAll() {
+        // Record still-streaming conversations BEFORE tearing anything down, so
+        // the next attach can tell the user what was lost (SIGTERM / update).
+        for (const [clientId, cs] of [...this.clients]) {
+            try {
+                const running = cs.streamingSummaries();
+                if (running.length > 0) {
+                    this.stateStore.saveInterrupted(clientId, running.map((r) => ({ ...r, at: Date.now() })));
+                }
+            }
+            catch {
+                // best effort — never block shutdown on bookkeeping
+            }
+        }
         const all = [...this.clients.values()];
         this.clients.clear();
         await Promise.all(all.map((cs) => cs.dispose()));

package/dist/server/bg-servers.js

@@ -1,4 +1,4 @@
-import { killPidTree, lookupProcessName, snapshotListeningPorts } from "./process-utils.js";
+import { killPidTree, lookupProcessName, lookupProcessCommandLine, snapshotListeningPorts, } from "./process-utils.js";
 const BG_REFRESH_INTERVAL_MS = 30_000;
 /** bash 结束后等这么久再拍「后」快照——给后台服务绑定端口的时间。 */
 const BG_BIND_WAIT_MS = 1500;
@@ -43,7 +43,8 @@ export class BgServerTracker {
             if (!before.has(port) && !this.servers.has(port)) {
                 this.servers.set(port, { pid, since: Date.now() });
                 added = true;
-                // Best-effort process name so the panel shows something readable.
+                // Best-effort process name + full command line so the panel shows
+                // something readable (name) AND what is actually running (command).
                 void lookupProcessName(pid).then((name) => {
                     const cur = this.servers.get(port);
                     if (cur && cur.pid === pid && name) {
@@ -51,6 +52,13 @@ export class BgServerTracker {
                         this.push();
                     }
                 });
+                void lookupProcessCommandLine(pid).then((command) => {
+                    const cur = this.servers.get(port);
+                    if (cur && cur.pid === pid && command) {
+                        cur.command = command;
+                        this.push();
+                    }
+                });
                 this.opts.emit({
                     type: "notice",
                     level: "info",
@@ -69,6 +77,7 @@ export class BgServerTracker {
             pid: v.pid,
             since: v.since,
             ...(v.name ? { name: v.name } : {}),
+            ...(v.command ? { command: v.command } : {}),
         }))
             .sort((a, b) => a.since - b.since);
     }

package/dist/server/client-state.js

@@ -92,6 +92,28 @@ export class ClientStateStore {
         };
         this.save();
     }
+    /** Remember conversations that were still streaming at shutdown (best-
+     *  effort; called during the graceful-shutdown path). */
+    saveInterrupted(clientId, list) {
+        if (list.length === 0)
+            return;
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.interrupted = list.slice(0, 8);
+        this.save();
+    }
+    /** Consume the interrupted-conversation record (returns and clears it) —
+     *  called once on the client's first attach after a restart. */
+    takeInterrupted(clientId) {
+        const all = this.load();
+        const state = all[clientId];
+        const list = state?.interrupted;
+        if (list?.length && state) {
+            delete state.interrupted;
+            this.save();
+        }
+        return list;
+    }
     /** Last-used settings-panel state for a client, or defaults. */
     getSettings(clientId) {
         const s = this.load()[clientId];

package/dist/server/files-service.js

@@ -191,6 +191,82 @@ export class FilesService {
             truncated,
         });
     }
+    /**
+     * Global search: recursive filename match across the active workspace.
+     * Best-effort bounded walk — ignored dirs (node_modules/.git/…) are
+     * skipped, unreadable dirs silently passed, and hard caps on results /
+     * visited entries / elapsed time keep big repos responsive. Always answers
+     * with a search_files_result echoing reqId so the client's request never
+     * stalls (ok:false on unexpected failure).
+     */
+    async searchFiles(query, reqId) {
+        const { join } = await import("node:path");
+        const fsp = await import("node:fs/promises");
+        const q = query.trim().toLowerCase();
+        if (!q) {
+            this.host.emit({ type: "search_files_result", reqId, ok: true, results: [] });
+            return;
+        }
+        const root = resolve(this.host.getActiveCwd());
+        const ignored = ignoredEntries();
+        const MAX_RESULTS = 50;
+        const MAX_VISITED = 20000;
+        const MAX_MS = 4000;
+        const start = Date.now();
+        const results = [];
+        let visited = 0;
+        let truncated = false;
+        const budgetLeft = () => results.length < MAX_RESULTS &&
+            visited < MAX_VISITED &&
+            Date.now() - start < MAX_MS;
+        // Breadth-first-ish iterative stack; depth cap is a symlink-cycle guard.
+        const walk = async (abs, rel, depth) => {
+            if (!budgetLeft() || depth > 24) {
+                truncated = true;
+                return;
+            }
+            let dirents;
+            try {
+                dirents = await fsp.readdir(abs, { withFileTypes: true });
+            }
+            catch {
+                return; // unreadable dir (ACL/permissions) — skip silently
+            }
+            for (const d of dirents) {
+                visited++;
+                if (!budgetLeft()) {
+                    truncated = true;
+                    break;
+                }
+                if (ignored.has(d.name))
+                    continue;
+                const childRel = rel ? `${rel}/${d.name}` : d.name;
+                if (d.name.toLowerCase().includes(q)) {
+                    results.push({
+                        path: childRel,
+                        name: d.name,
+                        type: d.isDirectory() ? "dir" : "file",
+                    });
+                }
+                if (d.isDirectory()) {
+                    await walk(join(abs, d.name), childRel, depth + 1);
+                }
+            }
+        };
+        try {
+            await walk(root, "", 0);
+            this.host.emit({
+                type: "search_files_result",
+                reqId,
+                ok: true,
+                results,
+                ...(truncated ? { truncated: true } : {}),
+            });
+        }
+        catch {
+            this.host.emit({ type: "search_files_result", reqId, ok: false, results: [] });
+        }
+    }
     /**
      * Source-control panel: read-only git queries via server-side execFile
      * (no shell, no prompts). Always responds with an scm_data message echoing

package/dist/server/index.js

@@ -450,7 +450,7 @@ wss.on("connection", (ws) => {
         // 每份 ~10MB 的全量 snapshot 字符串，低内存主机直接 OOM。snapshot 是全量
         // 幂等的且 60ms 后必有更新的一份，可以安全丢弃——在序列化之前丢，连
         // stringify 的分配都省掉。ready/notice/error/tool_delta 等消息必须送达。
-        if (msg.type === "snapshot" &&
+        if ((msg.type === "snapshot" || msg.type === "snapshot_delta") &&
             ws.bufferedAmount > SNAPSHOT_BACKPRESSURE_BYTES) {
             return;
         }
@@ -499,7 +499,9 @@ wss.on("connection", (ws) => {
                 cs.cycleThinking();
                 break;
             case "get_state":
-                cs.flushSnapshot();
+                // Always a FULL snapshot: the client is (re)connecting or detected
+                // a rev/seq gap — it needs an authoritative state to rebuild from.
+                cs.flushSnapshot(true);
                 break;
             case "get_commands":
                 void cs.pushSlashCommands();
@@ -519,6 +521,9 @@ wss.on("connection", (ws) => {
             case "list_files":
                 void cs.listFiles(msg.path);
                 break;
+            case "search_files":
+                void cs.searchFiles(msg.query, msg.reqId);
+                break;
             case "scm_status":
                 void cs.scmQuery("status", msg.reqId);
                 break;

package/dist/server/process-utils.js

@@ -65,6 +65,32 @@ export function killPidTree(pid) {
         // already dead
     }
 }
+/** Best-effort full command line of a pid (PowerShell CIM on win32 — wmic is
+ *  gone on recent Win11 builds; ps -o command= on POSIX). Returns undefined
+ *  when the process is gone or the lookup fails. */
+export async function lookupProcessCommandLine(pid) {
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            // CIM query is slower (~1s) than tasklist but this is a one-shot
+            // best-effort probe fired once per detected background server.
+            const out = await new Promise((resolve, reject) => execFile("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine`,
+            ], { windowsHide: true, timeout: 10000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            const line = out.trim();
+            return line || undefined;
+        }
+        const out = await new Promise((resolve, reject) => execFile("ps", ["-o", "command=", "-p", String(pid)], { timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+        const line = out.trim();
+        return line || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Best-effort process name for a pid (tasklist on win32, ps on POSIX).
  *  Returns undefined when the process is gone or the lookup fails. */
 export async function lookupProcessName(pid) {

package/dist/server/protocol-version.js

@@ -8,4 +8,4 @@
  * its own copy in web/src/protocol-version.ts; scripts/check-protocol-sync.mjs
  * verifies the two never drift.
  */
-export const PROTOCOL_VERSION = 1;
+export const PROTOCOL_VERSION = 3;