@evandu/super-pi 0.1.105 → 0.1.107

package/dist/server/git.d.ts

@@ -35,3 +35,20 @@ export declare function gitDiff(root: string, path: string, staged: boolean): Pr
     diff: string;
     kind: "text";
 }>;
+/**
+ * The content of a file AS IT WAS COMMITTED, or `null` when there is no such version.
+ *
+ * WHY THIS EXISTS ALONGSIDE `gitDiff`. `gitDiff` answers "what changed relative to HEAD" as a PATCH -
+ * which is a good thing to read and a bad thing to diff against: a patch is a set of hunks, and
+ * reconstructing the "before" text from it is a lossy operation that a review view should not depend on.
+ * The review view needs the two TEXTS, so that the difference between them is computed by one
+ * well-tested algorithm rather than by two different ones.
+ *
+ * `null` covers three different situations, and the caller must not confuse them: the repository has no
+ * commits yet (`unborn`), the file was never committed (it is new or untracked), or the file is not in
+ * this repository at all. The first two are the same answer for a review - "there is no committed
+ * version to compare against" - and the third is a refusal, which the caller reports.
+ */
+export declare function gitHeadContent(root: string, path: string): Promise<string | null>;
+/** Whether the directory is a git repository at all. The review view asks before it offers a git baseline. */
+export declare function isGitRepository(root: string): Promise<boolean>;

package/dist/server/git.js

@@ -28,3 +28,42 @@ export async function gitLog(root, limit) { const hasHead = await git(root, ["re
 export async function gitDiff(root, path, staged) { const safe = resolve(root, path); if (!safe.startsWith(resolve(root) + sep) || !existsSync(safe))
     throw Object.assign(new Error("文件路径无效"), { code: "path" }); const check = await git(root, ["ls-files", "--error-unmatch", "--", path]).then(() => true).catch(() => false); if (!check)
     return { path, staged, diff: null, kind: "untracked" }; const out = await git(root, ["diff", ...(staged ? ["--cached"] : []), "--", path]); return { path, staged, diff: out.stdout, kind: "text" }; }
+/**
+ * The content of a file AS IT WAS COMMITTED, or `null` when there is no such version.
+ *
+ * WHY THIS EXISTS ALONGSIDE `gitDiff`. `gitDiff` answers "what changed relative to HEAD" as a PATCH -
+ * which is a good thing to read and a bad thing to diff against: a patch is a set of hunks, and
+ * reconstructing the "before" text from it is a lossy operation that a review view should not depend on.
+ * The review view needs the two TEXTS, so that the difference between them is computed by one
+ * well-tested algorithm rather than by two different ones.
+ *
+ * `null` covers three different situations, and the caller must not confuse them: the repository has no
+ * commits yet (`unborn`), the file was never committed (it is new or untracked), or the file is not in
+ * this repository at all. The first two are the same answer for a review - "there is no committed
+ * version to compare against" - and the third is a refusal, which the caller reports.
+ */
+export async function gitHeadContent(root, path) {
+    const safe = resolve(root, path);
+    if (!safe.startsWith(resolve(root) + sep))
+        throw Object.assign(new Error("文件路径无效"), { code: "path" });
+    const hasHead = await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false);
+    if (!hasHead)
+        return null;
+    const tracked = await git(root, ["ls-files", "--error-unmatch", "--", path]).then(() => true).catch(() => false);
+    if (!tracked)
+        return null;
+    try {
+        const out = await git(root, ["show", `HEAD:${path}`]);
+        return out.stdout;
+    }
+    catch {
+        // The file is tracked but `HEAD:path` does not resolve - a path with characters git quotes, or a
+        // repository in a state this server does not model. Treated as "no committed version", which is the
+        // honest answer rather than a crash.
+        return null;
+    }
+}
+/** Whether the directory is a git repository at all. The review view asks before it offers a git baseline. */
+export async function isGitRepository(root) {
+    return git(root, ["rev-parse", "--git-dir"]).then(() => true).catch(() => false);
+}

package/dist/server/http-server.js

@@ -8,9 +8,12 @@ import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
 import { gitDiff, gitLog, gitStatus } from "./git.js";
+import { computeFileDiff } from "./file-diff.js";
 import { MAX_KNOWLEDGE_REQUEST_BYTES } from "./knowledge.js";
 import { MAX_TOOL_BODY_BYTES } from "./tool-registry.js";
 import { packageUpdateArgs } from "./update.js";
+import { FileIndex } from "./file-index.js";
+import { MAX_CONTENT_DEPTH, MAX_CONTENT_FILE_BYTES, MAX_CONTENT_RESULTS, searchByContent } from "./content-search.js";
 const MIME_TYPES = {
     ".css": "text/css; charset=utf-8",
     ".html": "text/html; charset=utf-8",
@@ -952,6 +955,118 @@ export function createHttpServer(options) {
             }
             return;
         }
+        if (url.pathname === "/api/files/diff") {
+            const json = (status, body) => {
+                response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
+            };
+            try {
+                const workspaceId = url.searchParams.get("workspaceId")?.trim();
+                const workspace = store.snapshot().workspaces.find((item) => item.id === workspaceId);
+                if (!workspaceId || !workspace) {
+                    json(404, { error: `Workspace ${workspaceId ?? "(missing)"} not found`, code: "no_workspace" });
+                    return;
+                }
+                const path = url.searchParams.get("path")?.trim() ?? "";
+                if (!path) {
+                    json(400, { error: "需要 path 参数", code: "bad_request" });
+                    return;
+                }
+                const requested = url.searchParams.get("base")?.trim();
+                const preferred = requested === "git" || requested === "agent" ? requested : "auto";
+                // The baseline is chosen by the server, but the client can name one - and when it names one, that
+                // is the one it gets. A silent fall-back would show the user a comparison they did not ask for.
+                const diff = await computeFileDiff({
+                    root: workspace.path,
+                    path,
+                    preferred,
+                    tracker: context.fileChanges,
+                    workspaceId,
+                });
+                json(200, diff);
+            }
+            catch (error) {
+                const described = describeFilesError(error);
+                json(described.status, described.body);
+            }
+            return;
+        }
+        if (url.pathname === "/api/files/search") {
+            const json = (status, body) => { response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body)); };
+            try {
+                if (request.method !== "GET") {
+                    json(405, { error: "Content search requires GET", code: "method" });
+                    return;
+                }
+                const workspaceId = url.searchParams.get("workspaceId")?.trim();
+                const query = url.searchParams.get("q")?.trim() ?? "";
+                const workspace = store.snapshot().workspaces.find((item) => item.id === workspaceId);
+                if (!workspaceId || !workspace) {
+                    json(404, { error: "workspace not found", code: "no_workspace" });
+                    return;
+                }
+                await resolveInsideRoot(workspace.path, "");
+                if (query.length > 256 || /[\r\n]/.test(query)) {
+                    json(400, { error: "Search query must be one line, at most 256 characters", code: "bad_query" });
+                    return;
+                }
+                if (!query) {
+                    json(200, { mode: "content", query, hits: [], truncated: false, skipped: [], complete: true, reasons: [], maxResults: MAX_CONTENT_RESULTS, maxFileBytes: MAX_CONTENT_FILE_BYTES, maxDepth: MAX_CONTENT_DEPTH });
+                    return;
+                }
+                const indexes = context.fileIndexes ?? new Map();
+                if (!context.fileIndexes)
+                    context.fileIndexes = indexes;
+                let index = indexes.get(workspaceId);
+                if (!index) {
+                    index = new FileIndex(workspaceId, (event) => broadcaster.broadcast(event));
+                    indexes.set(workspaceId, index);
+                }
+                index.start(workspace.path);
+                const deadline = Date.now() + 4500;
+                while (!index.builtAt && Date.now() < deadline)
+                    await new Promise((resolve) => setTimeout(resolve, 25));
+                const snapshot = index.snapshot();
+                const result = await searchByContent(workspace.path, [...index.entries.values()], query, snapshot);
+                json(200, { mode: "content", query, ...result, maxResults: MAX_CONTENT_RESULTS, maxFileBytes: MAX_CONTENT_FILE_BYTES, maxDepth: MAX_CONTENT_DEPTH });
+            }
+            catch (error) {
+                const described = describeFilesError(error);
+                json(described.status, described.body);
+            }
+            return;
+        }
+        if (url.pathname === "/api/files/index") {
+            const json = (status, body) => { response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body)); };
+            try {
+                if (request.method !== "GET") {
+                    json(405, { error: "File index requires GET", code: "method" });
+                    return;
+                }
+                const workspaceId = url.searchParams.get("workspaceId")?.trim();
+                const workspace = store.snapshot().workspaces.find((item) => item.id === workspaceId);
+                if (!workspaceId || !workspace) {
+                    json(404, { error: `Workspace ${workspaceId ?? "(missing)"} not found`, code: "no_workspace" });
+                    return;
+                }
+                const indexes = context.fileIndexes ?? new Map();
+                if (!context.fileIndexes)
+                    context.fileIndexes = indexes;
+                let index = indexes.get(workspaceId);
+                if (!index) {
+                    index = new FileIndex(workspaceId, (event) => broadcaster.broadcast(event));
+                    indexes.set(workspaceId, index);
+                }
+                index.start(workspace.path);
+                const sinceRaw = url.searchParams.get("since");
+                const since = sinceRaw === null ? undefined : Number(sinceRaw);
+                json(200, index.snapshot(Number.isSafeInteger(since) && since >= 0 ? since : undefined));
+            }
+            catch (error) {
+                const described = describeFilesError(error);
+                json(described.status, described.body);
+            }
+            return;
+        }
         if (url.pathname === "/api/files" || url.pathname === "/api/file") {
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
@@ -983,10 +1098,14 @@ export function createHttpServer(options) {
                     const rel = url.searchParams.get("path") ?? "";
                     if (url.searchParams.get("meta") === "1") {
                         const resolved = await resolveInsideRoot(root, rel);
-                        json(200, { path: toRelative(root, resolved), ...(await fileMeta(resolved)) });
+                        const meta = await fileMeta(resolved);
+                        const path = toRelative(root, resolved);
+                        context.fileIndexes?.get(workspaceId)?.recordFile(path, meta);
+                        json(200, { path, ...meta });
                         return;
                     }
                     const file = await readWorkspaceFile(root, rel);
+                    context.fileIndexes?.get(workspaceId)?.recordFile(file.path, file.meta);
                     json(200, { path: file.path, content: file.content, eol: file.eol, bom: file.bom, meta: file.meta, maxBytes: MAX_FILE_BYTES });
                     return;
                 }
@@ -1018,6 +1137,7 @@ export function createHttpServer(options) {
                         return;
                     }
                     const outcome = await writeWorkspaceFile(root, parsed.path, parsed.content, parsed.baseEtag);
+                    context.fileIndexes?.get(workspaceId)?.recordFile(outcome.path, outcome.meta);
                     json(200, outcome);
                     return;
                 }

package/dist/server/index.js

@@ -19,6 +19,7 @@ import { CatalogService } from "./application/catalog-service.js";
 import { ProviderService } from "./application/provider-service.js";
 import { ProviderRegistry } from "./providers.js";
 import { RunService } from "./application/run-service.js";
+import { FileChangeTracker } from "./file-changes.js";
 import { ConversationService } from "./application/conversation-service.js";
 import { WorkspaceService } from "./application/workspace-service.js";
 import { CommandHandler } from "./command-handler.js";
@@ -191,6 +192,18 @@ const providerRegistry = new ProviderRegistry(dataDir);
 const providerService = new ProviderService(providerRegistry, runtime, broadcaster, catalogService, store);
 const runService = new RunService(store, runtime, subagents, broadcaster, extensionUiService, initialAgentDirs, workflows);
 runService.setMemory(memory);
+/**
+ * WHAT THE AGENT CHANGED, and what each file looked like before.
+ *
+ * The tracker is created here rather than inside the service because it outlives one run: the changes a
+ * session produced are the session's record, and a tracker that died with the run would take the answer
+ * to "what did you just change" with it. It is handed to the run service as a setter, the same shape
+ * `memory` uses.
+ */
+const fileChanges = new FileChangeTracker();
+runService.setFileChanges(fileChanges);
+const fileIndexes = new Map();
+runService.setFileIndexes(fileIndexes);
 const conversationService = new ConversationService(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 conversationService.setMemory(memory);
 const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, initialAgentDirs);
@@ -232,6 +245,8 @@ const serverContext = {
     toolRegistry,
     toolRunner,
     toolLlm,
+    fileChanges,
+    fileIndexes,
     terminalEnabled: () => terminalService.enabled,
     terminalDisabledReason: () => terminalDisabledReason(),
 };
@@ -268,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/pi-session-events.d.ts

@@ -60,6 +60,15 @@ export type TurnItem =
 /** The callbacks a turn supplies. The names match the RPC runtime's, so the two paths behave alike. */
 export interface TurnEventHandlers {
     onToolCall?(call: ToolCallNotice): void;
+    /**
+     * Called when a tool that WRITES A FILE is announced, with the path it is about to write.
+     *
+     * The same hook the RPC runtime has, and for the same reason: the announcement is the last moment
+     * the old content is still on the disk, so it is the only moment a diff baseline can be taken. The two
+     * paths (SDK session and spawned RPC) must agree on WHEN this fires, or the same edit would be
+     * baselined on one path and not on the other.
+     */
+    onFileWrite?(path: string, toolName: string, toolCallId?: string): void;
     onToolUpdate?(call: ToolCallNotice): void;
     onToolPreparing?(call: ToolCallPreparing): void;
     onToolEnd?(call: ToolCallNotice): void;

package/dist/server/pi-session-events.js

@@ -17,6 +17,7 @@
  * from, not what they mean.
  */
 import { describeToolCall, describeToolCallArgs, extractPartialResultText } from "./tool-calls.js";
+import { toolTargetPath } from "./file-changes.js";
 /** Keeps only real strings, so a malformed queue snapshot cannot put objects into a broadcast. */
 const textList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
 /**
@@ -258,6 +259,17 @@ export function handleSessionEvent(event, queue, handlers, report, failure) {
             catch (error) {
                 console.warn(`PiRpcRuntime: the tool call handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
             }
+            // The file-writing call, announced before it runs - the only moment the old content is still on
+            // the disk. Fired and forgotten: the listener does its own I/O, off this handler's path.
+            const writePath = toolTargetPath(name, record.args);
+            if (writePath) {
+                try {
+                    handlers.onFileWrite?.(writePath, name, id);
+                }
+                catch (error) {
+                    console.warn(`PiRpcRuntime: the file-write handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
+                }
+            }
             return true;
         }
         case "tool_execution_update": {

package/dist/server/runtime.d.ts

@@ -115,6 +115,28 @@ export interface AnswerInput {
      * on a card but by its working directory on a call block would be worse than having neither.
      */
     onToolCall?(call: ToolCallNotice): void;
+    /**
+     * Called when a tool that WRITES A FILE is announced, with the path it is about to write.
+     *
+     * WHY A SEPARATE CALLBACK RATHER THAN A FIELD ON `onToolCall`. Two reasons, and the second is the
+     * load-bearing one.
+     *
+     * The first: this is a fact about the FILESYSTEM, not about the transcript. The transcript's row for
+     * an `edit` is a card; this is the server learning that a file on disk is about to change, and the
+     * listener for it has to act BEFORE the change - which is the only moment the old content is still on
+     * the disk. A card that arrives after the fact is too late to be a baseline.
+     *
+     * The second: the listener's job is to capture the file's previous content, which means reading the
+     * disk, and that must not happen on the path that draws a card. `onToolCall` is called synchronously
+     * in the drain loop, between yields, and a disk read there would put an I/O stall in the middle of
+     * the stream - the latency the streaming lane exists to avoid. So this callback is fired and FORGOTTEN:
+     * the listener does its work on its own time and the drain loop moves on.
+     *
+     * The path is the tool's own spelling, resolved against the workspace by the listener - the runtime
+     * does not know which workspace a call belongs to, and a path it cannot check is a path it does not
+     * vouch for.
+     */
+    onFileWrite?(path: string, toolName: string, toolCallId?: string): void;
     /**
      * Called on `tool_execution_end` for the same `id`, carrying how the call ended.
      *

package/dist/server/runtime.js

@@ -22,6 +22,7 @@ import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_END
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
+import { toolTargetPath } from "./file-changes.js";
 const traceLatency = (conversationId, phase, startedAt, extra = "") => {
     if (process.env.SUPER_PI_TRACE_LATENCY !== "1")
         return;
@@ -730,6 +731,7 @@ export class PiRpcRuntime {
         const queue = new TurnQueue();
         const handlers = {
             onToolCall: input.onToolCall,
+            onFileWrite: input.onFileWrite,
             onToolUpdate: input.onToolUpdate,
             onToolPreparing: input.onToolPreparing,
             onToolEnd: input.onToolEnd,
@@ -1063,7 +1065,7 @@ export class PiRpcRuntime {
      * Still used for the memory review, the knowledge reranker, and as the fallback when Pi's SDK is not
      * installed. The main conversation path does NOT come here - see `answer`.
      */
-    async *answerOneShot({ conversation, prompt, signal, cwd, host, onPiQueue, onSteerDelivered, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId, knowledgeRerank }) {
+    async *answerOneShot({ conversation, prompt, signal, cwd, host, onPiQueue, onSteerDelivered, onUserEntry, onSessionFile, onToolCall, onFileWrite, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId, knowledgeRerank }) {
         const latencyStartedAt = performance.now();
         traceLatency(conversation.id, "answer.begin", latencyStartedAt);
         await mkdir(this.sessionDir, { recursive: true });
@@ -1390,6 +1392,19 @@ export class PiRpcRuntime {
                         catch (error) {
                             console.warn(`PiRpcRuntime: the tool call handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
                         }
+                        // THE FILE-WRITING CALL, announced before it runs. This is the ONLY moment the old content
+                        // is still on the disk, so this is where a baseline has to be taken - and it is taken by a
+                        // listener that does its own I/O, off the drain loop's path, because a disk read between
+                        // yields would stall the stream.
+                        const writePath = toolTargetPath(name, record.args);
+                        if (writePath) {
+                            try {
+                                onFileWrite?.(writePath, name, record.toolCallId ?? undefined);
+                            }
+                            catch (error) {
+                                console.warn(`PiRpcRuntime: the file-write handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
+                            }
+                        }
                         continue;
                     }
                     if (record.type === "tool_execution_end") {

package/dist/server/server-context.d.ts

@@ -55,6 +55,18 @@ export interface ServerContext {
     execService: ExecService;
     toolRegistry: ToolRegistry;
     toolRunner: ToolRunner;
+    /**
+     * WHAT THE AGENT CHANGED, and what each file looked like before.
+     *
+     * The tracker is here because TWO layers need it: the run service writes to it (a write tool is
+     * announced, so the "before" is captured) and the HTTP layer reads from it (a diff request asks for
+     * the "before" of one file). Putting it in the context rather than inside either service is what
+     * keeps it ONE tracker - two trackers would be two answers to "what did the agent change", and only
+     * one of them would have the baselines.
+     */
+    fileChanges?: import("./file-changes.js").FileChangeTracker;
+    /** Shared file indexes: the HTTP layer starts them lazily and write paths refresh known entries. */
+    fileIndexes?: Map<string, import("./file-index.js").FileIndex>;
     /** Absent only if construction failed; a runtime with no Pi reports itself through `available`. */
     toolLlm?: import("./tool-llm.js").ToolLlmService;
     /**

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,39 @@ 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.
+ */
+function reconcileBackgroundTasks(state) {
+    const tasks = Array.isArray(state.backgroundTasks) ? state.backgroundTasks : [];
+    state.backgroundTasks = [];
+    if (!tasks.length)
+        return { orphaned: [], changed: false };
+    const orphaned = [];
+    for (const task of tasks) {
+        if (!task)
+            continue;
+        orphaned.push(task);
+        if (task.conversationId && task.originMessageId !== undefined && task.originCallRow !== undefined) {
+            const conv = state.conversations?.find((c) => c?.id === task.conversationId);
+            const msg = conv?.messages?.find((m) => m?.id === task.originMessageId);
+            const call = msg?.toolCalls?.[task.originCallRow];
+            if (call?.backgroundTask && call.backgroundTask.status === "running") {
+                call.backgroundTask.status = "failed";
+                call.backgroundTask.output = "任务随服务重启被终止";
+            }
+        }
+    }
+    return { orphaned, changed: true };
+}
 export class Store {
     repository;
     state;
@@ -531,6 +564,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 +572,13 @@ 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.`);
                 // 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 +1861,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

@@ -930,10 +930,32 @@ export type ClientCommandBody =
     type: "providers.remove";
     providerId: string;
 }
+/**
+ * Removes ONE model from a provider, leaving the provider and its other models alone.
+ *
+ * Separate from `providers.remove` because a provider is a GROUP of models sharing one address
+ * and one key: taking one model out must not cost the others their credential.
+ */
+ | {
+    type: "providers.removeModel";
+    providerId: string;
+    modelId: string;
+}
 /** Asks for the providers Super Pi manages. The answer carries no key. */
  | {
     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
@@ -1270,9 +1292,69 @@ export type MountedToolSummary = {
     description?: string;
     enabled: boolean;
 };
+/**
+ * A file the agent changed, as the Files panel learns about it.
+ *
+ * `path` is workspace-relative and `/`-separated, the same spelling every other file path uses on the
+ * wire. `baseline` is the content BEFORE the agent's write, or `null` when there was none - which is
+ * how a NEW file is told from an EDITED one, and the two are different things to a reader.
+ *
+ * `baselineUnknown` says the "before" could not be read, as opposed to not existing. A diff view that
+ * shows an empty "before" for a file that existed is a lie, and this flag is what keeps it from being
+ * one.
+ */
+export type ChangedFile = {
+    path: string;
+    /** The content before the agent wrote it, or `null` when the file did not exist then. */
+    baseline: string | null;
+    /** True when the baseline is missing because it could not be read, not because the file was new. */
+    baselineUnknown?: boolean;
+    /** The conversation the change belongs to, so a workspace's changes can be attributed to a session. */
+    conversationId?: string;
+    /** When it happened, so the panel can order a turn's changes the way they happened. */
+    at: number;
+};
 export type ServerEvent = {
     type: "tools.updated";
     tools: MountedToolSummary[];
+}
+/**
+ * THE AGENT CHANGED THESE FILES.
+ *
+ * WHY THIS EXISTS. The Files panel could browse the workspace but could not show a CHANGE, and a panel
+ * that cannot show a change is a browser rather than a workbench: the user asked for the opposite - being
+ * able to see the files is what makes the agent's edits reviewable. The server already knew which files
+ * the agent wrote (the tool call names the path) and the knowledge went no further than one line on a
+ * card, so a file the agent had rewritten looked exactly like a file it had never touched.
+ *
+ * A SNAPSHOT rather than a delta, like every other state-bearing event here: the client replaces its
+ * list with this one, so a browser that missed an event rebuilds the list from the next one rather than
+ * accumulating a partial truth.
+ *
+ * `dropped` says how many baselines were evicted because the per-workspace cap was reached. It is
+ * reported rather than hidden, because a list that is shorter than the agent's actual work - with no
+ * explanation - reads as "the agent only changed these" and is wrong.
+ */
+ | {
+    type: "files.changed";
+    workspaceId: string;
+    changes: ChangedFile[];
+    dropped: number;
+} | {
+    type: "files.index";
+    workspaceId: string;
+    version: number;
+    changed: {
+        path: string;
+        kind: "file" | "directory";
+        size: number | null;
+        mtimeMs: number | null;
+        etag: string | null;
+        text: boolean | null;
+    }[];
+    removed: string[];
+    complete: boolean;
+    skipped: string[];
 } | {
     type: "operation.result";
     requestId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -87,7 +87,13 @@
     "scripts/tool-calls.test.mjs",
     "scripts/files-api.test.mjs",
     "scripts/files-missing-path.test.mjs",
+    "scripts/file-changes.test.mjs",
+    "scripts/file-index.test.mjs",
+    "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/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",
@@ -130,6 +136,9 @@
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
+    "scripts/file-quickopen-browser.test.mjs",
+    "scripts/file-content-search-browser.test.mjs",
+    "scripts/file-changes-browser.test.mjs",
     "scripts/msg-tabs-browser.test.mjs",
     "scripts/tabs-on-top-browser.test.mjs",
     "scripts/subagent-source.test.mjs",
@@ -154,8 +163,11 @@
   ],
   "dependencies": {
     "@earendil-works/pi-coding-agent": "^0.86.1",
+    "@types/diff": "^5.2.3",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
+    "diff": "^5.2.2",
+    "fuse.js": "^7.5.0",
     "node-pty": "^1.2.0-beta.15",
     "ws": "latest"
   },