@evandu/super-pi 0.1.33 → 0.1.35

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

@@ -49,10 +49,27 @@ export declare class RunService {
     setMemory(memory: import("../active-memory.js").ActiveMemory): void;
     reviewMemoryBoundary(conversationId: string): void;
     private readonly activeRuns;
+    /** 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;
     /** Detached work (human and background sub-agents) which shutdown must still await. */
     private readonly detached;
     constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService, agentsDir: string | string[], workflows: WorkflowEngine);
     setAgentsDir(dir: string | string[]): void;
+    answerQuestion(command: {
+        conversationId: string;
+        messageId: string;
+        questionId: string;
+        selected?: string[];
+        extraNote?: string;
+        cancelled?: boolean;
+    }): Promise<void>;
+    askQuestion(conversationId: string, question: {
+        question: string;
+        options: string[];
+        multiple?: boolean;
+        extraNote?: boolean;
+    }): Promise<unknown>;
     /**
      * Resolves the conversation and workspace synchronously for a run.
      */
@@ -82,10 +99,12 @@ export declare class RunService {
      */
     waitForIdle(): Promise<void>;
     private trackDetached;
+    private serializeConversation;
     /**
      * Stops an active turn run for a conversation.
      */
     stopRun(conversationId: string): Promise<void>;
+    private stopRunUnsafe;
     /**
      * Handles queue snapshot updates from Pi RPC.
      */
@@ -113,10 +132,12 @@ export declare class RunService {
      * Steers a queued message into the in-flight turn.
      */
     steer(conversationId: string, queueId: string): Promise<void>;
+    private steerUnsafe;
     /**
      * Cancels a queued message.
      */
     cancelQueued(conversationId: string, queueId: string): Promise<void>;
+    private cancelQueuedUnsafe;
     /**
      * Dispatches a subagent from client command (human dispatch).
      */

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

@@ -3,6 +3,40 @@ import { newSubagentRunId } from "../subagents.js";
 import { readAgents } from "../agents.js";
 import { verifyCapability } from "../capability.js";
 import { validateWorkflowPlan, workflowSummary } from "../workflow.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Expands composer references into explicit context for the model. */
+async function expandAtReferences(store, workspace, content) {
+    const refs = [...content.matchAll(/@(worktree|session):([^\s]+)/gi)];
+    if (!refs.length)
+        return content;
+    const blocks = [];
+    for (const [, kind, raw] of refs) {
+        const key = raw.trim();
+        if (kind.toLowerCase() === "session") {
+            const state = store.snapshot();
+            const found = state.conversations.find(c => c.id === key || c.title.toLocaleLowerCase().includes(key.toLocaleLowerCase()));
+            if (!found)
+                continue;
+            const text = found.messages.filter(m => m.role === "user" || m.role === "assistant").slice(-12).map(m => `${m.role}: ${m.content}`).join("\n");
+            blocks.push(`\n[引用会话 ${found.title} (${found.id})]\n${text.slice(-12000)}\n[/引用会话]`);
+            continue;
+        }
+        try {
+            const { stdout } = await execFileAsync("git", ["-C", workspace.path, "worktree", "list", "--porcelain"], { maxBuffer: 1024 * 1024 });
+            const entries = stdout.split(/\n\n+/).map(block => {
+                const path = block.match(/^worktree (.+)$/m)?.[1];
+                return path ? { path, block } : undefined;
+            }).filter(Boolean);
+            const found = entries.find(e => e.path === key || e.path.endsWith(`\\${key}`) || e.path.endsWith(`/${key}`));
+            if (found)
+                blocks.push(`\n[引用 worktree ${found.path}]\n该 worktree 的路径是：${found.path}\n[/引用 worktree]`);
+        }
+        catch { /* non-git workspaces simply have no worktree references */ }
+    }
+    return blocks.length ? `${content}\n${blocks.join("\n")}` : content;
+}
 /**
  * Service managing execution of conversation turns, message queueing,
  * follow-ups, and sub-agent dispatching.
@@ -23,6 +57,9 @@ export class RunService {
             this.memory?.review(conversation);
     }
     activeRuns = new Map();
+    /** 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();
     /** Detached work (human and background sub-agents) which shutdown must still await. */
     detached = new Set();
     constructor(store, runtime, subagents, broadcaster, extensionUiService, agentsDir, workflows) {
@@ -37,6 +74,32 @@ export class RunService {
     setAgentsDir(dir) {
         this.agentsDir = dir;
     }
+    async answerQuestion(command) {
+        const blocks = await this.store.answerQuestion(command.conversationId, command.messageId, command.questionId, command);
+        this.broadcaster.broadcast({ type: "message.questions", conversationId: command.conversationId, messageId: command.messageId, questionBlocks: blocks });
+    }
+    async askQuestion(conversationId, question) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        const message = conversation?.messages.slice().reverse().find((item) => item.role === "assistant");
+        if (!message)
+            throw new Error("No active assistant message");
+        const block = await this.store.appendQuestion(conversationId, message.id, { question: question.question, options: question.options, multiple: question.multiple === true });
+        this.broadcaster.broadcast({ type: "message.questions", conversationId, messageId: message.id, questionBlocks: [...(message.questionBlocks ?? []), block] });
+        return new Promise((resolve, reject) => {
+            const timer = setInterval(() => {
+                const current = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.find((item) => item.id === message.id)?.questionBlocks?.find((item) => item.id === block.id);
+                if (current?.status === "answered") {
+                    clearInterval(timer);
+                    resolve({ selected: current.selected ?? [], extraNote: current.extraNote ?? "" });
+                }
+                else if (current?.status === "cancelled") {
+                    clearInterval(timer);
+                    resolve({ cancelled: true });
+                }
+            }, 250);
+            setTimeout(() => { clearInterval(timer); reject(new Error("Question timed out")); }, 30 * 60 * 1000);
+        });
+    }
     /**
      * Resolves the conversation and workspace synchronously for a run.
      */
@@ -95,14 +158,28 @@ export class RunService {
         void work.then(() => this.detached.delete(work), () => this.detached.delete(work));
         return work;
     }
+    serializeConversation(conversationId, work) {
+        const previous = this.conversationOps.get(conversationId) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(work);
+        const lane = next.then(() => undefined, () => undefined);
+        this.conversationOps.set(conversationId, lane);
+        void lane.finally(() => { if (this.conversationOps.get(conversationId) === lane)
+            this.conversationOps.delete(conversationId); });
+        return next;
+    }
     /**
      * Stops an active turn run for a conversation.
      */
     async stopRun(conversationId) {
-        this.memory?.cancel(conversationId);
-        this.extensionUiService.cancelPendingUi(conversationId, "aborted");
+        // Abort immediately before waiting for the conversation lane; otherwise a stop queued behind a
+        // long streaming command could never reach the controller that it is meant to cancel.
         this.activeRuns.get(conversationId)?.abort();
         await this.runtime.stop?.(conversationId);
+        return this.serializeConversation(conversationId, () => this.stopRunUnsafe(conversationId));
+    }
+    async stopRunUnsafe(conversationId) {
+        this.memory?.cancel(conversationId);
+        this.extensionUiService.cancelPendingUi(conversationId, "aborted");
         await this.store.setStatus(conversationId, "stopped");
         if (this.subagents.stopConversation(conversationId)) {
             console.log(`Super Pi: stopped the sub-agent runs of conversation ${conversationId}.`);
@@ -272,6 +349,7 @@ export class RunService {
             onToolPreparing,
             onToolUpdate,
             onToolEnd,
+            onThinking: (delta) => this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true }),
             images,
         })) {
             await this.store.appendAssistantDelta(conversation.id, assistant.id, delta);
@@ -319,20 +397,16 @@ export class RunService {
      * Enqueues or starts execution for a user message.
      */
     async enqueueAndRun(conversationId, content, images) {
+        // The run itself must not occupy the mutation lane: a second send needs to observe the active run
+        // and enqueue immediately while the first model turn is still streaming.
         this.memory?.cancel(conversationId);
         const trimmed = content.trim();
         const validImages = Array.isArray(images) && images.length > 0 ? images : undefined;
         if (!trimmed && !validImages?.length)
             return;
         const { conversation, workspace } = this.turnContext(conversationId);
-        if (validImages?.length) {
-            const catalog = await this.runtime.catalog(conversation.model);
-            const currentModel = catalog.models.find((model) => model.provider === conversation.model?.provider && model.modelId === conversation.model?.modelId)
-                ?? catalog.models.find((m) => m.provider === catalog.defaultModel?.provider && m.modelId === catalog.defaultModel?.modelId);
-            if (currentModel && !currentModel.imageInput) {
-                throw new Error(`当前选择的模型「${currentModel.label || currentModel.modelId}」不支持图片输入`);
-            }
-        }
+        // Claim the run slot synchronously (no await between has() and set()) so two
+        // rapid sends can never both pass the guard and start concurrent turns.
         if (this.activeRuns.has(conversation.id)) {
             await this.store.enqueueMessage(conversation.id, trimmed, validImages);
             this.broadcaster.broadcastState();
@@ -341,7 +415,16 @@ export class RunService {
         const controller = new AbortController();
         this.activeRuns.set(conversation.id, controller);
         try {
-            await this.runConversationTurns(conversation, workspace, trimmed, controller, validImages);
+            if (validImages?.length) {
+                const catalog = await this.runtime.catalog(conversation.model);
+                const currentModel = catalog.models.find((model) => model.provider === conversation.model?.provider && model.modelId === conversation.model?.modelId)
+                    ?? catalog.models.find((m) => m.provider === catalog.defaultModel?.provider && m.modelId === catalog.defaultModel?.modelId);
+                if (currentModel && !currentModel.imageInput) {
+                    throw new Error(`当前选择的模型「${currentModel.label || currentModel.modelId}」不支持图片输入`);
+                }
+            }
+            const expanded = await expandAtReferences(this.store, workspace, trimmed);
+            await this.runConversationTurns(conversation, workspace, expanded, controller, validImages);
             await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "completed");
         }
         catch (error) {
@@ -358,6 +441,9 @@ export class RunService {
      * Steers a queued message into the in-flight turn.
      */
     async steer(conversationId, queueId) {
+        return this.serializeConversation(conversationId, () => this.steerUnsafe(conversationId, queueId));
+    }
+    async steerUnsafe(conversationId, queueId) {
         if (!this.runtime.steer) {
             throw new Error("当前运行时没有插队能力，无法把排队消息插到正在运行的这轮里");
         }
@@ -379,6 +465,9 @@ export class RunService {
      * Cancels a queued message.
      */
     async cancelQueued(conversationId, queueId) {
+        return this.serializeConversation(conversationId, () => this.cancelQueuedUnsafe(conversationId, queueId));
+    }
+    async cancelQueuedUnsafe(conversationId, queueId) {
         await this.store.cancelQueuedMessage(conversationId, queueId);
         this.broadcaster.broadcastState();
     }
@@ -460,19 +549,41 @@ export class RunService {
             void this.trackDetached(dispatch.then(async (run) => {
                 if (run.status === "completed")
                     this.memory?.review(this.turnContext(conversationId).conversation, { task: body.prompt, result: run.output });
-                const result = run.status === "completed"
-                    ? run.output ?? ""
-                    : `Background task failed: ${run.error ?? run.status}`;
+                const result = run.status === "completed" ? run.output ?? "" : `Background task failed: ${run.error ?? run.status}`;
                 const tag = run.status === "completed" ? "task_result" : "task_error";
                 const message = `<task id="${run.id}" state="${run.status === "completed" ? "completed" : "error"}">\n<summary>Background task ${run.status === "completed" ? "completed" : "failed"}: ${body.description?.trim() || subagentType}</summary>\n<${tag}>\n${result}\n</${tag}>\n</task>`;
-                await this.store.enqueueMessage(conversation.id, message);
-                await this.store.removeBackgroundTask(run.id);
-                this.broadcaster.broadcastState();
-            })).catch(async (error) => {
+                // Background results are durable follow-up material. Keep them visible in the queue until the
+                // user sends the next prompt; injecting a result into an idle conversation starts an unexpected
+                // model turn and makes the result disappear before the Queue Dock can render it.
+                try {
+                    if (this.activeRuns.has(conversation.id))
+                        await this.enqueueAndRun(conversation.id, message);
+                    else
+                        await this.store.enqueueMessage(conversation.id, message);
+                }
+                catch (error) {
+                    await this.store.enqueueMessage(conversation.id, message);
+                    console.warn(`Super Pi: background result could not start a turn: ${error instanceof Error ? error.message : "unknown error"}`);
+                }
+                finally {
+                    await this.store.removeBackgroundTask(run.id);
+                    this.broadcaster.broadcastState();
+                }
+            }).catch(async (error) => {
+                const message = `<task id="${backgroundId}" state="error">\n<summary>Background task failed: ${body.description?.trim() || subagentType}</summary>\n<task_error>Background task failed before completion: ${error instanceof Error ? error.message : "unknown error"}</task_error>\n</task>`;
+                try {
+                    if (this.activeRuns.has(conversationId))
+                        await this.enqueueAndRun(conversationId, message);
+                    else
+                        await this.store.enqueueMessage(conversationId, message);
+                }
+                catch {
+                    await this.store.enqueueMessage(conversationId, message);
+                }
                 await this.store.removeBackgroundTask(backgroundId);
                 this.broadcaster.broadcastState();
                 console.warn(`Super Pi: background sub-agent dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
-            });
+            }));
             return {
                 mode: "async",
                 status: 202,

package/dist/server/command-handler.d.ts

@@ -32,5 +32,19 @@ export declare class CommandHandler {
      * connection came from, because it is the one command family whose blast radius is the whole machine
      * rather than one workspace. See `TerminalService.handle`.
      */
+    /**
+     * Takes the reverting claim for a conversation from the moment the command is RECEIVED.
+     *
+     * A `message.send` runs outside this socket's command queue - deliberately, so a follow-up can be
+     * admitted while a turn streams - so it can be handled before a queued `message.revert` has started
+     * cutting anything. Calling `isReverting` from the send path then answers "no" to a send that is
+     * racing a cut in every sense that matters, and the message lands on a transcript the model still
+     * reads in full. The socket layer calls this the moment it parses the revert, which is the only point
+     * on this side of the service that is early enough; `releaseRevert` gives the claim back when the
+     * command finishes, so a revert that never reaches the service cannot hold the conversation shut.
+     */
+    claimRevert(conversationId: string): void;
+    /** The other half of `claimRevert`. Safe to call for a conversation nothing claimed. */
+    releaseRevert(conversationId: string): void;
     handleCommand(command: ClientCommand, sendToSocket?: SocketSender, remoteAddress?: string): Promise<string | void>;
 }

package/dist/server/command-handler.js

@@ -31,6 +31,24 @@ export class CommandHandler {
      * connection came from, because it is the one command family whose blast radius is the whole machine
      * rather than one workspace. See `TerminalService.handle`.
      */
+    /**
+     * Takes the reverting claim for a conversation from the moment the command is RECEIVED.
+     *
+     * A `message.send` runs outside this socket's command queue - deliberately, so a follow-up can be
+     * admitted while a turn streams - so it can be handled before a queued `message.revert` has started
+     * cutting anything. Calling `isReverting` from the send path then answers "no" to a send that is
+     * racing a cut in every sense that matters, and the message lands on a transcript the model still
+     * reads in full. The socket layer calls this the moment it parses the revert, which is the only point
+     * on this side of the service that is early enough; `releaseRevert` gives the claim back when the
+     * command finishes, so a revert that never reaches the service cannot hold the conversation shut.
+     */
+    claimRevert(conversationId) {
+        this.conversationService.claimRevert(conversationId);
+    }
+    /** The other half of `claimRevert`. Safe to call for a conversation nothing claimed. */
+    releaseRevert(conversationId) {
+        this.conversationService.releaseRevert(conversationId);
+    }
     async handleCommand(command, sendToSocket, remoteAddress) {
         if (command.type === "terminal.open" || command.type === "terminal.input" || command.type === "terminal.resize" || command.type === "terminal.close") {
             if (!this.terminalService) {
@@ -187,6 +205,10 @@ export class CommandHandler {
             this.extensionUiService.answerUi(command.conversationId, command.requestId, answer);
             return;
         }
+        if (command.type === "question.answer") {
+            await this.runService.answerQuestion(command);
+            return;
+        }
         if (command.type === "catalog.fetch") {
             if (sendToSocket)
                 sendToSocket({ type: "model.catalog", conversationId: command.conversationId, catalog: await this.catalogService.getCatalog(undefined, command.conversationId) });

package/dist/server/git.d.ts

@@ -0,0 +1,37 @@
+export type GitWorkspace = {
+    branch: string | null;
+    detached: boolean;
+    unborn: boolean;
+    ahead: number | null;
+    behind: number | null;
+    staged: GitFile[];
+    unstaged: GitFile[];
+    untracked: GitFile[];
+};
+export type GitFile = {
+    path: string;
+    name: string;
+    xy: string;
+};
+export declare function gitStatus(root: string): Promise<GitWorkspace>;
+export declare function gitLog(root: string, limit: number): Promise<{
+    commits: {
+        hash: string;
+        short: string;
+        subject: string;
+        author: string;
+        date: string;
+    }[];
+    truncated: boolean;
+}>;
+export declare function gitDiff(root: string, path: string, staged: boolean): Promise<{
+    path: string;
+    staged: boolean;
+    diff: null;
+    kind: "untracked";
+} | {
+    path: string;
+    staged: boolean;
+    diff: string;
+    kind: "text";
+}>;

package/dist/server/git.js

@@ -0,0 +1,30 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { basename, resolve, sep } from "node:path";
+import { existsSync } from "node:fs";
+const exec = promisify(execFile);
+async function git(cwd, args) { return exec("git", ["-c", "core.quotepath=false", ...args], { cwd, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }); }
+function files(raw) { const staged = [], unstaged = [], untracked = []; for (const line of raw.split("\0").filter(Boolean)) {
+    const xy = line.slice(0, 2), path = line.slice(3).split("\0")[0].replaceAll("\\", "/");
+    const item = { path, name: basename(path), xy };
+    if (xy === "??")
+        untracked.push(item);
+    else {
+        if (xy[0] !== " ")
+            staged.push(item);
+        if (xy[1] !== " ")
+            unstaged.push(item);
+    }
+} return { staged, unstaged, untracked }; }
+export async function gitStatus(root) { try {
+    await git(root, ["rev-parse", "--git-dir"]);
+}
+catch {
+    throw Object.assign(new Error("此工作区不是 Git 仓库"), { code: "not_a_repo" });
+} const status = await git(root, ["status", "--porcelain=v1", "-z"]); const branch = await git(root, ["symbolic-ref", "--short", "-q", "HEAD"]).then(r => r.stdout.trim() || null).catch(() => null); const unborn = !(await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false)); const ahead = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(a) ? a : null; }).catch(() => null); const behind = await git(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).then(r => { const [a, b] = r.stdout.trim().split(/\s+/).map(Number); return Number.isFinite(b) ? b : null; }).catch(() => null); return { branch, detached: !branch, unborn, ahead, behind, ...files(status.stdout) }; }
+export async function gitLog(root, limit) { const hasHead = await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false); if (!hasHead)
+    return { commits: [], truncated: false }; const out = await git(root, ["log", `-${Math.min(Math.max(limit, 1), 50)}`, "--format=%H%x00%h%x00%s%x00%an%x00%aI%x00"]); const parts = out.stdout.split("\0").filter(Boolean); const commits = []; for (let i = 0; i + 4 < parts.length; i += 5)
+    commits.push({ hash: parts[i], short: parts[i + 1], subject: parts[i + 2], author: parts[i + 3], date: new Date(parts[i + 4]).toISOString() }); return { commits, truncated: commits.length >= limit }; }
+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" }; }

package/dist/server/http-server.js

@@ -7,6 +7,7 @@ import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, searchByName, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
+import { gitDiff, gitLog, gitStatus } from "./git.js";
 const MIME_TYPES = {
     ".css": "text/css; charset=utf-8",
     ".html": "text/html; charset=utf-8",
@@ -166,10 +167,12 @@ export function createHttpServer(options) {
             }
             try {
                 let raw = "";
+                let totalBytes = 0;
                 for await (const chunk of request) {
-                    raw += chunk;
-                    if (raw.length > 512000)
+                    totalBytes += chunk.length;
+                    if (totalBytes > 512000)
                         throw new Error("记忆请求过大");
+                    raw += chunk;
                 }
                 const body = raw ? JSON.parse(raw) : {};
                 const result = url.pathname.endsWith("/tool")
@@ -206,10 +209,26 @@ export function createHttpServer(options) {
                 const restart = spawn(process.execPath, [join(rootDir, "scripts", "restart-server.mjs")], { cwd: rootDir, detached: true, stdio: "ignore", env: process.env });
                 restart.unref();
             });
-            child.on("error", () => { });
+            child.on("error", (error) => { console.warn(`Super Pi: update spawn failed: ${error instanceof Error ? error.message : "unknown error"}`); });
             child.unref();
             return;
         }
+        if (url.pathname === "/api/update-check" && request.method === "GET") {
+            if (!isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403).end("Update check requires a loopback or private network request");
+                return;
+            }
+            try {
+                const current = checkDiskVersion(rootDir);
+                const remoteVersion = await fetch("https://pi.dev/api/latest-version").then(result => result.ok ? result.json() : Promise.reject(new Error(`HTTP ${result.status}`)));
+                const latestVersion = typeof remoteVersion.version === "string" ? remoteVersion.version : undefined;
+                response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ ...current, latestVersion, updateAvailable: Boolean(latestVersion && latestVersion !== current.diskVersion) }));
+            }
+            catch (error) {
+                response.writeHead(502, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
         if (url.pathname === "/api/health") {
             const version = checkDiskVersion(rootDir);
             response.writeHead(200, { "content-type": "application/json; charset=utf-8" })
@@ -234,14 +253,63 @@ export function createHttpServer(options) {
                 .end(JSON.stringify({ enabled, reason: enabled ? "" : (context.terminalDisabledReason?.() ?? "终端未启用。") }));
             return;
         }
+        if (url.pathname === "/api/git") {
+            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: "Git 视图需要 GET", code: "method" });
+                    return;
+                }
+                const workspaceId = url.searchParams.get("workspaceId");
+                const workspace = context.store.snapshot().workspaces.find((item) => item.id === workspaceId);
+                if (!workspace) {
+                    json(404, { error: `工作区 ${workspaceId ?? "(missing)"} 不存在`, code: "no_workspace" });
+                    return;
+                }
+                const op = url.searchParams.get("op") ?? "status";
+                if (op === "status")
+                    json(200, await gitStatus(workspace.path));
+                else if (op === "log")
+                    json(200, await gitLog(workspace.path, Number(url.searchParams.get("limit") ?? 20)));
+                else if (op === "diff") {
+                    const path = url.searchParams.get("path");
+                    if (!path) {
+                        json(400, { error: "diff 需要 path", code: "bad_path" });
+                        return;
+                    }
+                    json(200, await gitDiff(workspace.path, path, url.searchParams.get("staged") === "1"));
+                }
+                else
+                    json(400, { error: "未知 Git 操作", code: "bad_op" });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Git 读取失败";
+                const code = error?.code;
+                if (code === 128 || code === "not_a_repo" || /not a git repository/i.test(message))
+                    json(404, { error: "此工作区不是 git 仓库", code: "not_a_repo" });
+                else if (code === "path")
+                    json(400, { error: message, code: "bad_path" });
+                else
+                    json(400, { error: message, code: "git_error" });
+            }
+            return;
+        }
         if (url.pathname === "/api/subagent/dispatch") {
             if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
                 response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Sub-agent dispatch requires a loopback or private network POST");
                 return;
             }
             let raw = "";
-            for await (const chunk of request)
+            let totalBytes = 0;
+            for await (const chunk of request) {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_FILE_BYTES * 2) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
+                    request.destroy();
+                    return;
+                }
                 raw += chunk;
+            }
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -261,8 +329,16 @@ export function createHttpServer(options) {
                 return;
             }
             let raw = "";
-            for await (const chunk of request)
+            let totalBytes = 0;
+            for await (const chunk of request) {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_FILE_BYTES * 2) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
+                    request.destroy();
+                    return;
+                }
                 raw += chunk;
+            }
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -281,8 +357,16 @@ export function createHttpServer(options) {
                 return;
             }
             let raw = "";
-            for await (const chunk of request)
+            let totalBytes = 0;
+            for await (const chunk of request) {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_FILE_BYTES * 2) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
+                    request.destroy();
+                    return;
+                }
                 raw += chunk;
+            }
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -300,6 +384,26 @@ export function createHttpServer(options) {
             }
             return;
         }
+        if (url.pathname === "/api/question") {
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403).end();
+                return;
+            }
+            let raw = "";
+            for await (const chunk of request)
+                raw += chunk;
+            try {
+                const body = JSON.parse(raw);
+                if (!body.conversationId || !body.question || !Array.isArray(body.options))
+                    throw new Error("invalid question");
+                const result = await runService.askQuestion(body.conversationId, { question: body.question, options: body.options, multiple: body.multiple });
+                response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
+            }
+            catch (error) {
+                response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "question failed" }));
+            }
+            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));
@@ -345,8 +449,16 @@ export function createHttpServer(options) {
                         return;
                     }
                     let raw = "";
-                    for await (const chunk of request)
+                    let totalBytes = 0;
+                    for await (const chunk of request) {
+                        totalBytes += chunk.length;
+                        if (totalBytes > MAX_FILE_BYTES * 2) {
+                            json(413, { error: "请求体过大", code: "too_large" });
+                            request.destroy();
+                            return;
+                        }
                         raw += chunk;
+                    }
                     const declared = Number(request.headers["content-length"] ?? "0");
                     if (Number.isFinite(declared) && declared > MAX_FILE_BYTES * 2) {
                         json(413, { error: "请求体过大", code: "too_large" });
@@ -516,7 +628,13 @@ export function createHttpServer(options) {
                 "cache-control": "public, max-age=31536000, immutable",
                 "content-length": found.size,
             });
-            createReadStream(found.filePath).pipe(response);
+            createReadStream(found.filePath).on("error", () => {
+                if (!response.headersSent) {
+                    response.writeHead(500, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "Failed to read upload file" }));
+                    return;
+                }
+                response.destroy();
+            }).pipe(response);
             return;
         }
         // Static client asset handling