@evandu/super-pi 0.1.106 → 0.1.108

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-DBR_t9lF.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-mo5Dvh_v.css">
+    <script type="module" crossorigin src="/assets/index-CnIOGNIm.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Aa8KN3IB.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/run-service.d.ts

@@ -133,6 +133,16 @@ export declare class RunService {
      * transcript - so a `role: "user"` is never impersonated.
      */
     enqueueExecResult(sessionId: string, exitCode: number, stdout: string, stderr: string): void;
+    /**
+     * Stops an active background task (spawned process or detached subagent) on user request.
+     *
+     * 1. Kills the underlying PTY child process if one exists in `execService`.
+     * 2. If the task originated from a tool call in a conversation transcript, marks the tool
+     *    call as failed with a clear message and broadcasts `message.tools`.
+     * 3. Removes the task from `state.backgroundTasks` and broadcasts `state` so the sidebar
+     *    updates immediately.
+     */
+    stopBackgroundTask(taskId: string): Promise<void>;
     /** Per-conversation command lane.  All queue mutations and run claims use the same lane, so
      * two browser tabs cannot both observe an idle conversation and start duplicate turns. */
     private readonly conversationOps;

package/dist/server/application/run-service.js

@@ -310,6 +310,37 @@ export class RunService {
             }
         })());
     }
+    /**
+     * Stops an active background task (spawned process or detached subagent) on user request.
+     *
+     * 1. Kills the underlying PTY child process if one exists in `execService`.
+     * 2. If the task originated from a tool call in a conversation transcript, marks the tool
+     *    call as failed with a clear message and broadcasts `message.tools`.
+     * 3. Removes the task from `state.backgroundTasks` and broadcasts `state` so the sidebar
+     *    updates immediately.
+     */
+    async stopBackgroundTask(taskId) {
+        const tasks = this.store.snapshot().backgroundTasks ?? [];
+        const task = tasks.find((t) => t.id === taskId);
+        if (this.execService) {
+            try {
+                this.execService.kill(taskId);
+            }
+            catch { /* ignore if already exited */ }
+        }
+        if (task && task.originMessageId !== undefined && task.originCallRow !== undefined) {
+            const conv = this.store.snapshot().conversations.find((c) => c.id === task.conversationId);
+            const msg = conv?.messages.find((m) => m.id === task.originMessageId);
+            if (msg?.toolCalls?.[task.originCallRow]?.backgroundTask) {
+                const toolCalls = await this.store.updateToolCall(task.conversationId, task.originMessageId, task.originCallRow, {
+                    backgroundTask: { id: taskId, status: "failed", output: "已由用户手动终止" },
+                });
+                this.broadcaster.broadcast({ type: "message.tools", conversationId: task.conversationId, messageId: task.originMessageId, toolCalls });
+            }
+        }
+        await this.store.removeBackgroundTask(taskId);
+        this.broadcaster.broadcastState();
+    }
     /** Per-conversation command lane.  All queue mutations and run claims use the same lane, so
      * two browser tabs cannot both observe an idle conversation and start duplicate turns. */
     conversationOps = new Map();

package/dist/server/command-handler.js

@@ -108,6 +108,10 @@ export class CommandHandler {
                 sendToSocket({ type: "providers.list", providers: await this.providerService.list(), apis: [...KNOWN_APIS] });
             return;
         }
+        if (command.type === "backgroundTask.stop") {
+            await this.runService.stopBackgroundTask(command.taskId);
+            return;
+        }
         if (command.type === "workspace.create") {
             return await this.workspaceService.createWorkspace(command.name, command.path);
         }

package/dist/server/content-search.d.ts

@@ -22,11 +22,21 @@ export type ContentSearchResult = {
     complete: boolean;
     reasons: string[];
 };
-/**
- * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
- * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
- * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
- * Instead give it one verified indexed file at a time; validate again before publishing any hit.
- * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
- */
-export declare function searchByContent(root: string, candidates: readonly ContentSearchCandidate[], query: string, indexStatus?: Pick<FileIndexSnapshot, "complete" | "skipped">): Promise<ContentSearchResult>;
+type RipgrepMatch = {
+    path: string;
+    line: number;
+    text: string;
+};
+type RipgrepRun = (input: {
+    rgPath: string;
+    pattern: string;
+    paths: string[];
+    signal: AbortSignal;
+    onMatch: (match: RipgrepMatch) => Promise<boolean>;
+}) => Promise<void>;
+export type ContentSearchOptions = {
+    resolveRipgrep?: () => Promise<string | undefined>;
+    runRipgrep?: RipgrepRun;
+};
+export declare function searchByContent(root: string, candidates: readonly ContentSearchCandidate[], query: string, indexStatus?: Pick<FileIndexSnapshot, "complete" | "skipped">, options?: ContentSearchOptions): Promise<ContentSearchResult>;
+export {};

package/dist/server/content-search.js

@@ -1,152 +1,249 @@
-import { open } from "node:fs/promises";
-import { basename } from "node:path";
-import { createGrepTool } from "@earendil-works/pi-coding-agent";
-import { isTextName, looksBinary, resolveInsideRoot } from "./files.js";
+import { spawn } from "node:child_process";
+import { open, stat } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { FilesError, createRootGuard, isTextName, looksBinary, toRelative } from "./files.js";
 export const MAX_CONTENT_RESULTS = 500;
 export const MAX_CONTENT_FILE_BYTES = 512 * 1024;
 export const MAX_CONTENT_DEPTH = 12;
 export const MAX_CONTENT_MS = 10000;
+let sdkRipgrep;
+/** Pi's public package export hides this helper; resolve the installed module used by createGrepTool. */
+async function resolveSdkRipgrep() {
+    sdkRipgrep ??= (async () => {
+        const entry = fileURLToPath(await import.meta.resolve("@earendil-works/pi-coding-agent"));
+        const manager = await import(pathToFileURL(join(dirname(entry), "utils", "tools-manager.js")).href);
+        return manager.getToolPath("rg") ?? manager.ensureTool("rg");
+    })();
+    return sdkRipgrep;
+}
+function normalizeLine(text) { return text.endsWith("\r\n") ? text.slice(0, -2) : text.endsWith("\n") ? text.slice(0, -1) : text; }
 /**
- * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
- * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
- * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
- * Instead give it one verified indexed file at a time; validate again before publishing any hit.
- * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
+ * One rg process for all indexed files. createGrepTool is deliberately not used: its path accepts only
+ * one directory/file and glob cannot express this arbitrary index set, so it would walk a second tree or
+ * spawn once per file. Matching still uses the SDK's exact ensureTool/getToolPath-selected ripgrep.
+ * The installed rg has no --files-from flag, so verified absolute candidates are passed as paths.
  */
-export async function searchByContent(root, candidates, query, indexStatus = { complete: true, skipped: [] }) {
-    await resolveInsideRoot(root, "");
+const runRipgrep = ({ rgPath, pattern, paths, signal, onMatch }) => new Promise((resolve, reject) => {
+    const child = spawn(rgPath, ["--json", "--line-number", "--color=never", "--hidden", "--no-ignore", "--text", "--fixed-strings", "--", pattern, ...paths], { stdio: ["ignore", "pipe", "pipe"], shell: false, windowsHide: true });
+    let stdout = "";
+    let stderr = "";
+    let chain = Promise.resolve(true);
+    let stopped = false;
+    const stop = () => { if (!stopped) {
+        stopped = true;
+        child.kill();
+    } };
+    const onAbort = () => stop();
+    signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        let newline;
+        while ((newline = stdout.indexOf("\n")) >= 0) {
+            const row = stdout.slice(0, newline);
+            stdout = stdout.slice(newline + 1);
+            chain = chain.then(async (continueSearch) => {
+                if (!continueSearch)
+                    return false;
+                let event;
+                try {
+                    event = JSON.parse(row);
+                }
+                catch {
+                    return true;
+                }
+                if (event.type !== "match")
+                    return true;
+                const path = event.data?.path?.text;
+                const line = event.data?.line_number;
+                const text = event.data?.lines?.text;
+                if (!path || !Number.isSafeInteger(line))
+                    return true;
+                const keepGoing = await onMatch({ path, line: line, text: typeof text === "string" ? normalizeLine(text) : "" });
+                if (!keepGoing)
+                    stop();
+                return keepGoing;
+            });
+            chain.catch(() => { });
+        }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.on("error", (error) => { signal.removeEventListener("abort", onAbort); reject(new Error(`Failed to run ripgrep: ${error.message}`)); });
+    child.on("close", (code) => {
+        signal.removeEventListener("abort", onAbort);
+        void chain.then(() => {
+            if (signal.aborted || stopped || code === 0 || code === 1)
+                resolve();
+            else
+                reject(new Error(`ripgrep failed (${code}): ${stderr.trim() || "unknown error"}`));
+        }, reject);
+    });
+});
+async function checkedTextFile(absolute) {
+    try {
+        const info = await stat(absolute);
+        if (!info.isFile())
+            return "skip";
+        if (info.size > MAX_CONTENT_FILE_BYTES)
+            return "size";
+        const handle = await open(absolute, "r");
+        try {
+            const buffer = Buffer.alloc(MAX_CONTENT_FILE_BYTES + 1);
+            let length = 0;
+            while (length < buffer.length) {
+                const read = await handle.read(buffer, length, buffer.length - length, null);
+                if (!read.bytesRead)
+                    break;
+                length += read.bytesRead;
+            }
+            if (length > MAX_CONTENT_FILE_BYTES)
+                return "size";
+            const bytes = buffer.subarray(0, length);
+            if (looksBinary(bytes) || bytes.includes(0))
+                return "skip";
+            new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+            return "text";
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return "skip";
+    }
+}
+async function checkedFileSize(absolute) {
+    try {
+        const info = await stat(absolute);
+        return !info.isFile() ? "skip" : info.size > MAX_CONTENT_FILE_BYTES ? "size" : "ok";
+    }
+    catch {
+        return "skip";
+    }
+}
+function needsContainmentCheck(path) {
+    return /(^|[\\/])\.\.([\\/]|$)|^[\\/]|^[A-Za-z]:/.test(path);
+}
+async function mapConcurrently(items, limit, fn) {
+    const output = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            output[index] = await fn(items[index]);
+        }
+    }));
+    return output;
+}
+export async function searchByContent(root, candidates, query, indexStatus = { complete: true, skipped: [] }, options = {}) {
+    const guard = createRootGuard(root);
+    await guard("");
     const hits = [];
     const skipped = new Set(indexStatus.skipped);
     const reasons = new Set(indexStatus.complete ? [] : ["index"]);
     const needle = query.trim();
     if (!needle)
         return { hits, truncated: false, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
-    const tool = createGrepTool(root);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), MAX_CONTENT_MS);
+    const paths = [];
+    const candidateByPath = new Map();
+    const eligible = [];
+    for (const candidate of candidates) {
+        if (controller.signal.aborted) {
+            reasons.add("time");
+            break;
+        }
+        if (candidate.kind !== "file")
+            continue;
+        if (candidate.path.replace(/\\/g, "/").split("/").length - 1 > MAX_CONTENT_DEPTH) {
+            skipped.add(candidate.path);
+            reasons.add("depth");
+            continue;
+        }
+        if (candidate.text === false || !isTextName(candidate.path)) {
+            skipped.add(candidate.path);
+            continue;
+        }
+        if (candidate.size !== null && candidate.size > MAX_CONTENT_FILE_BYTES) {
+            skipped.add(candidate.path);
+            reasons.add("size");
+            continue;
+        }
+        // Index paths are normalized and symlink-free. Reject any shape that could escape before creating an
+        // rg argument; all output still takes the full shared containment path below before it is published.
+        if (needsContainmentCheck(candidate.path)) {
+            await guard(candidate.path);
+        }
+        eligible.push(candidate);
+    }
+    // Do bounded metadata checks concurrently. rg's binary heuristic cannot prove strict UTF-8, so matching
+    // files get the full byte check below; output passes the shared containment guard before publication.
+    const checkedCandidates = await mapConcurrently(eligible, 96, async (candidate) => ({ candidate, absolute: join(root, candidate.path), classification: await checkedFileSize(join(root, candidate.path)) }));
+    for (const { candidate, absolute, classification } of checkedCandidates) {
+        if (controller.signal.aborted) {
+            reasons.add("time");
+            break;
+        }
+        if (classification !== "ok") {
+            skipped.add(candidate.path);
+            if (classification === "size")
+                reasons.add("size");
+            continue;
+        }
+        paths.push(absolute);
+        candidateByPath.set(candidate.path, candidate);
+    }
     try {
-        for (const candidate of candidates) {
-            if (candidate.kind !== "file")
-                continue;
-            if (controller.signal.aborted) {
-                reasons.add("time");
-                break;
-            }
-            // Validate even an excluded candidate: metadata and cached paths are not a security boundary.
-            let absolute;
-            try {
-                absolute = await resolveInsideRoot(root, candidate.path);
-            }
-            catch (error) {
-                const code = error.code;
-                if (code === "outside_workspace" || code === "bad_path" || code === "workspace_missing")
-                    throw error;
-                skipped.add(candidate.path);
-                reasons.add("unreadable");
-                continue;
-            }
-            if (candidate.path.replace(/\\/g, "/").split("/").length - 1 > MAX_CONTENT_DEPTH) {
-                skipped.add(candidate.path);
-                reasons.add("depth");
-                continue;
-            }
-            if (candidate.text === false || !isTextName(candidate.path)) {
-                skipped.add(candidate.path);
-                continue;
-            }
-            let bytes;
-            try {
-                // Read at most cap+1 bytes even if a file grows after stat; never allocate its untrusted size.
-                const handle = await open(absolute, "r");
+        if (controller.signal.aborted)
+            return { hits, truncated: true, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
+        const rgPath = await (options.resolveRipgrep ?? resolveSdkRipgrep)();
+        if (!rgPath)
+            throw new FilesError(503, "内容搜索不可用（ripgrep 不可用）", "ripgrep_unavailable");
+        await (options.runRipgrep ?? runRipgrep)({ rgPath, pattern: needle, paths, signal: controller.signal, onMatch: async (match) => {
+                if (controller.signal.aborted) {
+                    reasons.add("time");
+                    return false;
+                }
+                let path;
+                let absolute;
                 try {
-                    const info = await handle.stat();
-                    if (!info.isFile()) {
-                        skipped.add(candidate.path);
-                        reasons.add("unreadable");
-                        continue;
-                    }
-                    if (info.size > MAX_CONTENT_FILE_BYTES) {
-                        skipped.add(candidate.path);
-                        reasons.add("size");
-                        continue;
-                    }
-                    const buffer = Buffer.alloc(MAX_CONTENT_FILE_BYTES + 1);
-                    let length = 0;
-                    while (length < buffer.length) {
-                        const read = await handle.read(buffer, length, buffer.length - length, null);
-                        if (!read.bytesRead)
-                            break;
-                        length += read.bytesRead;
-                    }
-                    if (length > MAX_CONTENT_FILE_BYTES) {
-                        skipped.add(candidate.path);
-                        reasons.add("size");
-                        continue;
-                    }
-                    bytes = buffer.subarray(0, length);
+                    path = toRelative(root, match.path);
+                    absolute = await guard(path);
                 }
-                finally {
-                    await handle.close();
+                catch (error) {
+                    const code = error.code;
+                    if (code === "outside_workspace" || code === "bad_path" || code === "workspace_missing")
+                        throw error;
+                    skipped.add(match.path);
+                    reasons.add("unreadable");
+                    return true;
                 }
-            }
-            catch {
-                skipped.add(candidate.path);
-                reasons.add("unreadable");
-                continue;
-            }
-            if (looksBinary(bytes) || bytes.includes(0)) {
-                skipped.add(candidate.path);
-                continue;
-            }
-            try {
-                new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-            }
-            catch {
-                skipped.add(candidate.path);
-                continue;
-            }
-            let result;
-            try {
-                result = await tool.execute("content-search", {
-                    pattern: needle, path: absolute, literal: true, limit: MAX_CONTENT_RESULTS - hits.length,
-                }, controller.signal);
-            }
-            catch (error) {
-                if (controller.signal.aborted) {
-                    reasons.add("time");
-                    break;
+                if (!candidateByPath.has(path)) {
+                    skipped.add(path);
+                    reasons.add("unreadable");
+                    return true;
                 }
-                // SDK/ripgrep failures are request failures, never a successful empty search.
-                throw error;
-            }
-            const prefix = basename(absolute) + ":";
-            const rows = [];
-            for (const block of result.content) {
-                if (block.type !== "text")
-                    continue;
-                for (const row of block.text.split("\n")) {
-                    if (!row.startsWith(prefix))
-                        continue;
-                    const match = /^(\d+): (.*)$/.exec(row.slice(prefix.length));
-                    if (!match)
-                        continue;
-                    rows.push({ path: candidate.path, name: basename(absolute), line: Number(match[1]), text: match[2] });
+                const classification = await checkedTextFile(absolute);
+                if (classification !== "text") {
+                    skipped.add(path);
+                    if (classification === "size")
+                        reasons.add("size");
+                    return true;
                 }
-            }
-            if (rows.length) {
-                await resolveInsideRoot(root, candidate.path);
-                hits.push(...rows.slice(0, MAX_CONTENT_RESULTS - hits.length));
-            }
-            const details = result.details;
-            if (details?.truncation?.truncated)
-                reasons.add("output");
-            if (details?.linesTruncated)
-                reasons.add("line");
-            if (details?.matchLimitReached || hits.length >= MAX_CONTENT_RESULTS) {
-                reasons.add("results");
-                break;
-            }
-        }
+                hits.push({ path, name: basename(absolute), line: match.line, text: match.text });
+                if (hits.length >= MAX_CONTENT_RESULTS) {
+                    reasons.add("results");
+                    return false;
+                }
+                return true;
+            } });
+        if (controller.signal.aborted)
+            reasons.add("time");
     }
     finally {
         clearTimeout(timer);

package/dist/server/index.js

@@ -283,6 +283,8 @@ async function shutdown(reason) {
         // The capabilities die AFTER the sessions that carry them: a session that is still alive could
         // otherwise use a credential the server has already forgotten about.
         releaseAllCapabilities();
+        // Clean up background tasks so the flushed state never freezes running zombies on disk.
+        await store.clearBackgroundTasks();
         await store.flush();
         wsServer.close();
         httpServer.closeAllConnections();

package/dist/server/store.d.ts

@@ -647,6 +647,7 @@ export declare class Store {
     setWorkflow(plan: WorkflowRun): Promise<WorkflowRun>;
     setBackgroundTask(summary: AppState["backgroundTasks"][number]): Promise<void>;
     removeBackgroundTask(id: string): Promise<void>;
+    clearBackgroundTasks(): Promise<void>;
     /**
      * Applies the fields a run's life can change, and nothing else.
      *

package/dist/server/store.js

@@ -498,6 +498,59 @@ function reconcileTodos(state) {
     const after = JSON.stringify({ todos: state.todos, todosByConversation: state.todosByConversation });
     return { changed: before !== after };
 }
+/**
+ * Startup reconciliation: cleans up background tasks left over from previous server process.
+ *
+ * `backgroundTasks` is a LIFECYCLE collection: it tracks active in-flight executions (pty child
+ * processes or detached subagents) and is emptied as each task settles. When a server restarts,
+ * those processes are dead and cannot report their completion. Leaving them in `backgroundTasks`
+ * creates permanent "zombies" in the main sidebar that can never be dismissed.
+ *
+ * If a task originated from a tool call in a conversation, its tool call block is marked as failed
+ * so the chat transcript accurately reflects that the task was interrupted by server restart.
+ *
+ * WHY ONLY THE LINKED ONES ARE SWEPT, and not every entry in the list.
+ *
+ * A task is created by exactly one route: the `/api/exec` endpoint, and that endpoint REQUIRES a
+ * `conversationId` (it is what the capability check and the tool-call anchor are resolved against).
+ * So every task this server ever creates is linked to a conversation's tool call, and every one of
+ * those is swept here - the zombie problem is fully covered.
+ *
+ * A task with NO conversation anchor is a shape this server cannot produce. The sweep cannot account
+ * for it either: there is no tool call to mark failed, so there is nothing to tell the reader that
+ * the task died. Deleting it would remove a record without replacing it with an explanation, which is
+ * the one outcome worse than a stale entry. So those are LEFT ALONE, and this function says so in its
+ * return value rather than silently keeping them.
+ */
+function reconcileBackgroundTasks(state) {
+    const tasks = Array.isArray(state.backgroundTasks) ? state.backgroundTasks : [];
+    state.backgroundTasks = [];
+    if (!tasks.length)
+        return { orphaned: [], changed: false, unlinked: [] };
+    const orphaned = [];
+    const unlinked = [];
+    for (const task of tasks) {
+        if (!task)
+            continue;
+        // The three fields are destructured rather than tested through a boolean, because a boolean does not
+        // narrow their types and `toolCalls[undefined]` is not an index.
+        const { conversationId, originMessageId, originCallRow } = task;
+        if (!conversationId || originMessageId === undefined || originCallRow === undefined) {
+            unlinked.push(task);
+            state.backgroundTasks.push(task);
+            continue;
+        }
+        orphaned.push(task);
+        const conv = state.conversations?.find((c) => c?.id === conversationId);
+        const msg = conv?.messages?.find((m) => m?.id === originMessageId);
+        const call = msg?.toolCalls?.[originCallRow];
+        if (call?.backgroundTask && call.backgroundTask.status === "running") {
+            call.backgroundTask.status = "failed";
+            call.backgroundTask.output = "任务随服务重启被终止";
+        }
+    }
+    return { orphaned, changed: orphaned.length > 0, unlinked };
+}
 export class Store {
     repository;
     state;
@@ -531,6 +584,7 @@ export class Store {
             // and the other was not - a half-repaired state that still needs a second restart to finish.
             const orphaned = reconcileSubagentRuns(state);
             const orphanedWorkflows = reconcileWorkflows(state);
+            const orphanedTasks = reconcileBackgroundTasks(state);
             const interrupted = reconcileConversations(state);
             const requeued = reconcileWaitingMessages(state);
             const todos = reconcileTodos(state);
@@ -538,11 +592,19 @@ export class Store {
             // Persisted here, in `open`, rather than left for the first unrelated write: a reconciled record that
             // is only rewritten by a later mutation would still read `running` to anything that opened the file
             // in the meantime, and would be reconciled a SECOND time on the next restart.
-            if (defaulted || orphaned.length || orphanedWorkflows.length || interrupted.length || requeued.recovered.length || requeued.changed || todos.changed) {
+            if (defaulted || orphaned.length || orphanedWorkflows.length || orphanedTasks.changed || interrupted.length || requeued.recovered.length || requeued.changed || todos.changed) {
                 for (const run of orphaned)
                     console.warn(`Super Pi: sub-agent run ${run.id} was still marked running when the last server stopped - it is now failed, because no child process survived it.`);
                 for (const plan of orphanedWorkflows)
                     console.warn(`Super Pi: workflow ${plan.id} was still marked running when the last server stopped - it is now stopped, because no step can still be executing.`);
+                for (const task of orphanedTasks.orphaned)
+                    console.warn(`Super Pi: background task ${task.id} (${task.title}) was left in flight when the last server stopped - it has been cleaned up.`);
+                // The unlinked ones are said out loud rather than swept silently. They cannot come from this
+                // server - `/api/exec` requires a conversationId - so they are a hand-written or legacy entry,
+                // and the reader is told they were left alone instead of wondering why one task vanished and
+                // another did not.
+                for (const task of orphanedTasks.unlinked)
+                    console.warn(`Super Pi: background task ${task.id} (${task.title}) has no conversation to be traced back to - it was left in place, because there is no tool call to mark as interrupted.`);
                 // Announced for the same reason: a conversation that failed while nobody was watching is invisible
                 // otherwise, and the user who was watching a spinner when the server died deserves to learn that
                 // their run is over rather than guessing from the fact that it stopped moving.
@@ -1825,6 +1887,12 @@ export class Store {
         this.state.backgroundTasks = this.state.backgroundTasks.filter((item) => item.id !== id);
         await this.persistCollections("backgroundTasks");
     }
+    async clearBackgroundTasks() {
+        if (!this.state.backgroundTasks.length)
+            return;
+        this.state.backgroundTasks = [];
+        await this.persistCollections("backgroundTasks");
+    }
     /**
      * Applies the fields a run's life can change, and nothing else.
      *

package/dist/server/types.d.ts

@@ -945,6 +945,17 @@ export type ClientCommandBody =
  | {
     type: "providers.fetch";
 }
+/**
+ * Stops and removes an active background task (spawned process or background subagent).
+ *
+ * If the task has a live pty child process, it is killed. If it originated from a tool call in
+ * a conversation, that call is marked as stopped/failed in the transcript so the user sees a
+ * settled outcome instead of a permanent spinner. The task is then removed from `backgroundTasks`.
+ */
+ | {
+    type: "backgroundTask.stop";
+    taskId: string;
+}
 /**
  * Sets the app-wide default model. `null` clears it back to "Pi's own default" - the same
  * "absence, not a frozen copy" convention the workspace defaults use, so removing the default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.106",
+  "version": "0.1.108",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -92,6 +92,9 @@
     "scripts/file-content-search.test.mjs",
     "scripts/file-diff-client.test.mjs",
     "scripts/task-tool.test.mjs",
+    "scripts/tool-register-env.test.mjs",
+    "scripts/bg-task-zombie.test.mjs",
+    "scripts/scoped-sidebar-tabs.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",