@evandu/super-pi 0.1.140 → 0.1.141

package/dist/client/index.html

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

package/dist/server/agents.d.ts

@@ -37,6 +37,8 @@ type Frontmatter = Record<string, unknown>;
  * `validateToolNames` for what is rejected on that account and why.
  */
 export declare const PI_TOOL_NAMES: readonly ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "codemode", "tool_search", "list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource"];
+/** Tools shipped by this package. Authors must be able to explicitly deny host extras. */
+export declare const SUPER_PI_TOOL_NAMES: readonly ["task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register", "memory", "skill_manage", "session_search", "knowledge_search", "knowledge_import", "document_read", "document_write", "web_search", "web_fetch", "feishu_doc_read", "feishu_doc_write"];
 /**
  * Whether a name can be a real Pi tool. A name is real if it is one of `PI_TOOL_NAMES`, an MCP
  * server tool, or a PATTERN.

package/dist/server/agents.js

@@ -36,7 +36,14 @@ export const PI_TOOL_NAMES = [
     // core/mcp-servers.ts:31-37 - reachable on any server that exposes resources.
     "list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource",
 ];
-const PI_TOOL_NAME_SET = new Set(PI_TOOL_NAMES);
+/** Tools shipped by this package. Authors must be able to explicitly deny host extras. */
+export const SUPER_PI_TOOL_NAMES = [
+    "task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register",
+    "memory", "skill_manage", "session_search", "knowledge_search", "knowledge_import",
+    "document_read", "document_write", "web_search", "web_fetch", "feishu_doc_read", "feishu_doc_write",
+];
+const KNOWN_TOOL_NAMES = [...PI_TOOL_NAMES, ...SUPER_PI_TOOL_NAMES];
+const PI_TOOL_NAME_SET = new Set(KNOWN_TOOL_NAMES);
 /**
  * Whether a name can be a real Pi tool. A name is real if it is one of `PI_TOOL_NAMES`, an MCP
  * server tool, or a PATTERN.
@@ -66,7 +73,7 @@ function editDistance(left, right) {
     return row[right.length];
 }
 function closestToolName(name) {
-    const ranked = PI_TOOL_NAMES.map((candidate) => ({ candidate, distance: editDistance(name, candidate) })).sort((a, b) => a.distance - b.distance);
+    const ranked = KNOWN_TOOL_NAMES.map((candidate) => ({ candidate, distance: editDistance(name, candidate) })).sort((a, b) => a.distance - b.distance);
     return ranked[0]?.distance <= Math.max(2, Math.floor(name.length / 2)) ? ranked[0].candidate : undefined;
 }
 /**
@@ -95,7 +102,7 @@ function validateToolNames(tools) {
         const suggestion = closestToolName(name);
         return `${JSON.stringify(name)}${suggestion ? ` (did you mean ${JSON.stringify(suggestion)}?)` : ""}`;
     });
-    return `tools names ${details.join(", ")}, which Pi does not have. Statically known tools: ${PI_TOOL_NAMES.join(", ")}; MCP tools are named mcp__<server>__<tool>, and a "*" in a name is a Pi glob.`;
+    return `tools names ${details.join(", ")}, which Pi does not have. Statically known tools: ${KNOWN_TOOL_NAMES.join(", ")}; MCP tools are named mcp__<server>__<tool>, and a "*" in a name is a Pi glob.`;
 }
 /**
  * Splits a definition file into frontmatter and body. The body is the system prompt, exactly as in

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

@@ -39,8 +39,16 @@ export declare class ConversationService {
     setAgentsDir(dir: string | string[]): void;
     /**
      * Creates a new conversation in a workspace.
+     *
+     * `parentage` is WHO OPENED THIS CONVERSATION, recorded at birth exactly once: the session
+     * tree's edge (`parentConversationId`) and its origin. Only the orchestrator passes it - the "+"
+     * button and every other caller create a top-level conversation by omission, which is the same
+     * "absence means top level" rule the pre-tree state.json files read under.
      */
-    createConversation(workspaceId: string): Promise<string>;
+    createConversation(workspaceId: string, parentage?: {
+        parentConversationId?: string;
+        origin?: "user" | "orchestrator";
+    }): Promise<string>;
     /**
      * Name a conversation from what was said in it. Returns the title; the CALLER applies it, because the
      * rename is a second command with its own optimistic path and its own failure toast, and a service that
@@ -69,6 +77,12 @@ export declare class ConversationService {
      * Unarchives a conversation.
      */
     unarchiveConversation(conversationId: string): Promise<void>;
+    /**
+     * Collapses or expands one conversation's subtree in the sidebar's session tree. The state is
+     * the store's, server-side; this method only adds the conversation-exists check and the
+     * broadcast every other write here performs.
+     */
+    setCollapsed(conversationId: string, collapsed: boolean): Promise<void>;
     /**
      * Renames a conversation.
      */

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

@@ -38,8 +38,13 @@ export class ConversationService {
     }
     /**
      * Creates a new conversation in a workspace.
+     *
+     * `parentage` is WHO OPENED THIS CONVERSATION, recorded at birth exactly once: the session
+     * tree's edge (`parentConversationId`) and its origin. Only the orchestrator passes it - the "+"
+     * button and every other caller create a top-level conversation by omission, which is the same
+     * "absence means top level" rule the pre-tree state.json files read under.
      */
-    async createConversation(workspaceId) {
+    async createConversation(workspaceId, parentage) {
         const workspace = this.store.workspace(workspaceId);
         if (!workspace)
             throw new Error("找不到这个工作区。");
@@ -104,7 +109,7 @@ export class ConversationService {
             : { model, thinkingLevel };
         // `null` is intentional here: Store uses it to remove a workspace value that it
         // would otherwise have copied before applying the resolved configuration.
-        const defaults = { ...resolved, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(modelNotice ? { modelNotice } : {}) };
+        const defaults = { ...resolved, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(modelNotice ? { modelNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
         const created = await this.store.createConversation(workspaceId, defaults);
         this.broadcaster.broadcastState();
         return created.id;
@@ -174,6 +179,17 @@ export class ConversationService {
         await this.store.unarchiveConversation(conversationId);
         this.broadcaster.broadcastState();
     }
+    /**
+     * Collapses or expands one conversation's subtree in the sidebar's session tree. The state is
+     * the store's, server-side; this method only adds the conversation-exists check and the
+     * broadcast every other write here performs.
+     */
+    async setCollapsed(conversationId, collapsed) {
+        if (!this.store.conversation(conversationId))
+            throw new Error("找不到这个会话。");
+        await this.store.setConversationCollapsed(conversationId, collapsed);
+        this.broadcaster.broadcastState();
+    }
     /**
      * Renames a conversation.
      */

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

@@ -85,6 +85,7 @@ export declare class RunService {
     setNameIndexes(indexes: Map<string, import("../file-name-index.js").FileNameIndex>): void;
     reviewMemoryBoundary(conversationId: string): void;
     private readonly activeRuns;
+    private readonly turnEventScopes;
     private readonly historyCutClaims;
     holdHistoryCut(conversationId: string): void;
     releaseHistoryCut(conversationId: string): void;

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

@@ -11,6 +11,7 @@ import { toWorkspaceRelative } from "../files.js";
 import { refreshWorkspaceIndex } from "../file-index.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
 const execFileAsync = promisify(execFile);
 /** Expands composer references into explicit context for the model. */
 async function expandAtReferences(store, workspace, content) {
@@ -115,6 +116,7 @@ export class RunService {
             this.memory?.review(conversation);
     }
     activeRuns = new Map();
+    turnEventScopes = new Map();
     historyCutClaims = new Map();
     holdHistoryCut(conversationId) {
         this.historyCutClaims.set(conversationId, (this.historyCutClaims.get(conversationId) ?? 0) + 1);
@@ -847,8 +849,31 @@ export class RunService {
      * nothing above it - the user could not find what they had typed, while the agent quoted it back.
      */
     async streamTurn(conversation, workspace, prompt, assistantMessage, controller, userMessageId, images, agentIdentity) {
+        const scope = { id: randomUUID(), controller, accepting: true };
+        this.turnEventScopes.set(conversation.id, scope);
+        const ownsScope = () => this.turnEventScopes.get(conversation.id) === scope
+            && this.activeRuns.get(conversation.id) === scope.controller;
+        // Abort closes new work, while an existing tool outcome and transcript locator may still settle.
+        // Iterator completion closes ALL runtime callbacks before the accepted write lane is drained.
+        const rejectedEvents = new Set();
+        const acceptsEvent = (event, settlement = false) => {
+            const current = ownsScope() && scope.accepting;
+            if (!current && !rejectedEvents.has(event)) {
+                rejectedEvents.add(event);
+                console.warn(`Super Pi: ignored stale turn event conversation=${conversation.id} turn=${scope.id} event=${event}`);
+            }
+            return current && (settlement || !controller.signal.aborted);
+        };
+        const traceScope = (phase) => {
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1") {
+                console.info(`[super-pi turn] conversation=${conversation.id} turn=${scope.id} phase=${phase} aborted=${controller.signal.aborted}`);
+            }
+        };
+        traceScope("opened");
         this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+        const uiHost = this.extensionUiService.createHost(conversation.id);
         let assistant = assistantMessage;
+        let closedOwnScope = false;
         let toolCalls = [];
         let pendingTools = Promise.resolve();
         // A TURN MOVES FROM `waiting` TO `running` ONCE THE MODEL HAS PRODUCED ANY SIGNAL: a text delta
@@ -872,11 +897,14 @@ export class RunService {
          * a snapshot only when it actually flips the status, and the caller asks.
          */
         const promoteToRunning = async () => {
-            if (!firstSignal)
+            // Accepted tool writes may drain after the producer closed; that is normal cleanup, not a stale event.
+            if (!ownsScope() || !scope.accepting || controller.signal.aborted || !firstSignal)
                 return false;
             firstSignal = false;
-            if (this.store.snapshot().conversations.find((item) => item.id === conversation.id)?.status === "waiting") {
+            if (this.store.conversationStatus(conversation.id) === "waiting") {
                 await this.store.setStatus(conversation.id, "running");
+                if (!ownsScope() || !scope.accepting || controller.signal.aborted)
+                    return false;
                 this.broadcaster.broadcastState();
                 return true;
             }
@@ -896,13 +924,21 @@ export class RunService {
             if (!checkpointPending)
                 return;
             checkpointPending = false;
+            if (!ownsScope())
+                return;
             // Tool updates and message checkpoints both replace the persisted message. They share this lane
             // so an earlier text snapshot cannot commit after a newer tool state and erase it on disk.
-            pendingTools = pendingTools.then(() => this.store.checkpointMessage(conversation.id, assistant.id)).catch((error) => {
+            pendingTools = pendingTools.then(async () => {
+                if (ownsScope())
+                    await this.store.checkpointMessage(conversation.id, assistant.id);
+            }).catch((error) => {
                 console.warn(`Super Pi: streaming checkpoint failed: ${error instanceof Error ? error.message : "unknown error"}`);
             });
         };
         const scheduleCheckpoint = () => {
+            // The final checkpoint owns all accepted live text after the producer closes.
+            if (!scope.accepting || !ownsScope())
+                return;
             checkpointPending = true;
             if (checkpointTimer !== undefined)
                 return;
@@ -910,14 +946,35 @@ export class RunService {
         };
         const enqueueTools = (what, work) => {
             pendingTools = pendingTools.then(async () => {
+                if (!ownsScope())
+                    return;
                 // A TOOL CALL IS A SIGNAL THE MODEL IS ALIVE. Promote `waiting` → `running` on the same
                 // path as text deltas: a tool row appearing on screen is the same "we have data" event
                 // the status needs to reflect. Doing it BEFORE the tool write keeps the order
                 // honest - a client that saw the new tool row in the same frame also saw the running
                 // status, instead of flashing back to a still-spinning waiting mark for the next paint.
                 await promoteToRunning();
+                if (!ownsScope())
+                    return;
                 const hadPendingQuestion = toolCalls.some(call => call.question?.status === "pending");
                 toolCalls = await work();
+                if (!ownsScope())
+                    return;
+                // Stop may have scanned pending questions before this accepted write reached the Store.
+                // Keep the tool record, but do not resurrect a human wait after cancellation.
+                if (controller.signal.aborted) {
+                    for (let index = 0; index < toolCalls.length; index++) {
+                        const question = toolCalls[index].question;
+                        if (question?.status !== "pending")
+                            continue;
+                        toolCalls = await this.store.updateToolCall(conversation.id, assistant.id, index, {
+                            question: { items: question.items, status: "cancelled" },
+                        });
+                        if (!ownsScope())
+                            return;
+                        this.settleQuestion(conversation.id, assistant.id, index, toolCalls[index]?.question);
+                    }
+                }
                 this.broadcaster.broadcast({ type: "message.tools", conversationId: conversation.id, messageId: assistant.id, toolCalls });
                 if (hadPendingQuestion !== toolCalls.some(call => call.question?.status === "pending"))
                     this.broadcaster.broadcastState();
@@ -980,6 +1037,8 @@ export class RunService {
          */
         const preparingRows = new Map();
         const onToolPreparing = (call) => {
+            if (!acceptsEvent("tool.preparing"))
+                return;
             const existing = preparingRows.get(call.contentIndex);
             if (existing === undefined && call.final) {
                 // `toolcall_end` FOR A CALL THAT IS ALREADY ON SCREEN. Pi closes an argument document whenever it
@@ -1069,6 +1128,8 @@ export class RunService {
          */
         const fileWritePaths = new Map();
         const onFileWrite = (path, _toolName, toolCallId) => {
+            if (!acceptsEvent("file.write"))
+                return;
             const tracker = this.fileChanges;
             if (!tracker)
                 return;
@@ -1098,6 +1159,8 @@ export class RunService {
             this.broadcastFileChanges(workspace.id);
         };
         const onToolCall = (call) => {
+            if (!acceptsEvent("tool.start"))
+                return;
             const at = spoken;
             // THE PLACEHOLDER THAT BELONGS TO THIS CALL, IF ONE IS ON SCREEN.
             //
@@ -1156,12 +1219,16 @@ export class RunService {
             enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at, thinkingAt, thinkingBlock: callThinkingBlock, ...(call.question ? { question: call.question } : {}) }));
         };
         const onToolUpdate = (call) => {
+            if (!acceptsEvent("tool.update"))
+                return;
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
             if (index === undefined)
                 return;
             enqueueTools("a tool call update", () => this.store.updateToolCall(conversation.id, assistant.id, index, { ...(call.args ? { args: call.args } : {}), ...(call.live !== undefined ? { live: call.live } : {}) }));
         };
         const onToolEnd = (call) => {
+            if (!acceptsEvent("tool.end", true))
+                return;
             // THE WRITE IS FINISHED, so the baseline can be CHECKED. The tracker recorded the file's etag when
             // the write was announced; if the file's etag now differs, the baseline really is the content
             // from before the write. If it does not, the baseline was taken too late to be shown, and the
@@ -1199,14 +1266,18 @@ export class RunService {
          * it is a global fold sequence, and restarting it would make the browser render two folds numbered 0.
          */
         const onSteerDelivered = (text) => {
+            if (!acceptsEvent("steer.delivered"))
+                return Promise.resolve();
             enqueueTools("a queued message being delivered", async () => {
                 // A delayed SDK delivery during abort still belongs to the stopped producer.
-                if (controller.signal.aborted)
+                if (!acceptsEvent("steer.delivered"))
                     return toolCalls;
                 const previous = assistant;
                 // Checkpoint first: the message being left behind is complete - Pi drains its queues at a turn
                 // boundary - and this is the last chance to write it durably with the lane it belongs to.
                 await this.store.checkpointMessage(conversation.id, previous.id);
+                if (!acceptsEvent("steer.delivered"))
+                    return toolCalls;
                 // WHICH MESSAGE THIS DELIVERY IS ABOUT. Pi announces the text it picked up, and Pi itself matches
                 // its own queue by that text (`agent-session.ts:1123`), so the same text resolves to the same
                 // message on both sides - including when two messages carry identical words, where both sides
@@ -1225,6 +1296,8 @@ export class RunService {
                 // assistant message for one of those would open an empty bubble before every single turn.
                 if (!delivered)
                     return toolCalls;
+                if (!ownsScope())
+                    return toolCalls;
                 const next = delivered.assistant;
                 this.broadcaster.broadcastState();
                 assistant = next;
@@ -1247,11 +1320,22 @@ export class RunService {
                 prompt,
                 signal: controller.signal,
                 cwd: workspace.path,
-                host: this.extensionUiService.createHost(conversation.id),
-                onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
+                host: {
+                    notify: (request) => { if (acceptsEvent("ui.notify"))
+                        uiHost.notify(request); },
+                    ask: (request) => acceptsEvent("ui.ask") ? uiHost.ask(request) : Promise.resolve({ cancelled: true }),
+                },
+                onPiQueue: (snapshot) => { if (acceptsEvent("pi.queue"))
+                    this.onPiQueue(conversation.id, snapshot); },
                 onSteerDelivered,
-                onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
-                onSessionFile: (path) => this.store.setConversationPiSessionFile(conversation.id, path),
+                onUserEntry: async (entryId) => {
+                    if (acceptsEvent("transcript.entry", true))
+                        await this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId);
+                },
+                onSessionFile: async (path) => {
+                    if (acceptsEvent("transcript.file", true))
+                        await this.store.setConversationPiSessionFile(conversation.id, path);
+                },
                 onToolCall,
                 onFileWrite,
                 onToolPreparing,
@@ -1265,7 +1349,7 @@ export class RunService {
                 // having received one. Pi announces the END of reasoning with `thinking_end` and puts nothing on
                 // the delta, so these two halves together are the whole lifecycle.
                 onThinking: async (delta) => {
-                    if (!delta)
+                    if (!delta || !acceptsEvent("thinking.delta"))
                         return;
                     // THINKING IS THE MODEL PRODUCING SOMETHING, SO THE TURN IS RUNNING. The contract above
                     // says a turn moves from `waiting` to `running` once the model has produced ANY signal -
@@ -1303,7 +1387,9 @@ export class RunService {
                     // published live. `promoteToRunning` answers whether it published one.
                     this.store.appendThinkingDeltaLive(conversation.id, assistant.id, delta, spoken, newBlock);
                     const promoted = await promoteToRunning();
-                    if (!promoted) {
+                    if (!ownsScope())
+                        return;
+                    if (!promoted && acceptsEvent("thinking.delta")) {
                         this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true, at: spoken, blockIndex: thinkingBlock });
                     }
                     scheduleCheckpoint();
@@ -1314,6 +1400,8 @@ export class RunService {
                 // block to every turn whose second reasoning run starts after the answer has already begun,
                 // because that block's `at` then differs from the previous one's.
                 onThinkingEnd: () => {
+                    if (!acceptsEvent("thinking.end"))
+                        return;
                     thinkingActive = false;
                     this.store.setThinkingActiveLive(conversation.id, assistant.id, false);
                     this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta: "", active: false });
@@ -1328,12 +1416,16 @@ export class RunService {
                 // publish a new message underneath it. One `await` at the top covers both, and costs nothing:
                 // the lane is empty most of the time.
                 await pendingTools;
+                if (!acceptsEvent("text.delta"))
+                    continue;
                 // `waiting` → `running` ON THE FIRST DELTA, before the live write. The conversation was
                 // opened in `waiting` (see `openTurn` / `openTurnOnSpecificMessage` / `openTurnOnMessage`),
                 // and the first response token is the observable fact that says the LLM is actually
                 // answering rather than hanging on auth / quota / network. `promoteToRunning` is a no-op
                 // after the first signal so this stays a one-shot status write, not a per-token one.
                 await promoteToRunning();
+                if (!acceptsEvent("text.delta"))
+                    continue;
                 if (!thinkingActive && thinkingBlock >= 0)
                     answerAfterThinking = true;
                 this.store.appendAssistantDeltaLive(conversation.id, assistant.id, delta);
@@ -1346,10 +1438,14 @@ export class RunService {
             }
         }
         finally {
+            scope.accepting = false;
+            traceScope("draining");
             // A failed or cancelled producer still owns live text and a checkpoint timer.
             // Drain the lane before the caller changes status or permits another turn.
-            this.store.setThinkingActiveLive(conversation.id, assistant.id, false);
-            checkpointPending = true;
+            if (ownsScope()) {
+                this.store.setThinkingActiveLive(conversation.id, assistant.id, false);
+                checkpointPending = true;
+            }
             checkpointNow();
             // A CALL THE MODEL STARTED AND NEVER RAN. Pi announces a call with `toolcall_start` and only tells
             // the host it is running with `tool_execution_start`, so an abort, a cancelled turn or an upstream
@@ -1357,7 +1453,7 @@ export class RunService {
             // rows, so each one kept 「生成参数中…」 for the rest of the conversation. Queued HERE, before the
             // await below, so it drains behind the last real tool write rather than racing it; `preparingRows`
             // is read here because by this line no further call can be announced.
-            if (preparingRows.size) {
+            if (ownsScope() && preparingRows.size) {
                 const stranded = [...preparingRows.values()].map((entry) => entry.row);
                 preparingRows.clear();
                 enqueueTools("unfinished tool calls", () => this.store.clearPreparingToolCalls(conversation.id, assistant.id, stranded));
@@ -1366,15 +1462,20 @@ export class RunService {
             // The positions are facts ABOUT THIS TURN and stop being true when it ends, so they go with it.
             // A dispatch whose POST arrives after this line gets no anchor and renders where it always did -
             // which is the honest outcome, because by then the call that asked for it may no longer be on screen.
-            this.toolCallSites.delete(conversation.id);
-            this.toolCallLanes.delete(conversation.id);
-            for (const [key, waiters] of this.toolCallWaiters) {
-                if (key.startsWith(`${conversation.id}:`))
-                    for (const wake of waiters)
-                        wake();
+            if (this.turnEventScopes.get(conversation.id) === scope) {
+                closedOwnScope = ownsScope();
+                this.turnEventScopes.delete(conversation.id);
+                this.toolCallSites.delete(conversation.id);
+                this.toolCallLanes.delete(conversation.id);
+                for (const [key, waiters] of this.toolCallWaiters) {
+                    if (key.startsWith(`${conversation.id}:`))
+                        for (const wake of waiters)
+                            wake();
+                }
             }
+            traceScope("closed");
         }
-        if (!controller.signal.aborted) {
+        if (closedOwnScope && this.activeRuns.get(conversation.id) === controller && !controller.signal.aborted) {
             const completed = this.store.snapshot().conversations.find(c => c.id === conversation.id);
             if (completed)
                 await this.memory?.completed(completed).catch(error => console.warn("Super Pi memory scheduling failed:", error));

package/dist/server/application/session-orchestrator-service.js

@@ -29,7 +29,14 @@ export class SessionOrchestratorService {
         if (!workspaceId) {
             throw new Error("创建兄弟会话需要指定工作区（或提供有效的父会话 ID）。");
         }
-        const conversationId = await this.conversationService.createConversation(workspaceId);
+        // THE PARENTAGE IS WRITTEN AT CREATION TIME, onto the conversation itself - not only into the
+        // in-memory ledger below. The ledger is task/status/progress metadata and dies with the process;
+        // the conversation's parentConversationId/origin is what the sidebar's session tree redraws
+        // from after a restart, so it has to be the persistent record.
+        const conversationId = await this.conversationService.createConversation(workspaceId, {
+            parentConversationId: options.parentConversationId,
+            origin: options.parentConversationId ? "orchestrator" : "user",
+        });
         // Set title if requested or derive from task
         if (options.title) {
             await this.conversationService.renameConversation(conversationId, options.title);

package/dist/server/command-handler.js

@@ -200,6 +200,10 @@ export class CommandHandler {
                 await this.conversationService.selectConversation(command.conversationId);
             return;
         }
+        if (command.type === "conversation.collapse") {
+            await this.conversationService.setCollapsed(command.conversationId, command.collapsed);
+            return;
+        }
         if (command.type === "conversation.archive") {
             await this.conversationService.archiveConversation(command.conversationId);
             return;

package/dist/server/store.d.ts

@@ -270,7 +270,17 @@ export declare class Store {
         model?: ModelSelection | null;
         thinkingLevel?: string | null;
         modelNotice?: string;
+        parentConversationId?: string;
+        origin?: "user" | "orchestrator";
     }): Promise<Conversation>;
+    /**
+     * Records (or clears) one conversation as collapsed in the sidebar's session tree. The list is a
+     * SET in array clothing - order means nothing, duplicates must not accumulate - and it follows the
+     * assign -> persist -> rollback pattern `setTerminalShell` established: the in-memory value is the
+     * previous value again the moment persistence fails, so a rejected write can never leave the
+     * screen and the disk disagreeing.
+     */
+    setConversationCollapsed(conversationId: string, collapsed: boolean): Promise<void>;
     /**
      * Copies a conversation into a NEW one, under an id the caller has already minted.
      *

package/dist/server/store.js

@@ -1086,11 +1086,49 @@ export class Store {
             }
             if (configuration.agentId)
                 conversation.agentId = configuration.agentId;
+            // THE SESSION TREE'S EDGE, WRITTEN AT BIRTH. Both fields describe how this conversation CAME TO
+            // BE, exactly like modelNotice above, so they are set once here and never rewritten: the tree
+            // the sidebar draws after a restart is the tree that was true when each session was opened.
+            // Written only when present, so a conversation created without them (the user's own "+") reads
+            // as a top-level one on every code path, including every state.json from before this field.
+            if (configuration.parentConversationId)
+                conversation.parentConversationId = configuration.parentConversationId;
+            if (configuration.origin)
+                conversation.origin = configuration.origin;
         }
         this.state.conversations.unshift(conversation);
         await this.persist();
         return structuredClone(conversation);
     }
+    /**
+     * Records (or clears) one conversation as collapsed in the sidebar's session tree. The list is a
+     * SET in array clothing - order means nothing, duplicates must not accumulate - and it follows the
+     * assign -> persist -> rollback pattern `setTerminalShell` established: the in-memory value is the
+     * previous value again the moment persistence fails, so a rejected write can never leave the
+     * screen and the disk disagreeing.
+     */
+    async setConversationCollapsed(conversationId, collapsed) {
+        const previous = this.state.collapsedConversationIds;
+        const next = new Set(previous ?? []);
+        if (collapsed)
+            next.add(conversationId);
+        else
+            next.delete(conversationId);
+        if (next.size === 0)
+            delete this.state.collapsedConversationIds;
+        else
+            this.state.collapsedConversationIds = [...next];
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            if (previous === undefined)
+                delete this.state.collapsedConversationIds;
+            else
+                this.state.collapsedConversationIds = previous;
+            throw error;
+        }
+    }
     /**
      * Copies a conversation into a NEW one, under an id the caller has already minted.
      *

package/dist/server/types.d.ts

@@ -516,6 +516,21 @@ export type Conversation = {
      * deleted agent degrades to "no role" instead of leaving a stale snapshot in state.json.
      */
     agentId?: string;
+    /**
+     * The conversation that opened this one, when an orchestrator agent created it. Absent for a
+     * conversation the user started. This is the session tree's edge, and it PERSISTS: the sidebar
+     * draws the hierarchy from it after a restart, which a server-side in-memory ledger cannot do.
+     * Absence also reads correctly on every state.json written before this field existed - no parent
+     * recorded simply means "top level", which is what those conversations genuinely are.
+     */
+    parentConversationId?: string;
+    /**
+     * Who opened this conversation. "user" for one the user started, "orchestrator" for one an agent
+     * created. Kept beside the parent id because a conversation can be an orchestrator's without
+     * having a parent (the top-level orchestrator), and because the context menu's "stop the session
+     * AND its queue" needs to know a queue exists without polling the orchestrator's ledger.
+     */
+    origin?: "user" | "orchestrator";
 };
 /**
  * One parsed agent definition, as read from an `agents/*.md` file. `prompt` is the file body and is the
@@ -863,7 +878,13 @@ export type AppState = {
     todosByConversation?: Record<string, TodoItem[]>;
     workflows?: WorkflowRun[];
     scheduledTasks?: ScheduledTask[];
-    customAgentDirs?: string[];
+    customAgentDirs?: string[]; /**
+     * Which conversations the reader has collapsed in the sidebar's session tree, by conversation id.
+     * Server-side so the tree looks the same after a restart and on another machine - the sidebar is a
+     * view of the PRODUCT's state, not of one browser's session. Absent (older state.json) means
+     * "nothing collapsed", which is the correct reading of a preference that did not exist yet.
+     */
+    collapsedConversationIds?: string[];
 };
 export type TodoItem = {
     id?: string;
@@ -1158,6 +1179,17 @@ export type ClientCommandBody =
 } | {
     type: "conversation.unarchive";
     conversationId: string;
+}
+/**
+ * Collapses or expands one conversation's whole subtree in the sidebar's session tree. The state
+ * lives SERVER-SIDE (`AppState.collapsedConversationIds`), not in the browser: the tree must look
+ * the same after a restart and on another machine, and a bare WS client must not be able to leave
+ * the server's truth and the screen's truth disagreeing about a preference the product owns.
+ */
+ | {
+    type: "conversation.collapse";
+    conversationId: string;
+    collapsed: boolean;
 } | {
     type: "conversation.rename";
     conversationId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.140",
+  "version": "0.1.141",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -75,6 +75,7 @@
     "scripts/image-upload.test.mjs",
     "scripts/extension-ui-e2e.test.mjs",
     "scripts/session-picker.test.mjs", "scripts/session-orchestrator.test.mjs", "scripts/session-orchestrator-tools.test.mjs",
+    "scripts/session-tree-collapse.test.mjs",
     "scripts/workspace-cwd.test.mjs",
     "scripts/subagents.test.mjs",
     "scripts/subagent-noise.test.mjs",