@evandu/super-pi 0.1.33 → 0.1.34

package/dist/server/index.js

@@ -25,7 +25,10 @@ import { initRunningVersion } from "./version.js";
 const rootDir = resolve(import.meta.dirname, "../..");
 initRunningVersion(rootDir);
 const cliArgs = parseServerArgs(process.argv);
-const port = cliArgs.port ?? Number.parseInt(process.env.SUPER_PI_PORT ?? "3080", 10);
+// A non-numeric SUPER_PI_PORT would parse to NaN and die later in `listen` with a confusing error;
+// like the other environment variables here, an unusable value falls back to the default port.
+const envPort = Number.parseInt(process.env.SUPER_PI_PORT ?? "3080", 10);
+const port = cliArgs.port ?? (Number.isNaN(envPort) ? 3080 : envPort);
 const host = cliArgs.host ?? process.env.SUPER_PI_HOST ?? "0.0.0.0";
 const internalHost = (host === "0.0.0.0" || host === "::" || !host) ? "127.0.0.1" : host;
 const defaultDataDir = !rootDir.includes("node_modules") && existsSync(join(rootDir, ".super-pi"))
@@ -40,6 +43,7 @@ await mkdir(uploadsDir, { recursive: true }).catch(() => { });
 const taskEndpoint = `http://${internalHost}:${port}/api/subagent/dispatch`;
 const todoEndpoint = `http://${internalHost}:${port}/api/todos`;
 const workflowEndpoint = `http://${internalHost}:${port}/api/workflow/run`;
+const questionEndpoint = `http://${internalHost}:${port}/api/question`;
 // ------------------------------------------------------------- Core singletons
 const store = await openStateStore(dataDir, process.env.SUPER_PI_PERSISTENCE ?? "sqlite");
 const initialAgentDirs = resolveAgentDirectories({
@@ -58,7 +62,7 @@ const paths = {
 };
 const runtime = process.env.SUPER_PI_RUNTIME === "welcome"
     ? new WelcomeRuntime()
-    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, todoEndpoint, workflowEndpoint, uploadsDir });
+    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, uploadsDir });
 const broadcaster = new WsBroadcaster(() => store.snapshot());
 const memory = new ActiveMemory(join(dataDir, "memories"), store, runtime);
 process.env.SUPER_PI_MEMORY_ENDPOINT = `http://${internalHost}:${port}/api/memory/tool`;
@@ -114,6 +118,7 @@ const catalogService = new CatalogService(runtime, broadcaster, initialAgentDirs
 const runService = new RunService(store, runtime, subagents, broadcaster, extensionUiService, initialAgentDirs, workflows);
 runService.setMemory(memory);
 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);
 /**
  * The terminal, constructed before `serverContext` because that object carries the two predicates

package/dist/server/memory.d.ts

@@ -18,6 +18,33 @@ export declare class MemoryStore {
     private path;
     private read;
     apply(workspaceId: string, conversationId: string, operation: MemoryOperation, review?: boolean): Promise<MemoryEntry[]>;
+    /**
+     * Drops every entry this conversation contributed at or after `sinceIso`, in all three targets.
+     *
+     * WHY THIS EXISTS. A revert rewinds the conversation - Pi's session file is truncated and the messages
+     * after the boundary are gone from `state.json` - but the memory store is a SECOND, durable copy of what
+     * those turns said, and `snapshot` below splices it into every later prompt. So a person who withdrew a
+     * message had not actually withdrawn it: the turn was gone from the transcript and the app went on
+     * handing its contents to the model. Measured rather than argued: with `SUPER_PI_MEMORY_ENABLED=0` the
+     * same revert test passes, and with memory on the model still answered with a codeword from a turn the
+     * user had withdrawn.
+     *
+     * WHY A TIMESTAMP IS THE RIGHT CUT. Entries carry a `conversationId` and a `createdAt`, and reverting to
+     * a message removes EVERY message after it - so any entry this conversation created at or after the first
+     * removed message can only have come from content that no longer exists. The predicate therefore cannot
+     * delete a memory that is still true of the conversation, which is what makes deleting on a timestamp
+     * acceptable at all.
+     *
+     * WHAT IT COSTS, STATED PLAINLY. An entry does not record which message taught it, so an entry learned in
+     * a removed turn goes even when it states something that would still be true - a user's name first
+     * mentioned in the withdrawn turn. Narrowing that to provenance means stamping every write with its source
+     * and reworking consolidation: a larger change than the defect warrants, and not taken here. The
+     * alternative is the behaviour this exists to stop.
+     *
+     * Returns the dropped ids per target so the caller can unlink the mirrored skill files; the JSON alone
+     * would leave a skill on disk that no manifest advertises.
+     */
+    forget(workspaceId: string, conversationId: string, sinceIso: string): Promise<Record<MemoryTarget, string[]>>;
     snapshot(workspaceId: string): Promise<string>;
 }
 /** A separate review session must never reuse or truncate the user's Pi session. */

package/dist/server/memory.js

@@ -72,6 +72,62 @@ export class MemoryStore {
                 locks.delete(path);
         }
     }
+    /**
+     * Drops every entry this conversation contributed at or after `sinceIso`, in all three targets.
+     *
+     * WHY THIS EXISTS. A revert rewinds the conversation - Pi's session file is truncated and the messages
+     * after the boundary are gone from `state.json` - but the memory store is a SECOND, durable copy of what
+     * those turns said, and `snapshot` below splices it into every later prompt. So a person who withdrew a
+     * message had not actually withdrawn it: the turn was gone from the transcript and the app went on
+     * handing its contents to the model. Measured rather than argued: with `SUPER_PI_MEMORY_ENABLED=0` the
+     * same revert test passes, and with memory on the model still answered with a codeword from a turn the
+     * user had withdrawn.
+     *
+     * WHY A TIMESTAMP IS THE RIGHT CUT. Entries carry a `conversationId` and a `createdAt`, and reverting to
+     * a message removes EVERY message after it - so any entry this conversation created at or after the first
+     * removed message can only have come from content that no longer exists. The predicate therefore cannot
+     * delete a memory that is still true of the conversation, which is what makes deleting on a timestamp
+     * acceptable at all.
+     *
+     * WHAT IT COSTS, STATED PLAINLY. An entry does not record which message taught it, so an entry learned in
+     * a removed turn goes even when it states something that would still be true - a user's name first
+     * mentioned in the withdrawn turn. Narrowing that to provenance means stamping every write with its source
+     * and reworking consolidation: a larger change than the defect warrants, and not taken here. The
+     * alternative is the behaviour this exists to stop.
+     *
+     * Returns the dropped ids per target so the caller can unlink the mirrored skill files; the JSON alone
+     * would leave a skill on disk that no manifest advertises.
+     */
+    async forget(workspaceId, conversationId, sinceIso) {
+        const dropped = { user: [], memory: [], skills: [] };
+        const since = Date.parse(sinceIso);
+        if (!Number.isFinite(since))
+            throw new Error("记忆回滚需要一条可解析的时间戳");
+        for (const target of Object.keys(limits)) {
+            const path = this.path(workspaceId, target);
+            const task = (locks.get(path) ?? Promise.resolve()).catch(() => { }).then(async () => {
+                const entries = await this.read(path);
+                const kept = entries.filter((entry) => !(entry.conversationId === conversationId && Date.parse(entry.createdAt) >= since));
+                dropped[target] = entries.filter((entry) => !kept.includes(entry)).map((entry) => entry.id);
+                if (kept.length === entries.length)
+                    return entries;
+                const temporary = `${path}.${randomUUID()}.tmp`;
+                await mkdir(this.directory, { recursive: true });
+                await writeFile(temporary, JSON.stringify(kept, null, 2), { encoding: "utf8", mode: 0o600 });
+                await rename(temporary, path);
+                return kept;
+            });
+            locks.set(path, task);
+            try {
+                await task;
+            }
+            finally {
+                if (locks.get(path) === task)
+                    locks.delete(path);
+            }
+        }
+        return dropped;
+    }
     async snapshot(workspaceId) {
         const blocks = await Promise.all(Object.keys(limits).map(async (target) => {
             const entries = await this.apply(workspaceId, "", { target, action: "list" });

package/dist/server/persistence/json-state-repository.d.ts

@@ -4,6 +4,8 @@ import type { AppStateRepository } from "./app-state-repository.js";
 export declare class JsonStateRepository implements AppStateRepository {
     readonly filePath: string;
     private writeQueue;
+    /** The error of the most recent FAILED write, cleared by the next successful one. Read by `flush`. */
+    private lastWriteError;
     constructor(filePath: string);
     load(): Promise<AppState>;
     save(state: AppState): Promise<void>;

package/dist/server/persistence/json-state-repository.js

@@ -5,20 +5,39 @@ import { dirname, join } from "node:path";
 export class JsonStateRepository {
     filePath;
     writeQueue = Promise.resolve();
+    /** The error of the most recent FAILED write, cleared by the next successful one. Read by `flush`. */
+    lastWriteError;
     constructor(filePath) {
         this.filePath = filePath;
     }
     async load() { return JSON.parse(await readFile(this.filePath, "utf8")); }
     async save(state) {
         const write = this.writeQueue.then(async () => {
-            await mkdir(dirname(this.filePath), { recursive: true });
-            const temporary = `${this.filePath}.tmp`;
-            await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-            await replaceFile(temporary, this.filePath);
+            try {
+                await mkdir(dirname(this.filePath), { recursive: true });
+                const temporary = `${this.filePath}.tmp`;
+                await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+                await replaceFile(temporary, this.filePath);
+                this.lastWriteError = undefined;
+            }
+            catch (error) {
+                this.lastWriteError = error;
+                throw error;
+            }
         });
+        // The queue keeps swallowing: one failed write must not poison every write queued behind it.
+        // The failure is remembered above, and `flush` is what reports it.
         this.writeQueue = write.catch(() => { });
         await write;
     }
-    async flush() { await this.writeQueue; }
+    async flush() {
+        await this.writeQueue;
+        if (this.lastWriteError !== undefined) {
+            const error = this.lastWriteError;
+            this.lastWriteError = undefined;
+            console.error(`Super Pi: the last state write to ${this.filePath} failed (${error instanceof Error ? error.message : String(error)}) - the state on disk may be older than the state in memory.`);
+            throw error;
+        }
+    }
 }
 export const defaultJsonStatePath = (dataDir) => join(dataDir, "state.json");

package/dist/server/runtime.d.ts

@@ -96,6 +96,8 @@ export interface AnswerInput {
      * replacement text, and one that shows the call arriving.
      */
     onToolPreparing?(call: ToolCallPreparing): void;
+    /** Called while the primary model is emitting reasoning, so the UI can show live progress. */
+    onThinking?(delta: string): void;
 }
 /**
  * What Pi answered when a `steer` was written to it, from the `disposition` of that command's response
@@ -662,6 +664,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
         endpoint?: string;
         todoEndpoint?: string;
         workflowEndpoint?: string;
+        questionEndpoint?: string;
         uploadsDir?: string;
     });
     /**
@@ -703,7 +706,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * own address, so it is the same string on every turn and is read once from the constructor's options.
      */
     private taskExtensionEnv;
-    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
+    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
     /**
      * Reads back the id of the user message this turn just created, and hands it to the caller.
      *

package/dist/server/runtime.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { resolve, join } from "node:path";
@@ -343,6 +344,11 @@ export async function truncateSessionFile(path, boundaryEntryId, expectedSession
     const expectedLastId = beforeBoundary ? parsed[boundary - 1]?.id : parsed[boundary]?.id;
     if (beforeBoundary)
         boundary -= 1;
+    // Fail closed: a boundary of -1 here means "revert to before the FIRST entry", which would write an
+    // empty session file. The verification below would pass vacuously (0 !== 0 is false), so the refusal
+    // must happen here rather than be trusted to a check that cannot fire.
+    if (boundary < 0)
+        throw new Error(`回退点在第一条消息之前，截断会得到一个空会话文件，拒绝回退：${path}`);
     // The `parentId` property probe A measured, enforced at the boundary that matters: every entry still
     // being KEPT must point at something also being kept. A prefix that violates this is not a session,
     // and writing it would produce a file Pi either rejects or silently misreads.
@@ -371,7 +377,7 @@ export async function truncateSessionFile(path, boundaryEntryId, expectedSession
     catch {
         lastEntry = undefined;
     }
-    if (verified.length !== boundary + 1 || lastEntry?.id !== expectedLastId) {
+    if (verified.length !== boundary + 1 || lastEntry?.id !== expectedLastId || boundary + 1 < 1) {
         throw new Error(`截断后的 Pi 会话文件没有以要保留的那条消息结尾（写到 ${verified.length} 行，期望 ${boundary + 1} 行，末行 id=${JSON.stringify(lastEntry?.id ?? null)}）。原始文件仍在 ${backupPath}。`);
     }
     return { linesKept: boundary + 1, entriesDropped: lines.length - (boundary + 1) };
@@ -703,6 +709,7 @@ export class PiRpcRuntime {
             [TASK_DEPTH_ENV]: "0",
             [TODO_ENDPOINT_ENV]: this.options.todoEndpoint ?? "",
             [WORKFLOW_ENDPOINT_ENV]: this.options.workflowEndpoint ?? "",
+            SUPER_PI_QUESTION_ENDPOINT: this.options.questionEndpoint ?? "",
             // MINTED HERE, AT SPAWN, rather than read from anywhere: this is the only moment the value is
             // decided, so it cannot change underneath a running child. `SubagentSupervisor` never calls this
             // function, so no sub-agent process is ever handed a capability - which is what makes a sub-agent
@@ -710,7 +717,7 @@ export class PiRpcRuntime {
             [TASK_CAPABILITY_ENV]: mintCapability(conversationId),
         };
     }
-    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, images, memoryReview, memorySourceConversationId }) {
+    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, images, memoryReview, memorySourceConversationId }) {
         await mkdir(this.sessionDir, { recursive: true });
         // Normalize first: the picker can hand over forward slashes or a trailing separator, and `resolve`
         // turns both into one absolute native path. The directory must exist on disk before spawn - a
@@ -751,7 +758,7 @@ export class PiRpcRuntime {
         // other. They also share the extension's existence - `extensionArgs` is non-empty exactly when
         // `index.ts` is on disk and an endpoint was configured - so there is no case where one is mounted and
         // the other is not.
-        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : [])] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, "question"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)
@@ -773,8 +780,16 @@ export class PiRpcRuntime {
         });
         const channel = new RpcChannel(child);
         this.runs.set(conversation.id, { child, channel });
-        const abort = () => { if (!child.killed)
-            child.stdin.write(`${JSON.stringify({ id: "abort", type: "abort" })}\n`); };
+        // Same guard as subagents.ts: a destroyed stdin throws synchronously on write, and an abort
+        // listener that throws inside a listener would surface as an unhandled error instead of a cancel.
+        const abort = () => {
+            if (child.exitCode === null && !child.killed && !child.stdin.destroyed) {
+                try {
+                    child.stdin.write(`${JSON.stringify({ id: "abort", type: "abort" })}\n`);
+                }
+                catch { /* the child died between the check and the write; the abort is moot */ }
+            }
+        };
         signal.addEventListener("abort", abort, { once: true });
         // A blocking request is awaited inside the drain loop, so the loop cannot observe an abort or a
         // dead child on its own. Both are raced into the wait so a pending question can never outlive the run.
@@ -1006,6 +1021,8 @@ export class PiRpcRuntime {
                             const detail = describeToolCallInProgress(name, argumentText.get(event.contentIndex) ?? "");
                             onToolPreparing?.({ contentIndex: event.contentIndex, name, ...(delta ? { delta } : {}), ...(detail ? { detail } : {}) });
                         }
+                        else if (event?.type === "thinking_delta")
+                            onThinking?.(typeof event.delta === "string" ? event.delta : "");
                         else
                             noteUnhandled(`message_update:${JSON.stringify(event?.type ?? "(missing)")}`);
                         continue;
@@ -1335,8 +1352,14 @@ export class PiRpcRuntime {
             console.warn(`PiRpcRuntime: extension_ui_request method=${JSON.stringify(record.method ?? null)} id=${JSON.stringify(record.id ?? null)} is not one of Pi's nine Extension UI methods - consumed without reply.`);
             return;
         }
-        const reply = (response) => { if (child.killed || child.stdin.destroyed)
-            return; child.stdin.write(`${JSON.stringify(response)}\n`); };
+        const reply = (response) => {
+            if (child.exitCode === null && !child.killed && !child.stdin.destroyed) {
+                try {
+                    child.stdin.write(`${JSON.stringify(response)}\n`);
+                }
+                catch { /* the child died between the check and the write; the reply is moot */ }
+            }
+        };
         if (!request.blocking) {
             // Deliberately not awaited: these five are fire-and-forget in Pi, and awaiting would stall the
             // drain loop on a UI that already told us it wants no reply.
@@ -1372,8 +1395,18 @@ export class PiRpcRuntime {
         }
         reply(buildExtensionUiResponse(request, answer));
     }
-    async stop(conversationId) { const run = this.runs.get(conversationId); if (run && !run.child.killed)
-        run.child.stdin.write(`${JSON.stringify({ id: "abort", type: "abort" })}\n`); }
+    async stop(conversationId) {
+        const run = this.runs.get(conversationId);
+        if (!run)
+            return;
+        // Same guard as the abort listener in `answer`: a destroyed stdin throws synchronously on write.
+        if (run.child.exitCode === null && !run.child.killed && !run.child.stdin.destroyed) {
+            try {
+                run.child.stdin.write(`${JSON.stringify({ id: "abort", type: "abort" })}\n`);
+            }
+            catch { /* the child died between the check and the write; the abort is moot */ }
+        }
+    }
     /**
      * Injects one message into the Pi process that is running right now, at its next turn boundary.
      *
@@ -1404,10 +1437,12 @@ export class PiRpcRuntime {
         if (!this.pi.found)
             throw new Error(this.pi.reason);
         const TIMEOUT_MS = 30_000;
-        const MAX_TITLE_CHARS = 40;
+        // Session names live in a narrow sidebar row. Keep the model's budget well below the storage
+        // limit so the result remains a concise label instead of becoming a sentence.
+        const MAX_TITLE_CHARS = 18;
         // A throwaway session id, not the conversation's: this child reads nothing else and its history must
         // not be filed under the conversation whose title it is producing.
-        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", `autotitle-${Date.now()}`], {
+        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", `autotitle-${randomUUID()}`], {
             cwd: resolve(cwd),
             stdio: ["pipe", "pipe", "pipe"],
             shell: process.platform === "win32",
@@ -1427,7 +1462,7 @@ export class PiRpcRuntime {
                 message: [
                     "为下面这段对话起一个简短的标题,用作会话列表里的一行字。",
                     "只输出标题本身:不要引号,不要句末标点,不要「标题:」之类的前缀,不要解释,不要换行。",
-                    `长度不超过 ${MAX_TITLE_CHARS} 个字符,用与对话内容相同的语言。`,
+                    `只生成一个简短的会话标签，长度严格不超过 ${MAX_TITLE_CHARS} 个字符（中文按一个字计数）。优先控制在 8-12 个字符；不要写成完整句子，不要使用副标题、解释、列表或多个候选标题。用与对话内容相同的语言。`,
                     "",
                     transcript,
                 ].join("\n"),
@@ -1460,8 +1495,10 @@ export class PiRpcRuntime {
                 .replace(/[。.！!，,、;；\s]+$/u, "")
                 .trim()
                 .slice(0, MAX_TITLE_CHARS);
-            if (!title)
-                throw new Error("模型没有返回可用的标题");
+            if (!title) {
+                const fallback = conversation.messages.find((message) => message.role === "user" && message.content.trim())?.content.trim();
+                return (fallback || "新会话").slice(0, MAX_TITLE_CHARS);
+            }
             return title;
         }
         finally {

package/dist/server/store.d.ts

@@ -232,6 +232,12 @@ export declare class Store {
      * instead of as a field it does not understand.
      */
     appendToolCall(conversationId: string, messageId: string, call: ToolCallBlock): Promise<ToolCallBlock[]>;
+    appendQuestion(conversationId: string, messageId: string, question: Omit<import("./types.js").QuestionBlock, "id" | "status">): Promise<import("./types.js").QuestionBlock>;
+    answerQuestion(conversationId: string, messageId: string, questionId: string, answer: {
+        selected?: string[];
+        extraNote?: string;
+        cancelled?: boolean;
+    }): Promise<import("./types.js").QuestionBlock[]>;
     /**
      * Fills in the outcome of the call at `index`, or returns the array UNCHANGED when there is no such
      * index.

package/dist/server/store.js

@@ -1,3 +1,4 @@
+import { rename } from "node:fs/promises";
 import { JsonStateRepository, defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import { normalizeTodos } from "./task-tool.js";
 import { TOOL_ARG_CAP } from "./tool-calls.js";
@@ -481,8 +482,23 @@ export class Store {
             return store;
         }
         catch (error) {
-            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
-                throw error;
+            const code = error instanceof Error ? error.code : undefined;
+            if (code !== "ENOENT") {
+                // A file-backed JSON state that cannot be parsed (or read) must not crash startup: the bad file is
+                // moved aside so a later run can still inspect it, and the server starts from a fresh state.
+                // Repositories without a file behind them keep failing loudly - there is nothing to quarantine.
+                if (!(repository instanceof JsonStateRepository))
+                    throw error;
+                const quarantine = `${repository.filePath}.corrupt-${Date.now()}`;
+                const reason = error instanceof Error ? error.message : String(error);
+                try {
+                    await rename(repository.filePath, quarantine);
+                    console.warn(`Super Pi: state file ${repository.filePath} could not be loaded (${reason}) - it was moved to ${quarantine} and the server starts with a fresh state.`);
+                }
+                catch (moveError) {
+                    console.warn(`Super Pi: state file ${repository.filePath} could not be loaded (${reason}) and could not be moved aside either (${moveError instanceof Error ? moveError.message : String(moveError)}) - the server starts with a fresh state; the unreadable file is still at ${repository.filePath}.`);
+                }
+            }
             const createdAt = now();
             return new Store(repository, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], queuedMessages: [], backgroundTasks: [] });
         }
@@ -723,6 +739,7 @@ export class Store {
             throw new Error("Conversation name must be 1-80 characters");
         const conversation = this.requireConversation(conversationId);
         conversation.title = cleanName;
+        conversation.titleLocked = true;
         await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
@@ -741,7 +758,8 @@ export class Store {
         const autoTitle = firstUser?.content.trim()
             ? firstUser.content.slice(0, 42)
             : (firstUser?.images?.length ? "【图片】" : DEFAULT_CONVERSATION_TITLE);
-        conversation.title = autoTitle || DEFAULT_CONVERSATION_TITLE;
+        if (!conversation.titleLocked)
+            conversation.title = autoTitle || DEFAULT_CONVERSATION_TITLE;
         conversation.updatedAt = message.createdAt;
         conversation.status = "running";
         // The reason this conversation was failed - startup reconciliation's note that a previous run was cut
@@ -881,6 +899,31 @@ export class Store {
         await this.persist();
         return structuredClone(calls);
     }
+    async appendQuestion(conversationId, messageId, question) {
+        const message = this.requireConversation(conversationId).messages.find((item) => item.id === messageId);
+        if (!message)
+            throw new Error("Assistant message not found");
+        const block = { ...structuredClone(question), id: id("question"), status: "pending" };
+        (message.questionBlocks ??= []).push(block);
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: now() });
+        return structuredClone(block);
+    }
+    async answerQuestion(conversationId, messageId, questionId, answer) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message?.questionBlocks)
+            throw new Error("Question not found");
+        const block = message.questionBlocks.find((item) => item.id === questionId);
+        if (!block || block.status !== "pending")
+            throw new Error("Question is no longer pending");
+        block.status = answer.cancelled ? "cancelled" : "answered";
+        if (!answer.cancelled) {
+            block.selected = [...(answer.selected ?? [])];
+            block.extraNote = answer.extraNote ?? "";
+        }
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: now() });
+        return structuredClone(message.questionBlocks);
+    }
     /**
      * Fills in the outcome of the call at `index`, or returns the array UNCHANGED when there is no such
      * index.

package/dist/server/terminal.js

@@ -156,8 +156,10 @@ const MAX_ROWS = 200;
  * event loop. Chunks are queued and flushed on a timer, with a byte ceiling per frame so one flush
  * cannot build a megabyte-long string.
  *
- * The ceiling is applied to the QUEUE, not to the flush, because dropping a partial ANSI escape sequence
- * would corrupt the stream: the split is forced at the START of the next flush rather than mid-escape.
+ * The per-frame ceiling never DISCARDS data: a flush larger than MAX_CHUNK_BYTES sends its first
+ * MAX_CHUNK_BYTES and puts the remainder back at the FRONT of the queue - it is older than anything
+ * enqueued since - with the flush timer re-armed, so the split lands at the START of the next flush
+ * rather than mid-escape, where it could cut a partial ANSI escape sequence.
  */
 const FLUSH_INTERVAL_MS = 16;
 const MAX_CHUNK_BYTES = 64 * 1024;
@@ -257,7 +259,11 @@ export class TerminalService {
             this.sessions.set(command.sessionId, session);
             child.onData((data) => this.enqueue(session, command.sessionId, data, send));
             child.onExit(({ exitCode }) => {
-                this.flush(session, command.sessionId, send);
+                // Drain everything still queued before reporting the exit: each flush sends at most
+                // MAX_CHUNK_BYTES and re-queues the remainder, so a large final burst takes several
+                // passes. Without the loop, the exit would cut off output the shell already produced.
+                while (session.pending)
+                    this.flush(session, command.sessionId, send);
                 this.sessions.delete(command.sessionId);
                 // A killed shell on Windows reports 0xC0000139 (STATUS_ENTRYPOINT_NOT_FOUND) because that is how
                 // ConPTY tears down, not because a command failed. Reporting it verbatim would tell the user a
@@ -265,8 +271,6 @@ export class TerminalService {
                 if (session.closed && session.killed)
                     return;
                 session.closed = true;
-                if (session.timer)
-                    clearTimeout(session.timer);
                 send({ type: "terminal.exit", sessionId: command.sessionId, exitCode: session.killed ? 0 : exitCode });
             });
             return;
@@ -319,12 +323,21 @@ export class TerminalService {
         }
         let data = session.pending;
         session.pending = "";
-        if (data.length > MAX_CHUNK_BYTES)
+        if (data.length > MAX_CHUNK_BYTES) {
+            // The ceiling bounds ONE FRAME, not the queue: the remainder is older data, so it goes back to
+            // the FRONT of the pending buffer and the timer is re-armed so the next flush sends it. Dropping
+            // it here would silently lose terminal output - the exact corruption the queue exists to avoid.
+            session.pending = data.slice(MAX_CHUNK_BYTES) + session.pending;
             data = data.slice(0, MAX_CHUNK_BYTES);
+            session.timer = setTimeout(() => this.flush(session, sessionId, send), FLUSH_INTERVAL_MS);
+        }
         send({ type: "terminal.output", sessionId, data });
     }
     kill(sessionId, session, send) {
-        this.flush(session, sessionId, send);
+        // Drain the backlog before teardown so closing a terminal does not discard output the shell
+        // already produced; each flush sends at most MAX_CHUNK_BYTES per frame.
+        while (session.pending)
+            this.flush(session, sessionId, send);
         session.closed = true;
         session.killed = true;
         if (session.timer) {

package/dist/server/types.d.ts

@@ -55,6 +55,15 @@ export type MessageImage = {
     width?: number;
     height?: number;
 };
+export type QuestionBlock = {
+    id: string;
+    question: string;
+    options: string[];
+    multiple: boolean;
+    status: "pending" | "answered" | "cancelled";
+    selected?: string[];
+    extraNote?: string;
+};
 export type Message = {
     id: string;
     role: MessageRole;
@@ -62,6 +71,8 @@ export type Message = {
     createdAt: string;
     piEntryId?: string;
     toolCalls?: ToolCallBlock[];
+    questionBlocks?: QuestionBlock[];
+    thinking?: string;
     images?: MessageImage[];
     agentIdentity?: {
         id?: string;
@@ -250,6 +261,8 @@ export type Conversation = {
     status: RunStatus;
     messages: Message[];
     archivedAt?: string;
+    /** Set when the user explicitly names the session; automatic first-message titles must not overwrite it. */
+    titleLocked?: boolean;
     /**
      * Why this conversation is not `running`, in WORDS A PERSON READS - the same role `SubagentRun.error`
      * plays for a card, one level up.
@@ -678,7 +691,15 @@ export type ExtensionUiAnswer = {
 export type ClientCommand = ClientCommandBody & {
     operationRequestId?: string;
 };
-export type ClientCommandBody = 
+export type ClientCommandBody = {
+    type: "question.answer";
+    conversationId: string;
+    messageId: string;
+    questionId: string;
+    selected?: string[];
+    extraNote?: string;
+    cancelled?: boolean;
+}
 /**
  * THE TERMINAL, and the reason `terminal.open` CARRIES NO PATH.
  *
@@ -689,7 +710,7 @@ export type ClientCommandBody =
  * the user already configured and a shell scoped to the whole disk, and it is structural rather than a
  * check that a later edit could forget.
  */
-{
+ | {
     type: "terminal.open";
     sessionId: string;
     workspaceId: string;
@@ -948,6 +969,8 @@ export type ServerVersionInfo = {
     runningVersion: string;
     diskVersion: string;
     needsRestart: boolean;
+    latestVersion?: string;
+    updateAvailable?: boolean;
 };
 export type ServerEvent = {
     type: "operation.result";
@@ -966,6 +989,12 @@ export type ServerEvent = {
     conversationId: string;
     messageId: string;
     delta: string;
+} | {
+    type: "message.thinking";
+    conversationId: string;
+    messageId: string;
+    delta: string;
+    active: boolean;
 }
 /**
  * THE ANSWER TO `conversation.fork`, as ONE event with an `ok` discriminant rather than two events or a
@@ -1021,6 +1050,11 @@ export type ServerEvent = {
     conversationId: string;
     messageId: string;
     toolCalls: ToolCallBlock[];
+} | {
+    type: "message.questions";
+    conversationId: string;
+    messageId: string;
+    questionBlocks: QuestionBlock[];
 } | {
     type: "error";
     message: string;