@evandu/super-pi 0.1.141 → 0.1.143

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-DHsjaI7m.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BJIfLtDs.css">
+    <script type="module" crossorigin src="/assets/index-iSnWwgJ-.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-6h_u-X47.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -74,7 +74,8 @@ export declare class ConversationService {
      */
     archiveConversation(conversationId: string): Promise<void>;
     /**
-     * Unarchives a conversation.
+     * Unarchives an archived tree root and every archived descendant. Descendants that are
+     * already active need no write; they are already in the live tree this restore rejoins.
      */
     unarchiveConversation(conversationId: string): Promise<void>;
     /**

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

@@ -1,5 +1,11 @@
 import { assertModelAllowed } from "../model-filter.js";
 import { newConversationId } from "../store.js";
+function isMissingPrimaryAgent(error, agentId) {
+    const message = error instanceof Error ? error.message : String(error);
+    const id = JSON.stringify(agentId);
+    return message.includes(`Agent ${id} 已失效或不是可用的 primary agent`)
+        || message.includes(`Agent ${id} 不存在或不是可用的 primary agent`);
+}
 /**
  * Service managing conversation lifecycle: creation, selection, archiving,
  * model/thinking/agent configuration, message reversion, and session forking.
@@ -104,12 +110,23 @@ export class ConversationService {
                 thinkingLevel = undefined;
             }
         }
-        const resolved = workspace.defaultAgentId
-            ? await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId)
-            : { model, thinkingLevel };
+        let agentNotice;
+        let resolved = { model, thinkingLevel };
+        if (workspace.defaultAgentId) {
+            try {
+                resolved = await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId);
+            }
+            catch (error) {
+                // Only an absent definition is downgraded. A present agent whose model, thinking level or
+                // workspace rules are invalid must still refuse rather than silently dropping its configuration.
+                if (!isMissingPrimaryAgent(error, workspace.defaultAgentId))
+                    throw error;
+                agentNotice = `你设的默认 Agent「${workspace.defaultAgentId}」已经不存在了，这个会话改用 Pi 默认 Agent。请在工作区设置里重新选择默认 Agent。`;
+            }
+        }
         // `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 } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
+        const defaults = { ...resolved, agentId: resolved.agentId ?? null, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(modelNotice ? { modelNotice } : {}), ...(agentNotice ? { agentNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
         const created = await this.store.createConversation(workspaceId, defaults);
         this.broadcaster.broadcastState();
         return created.id;
@@ -169,14 +186,15 @@ export class ConversationService {
      */
     async archiveConversation(conversationId) {
         this.runService.reviewMemoryBoundary(conversationId);
-        await this.store.archiveConversation(conversationId);
+        await this.store.archiveConversationTree(conversationId);
         this.broadcaster.broadcastState();
     }
     /**
-     * Unarchives a conversation.
+     * Unarchives an archived tree root and every archived descendant. Descendants that are
+     * already active need no write; they are already in the live tree this restore rejoins.
      */
     async unarchiveConversation(conversationId) {
-        await this.store.unarchiveConversation(conversationId);
+        await this.store.unarchiveConversationTree(conversationId);
         this.broadcaster.broadcastState();
     }
     /**

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

@@ -43,6 +43,7 @@ export interface WorkflowRunRequestBody {
     summary?: string;
     onFailure?: string;
     steps?: unknown;
+    nodes?: unknown;
     /** The per-turn dispatch capability, presented by the primary agent's extension. See `capability.ts`. */
     capability?: string;
     /** Pi's id for the tool call that asked for this, and resolved the same inert way as a sub-agent
@@ -148,6 +149,18 @@ export declare class RunService {
      * transcript - so a `role: "user"` is never impersonated.
      */
     enqueueExecResult(sessionId: string, exitCode: number, stdout: string, stderr: string): void;
+    /**
+     * Delivers an orchestrated child session's final output to its direct parent. This intentionally uses
+     * the same waiting-queue contract as background sub-agent results: one result per turn, ahead of
+     * unclaimed user messages, with an automatic follow-up turn only when the parent is idle.
+     */
+    enqueueSessionResult(input: {
+        conversationId: string;
+        parentConversationId?: string;
+        output: string;
+        resultPath: string;
+        error?: string;
+    }): Promise<void>;
     /**
      * Stops an active background task (spawned process or detached subagent) on user request.
      *
@@ -231,6 +244,8 @@ export declare class RunService {
      * Checks whether a conversation has an active turn running.
      */
     isRunning(conversationId: string): boolean;
+    /** Waits for this conversation's current producer, without waiting for unrelated sessions. */
+    waitForConversationIdle(conversationId: string): Promise<void>;
     /** Returns true while a stop has been requested and the old producer is still unwinding. */
     private isStopping;
     /**

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

@@ -3,7 +3,7 @@ import { checkSubagentDepth, parentDeniedTools, subagentRoster } from "../task-t
 import { newSubagentRunId } from "../subagents.js";
 import { readAgents } from "../agents.js";
 import { verifyCapability } from "../capability.js";
-import { validateWorkflowPlan, workflowSummary } from "../workflow.js";
+import { capText, validateWorkflowPlan, workflowSummary } from "../workflow.js";
 import { ensureNameIndex } from "../file-name-index.js";
 import { formatTurnFailure } from "../turn-failure.js";
 import { describeThrownWithStack } from "../failure-text.js";
@@ -304,6 +304,54 @@ export class RunService {
             }
         })());
     }
+    /**
+     * Delivers an orchestrated child session's final output to its direct parent. This intentionally uses
+     * the same waiting-queue contract as background sub-agent results: one result per turn, ahead of
+     * unclaimed user messages, with an automatic follow-up turn only when the parent is idle.
+     */
+    async enqueueSessionResult(input) {
+        await this.trackDetached((async () => {
+            const parentId = input.parentConversationId;
+            if (!parentId)
+                return;
+            const parent = this.store.conversation(parentId);
+            if (!parent || parent.archivedAt)
+                return;
+            // A corrupt or manually edited parent chain must not bounce a result around a cycle forever.
+            const seen = new Set();
+            let ancestor = parent;
+            while (ancestor && !seen.has(ancestor.id)) {
+                if (ancestor.id === input.conversationId)
+                    return;
+                seen.add(ancestor.id);
+                ancestor = ancestor.parentConversationId ? this.store.conversation(ancestor.parentConversationId) : undefined;
+            }
+            const failed = input.error !== undefined;
+            const state = failed ? "error" : "completed";
+            const tag = failed ? "task_error" : "task_result";
+            const output = failed ? input.error : input.output;
+            const inline = output.length <= 8_000 ? output : capText(output, 4_000, "子会话输出").text;
+            const summary = `Child session ${input.conversationId} ${failed ? "failed" : "completed"}. The full result is in ${input.resultPath}; use the read tool to inspect it.`;
+            const message = `<task id="${input.conversationId}" state="${state}" kind="session">\n<summary>${summary}</summary>\n<result_file>${input.resultPath}</result_file>\n<${tag}>\n${inline}\n</${tag}>\n</task>`;
+            const queued = await this.serializeConversation(parentId, async () => {
+                // The parent can disappear or become archived while this delivery waits for its command lane.
+                const current = this.store.conversation(parentId);
+                if (!current || current.archivedAt)
+                    return undefined;
+                const row = await this.store.addToolMessage(parentId, message, { delivery: "waiting" });
+                await this.moveAheadOfUnclaimed(parentId, row.id);
+                this.broadcaster.broadcastState();
+                return row;
+            });
+            if (!queued)
+                return;
+            if (!this.activeRuns.has(parentId) && !this.interruptTargets.has(parentId)) {
+                void this.processWaitingMessage(parentId, queued.id).catch((error) => {
+                    console.warn(`Super Pi: auto-trigger for child session result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                });
+            }
+        })());
+    }
     /**
      * Stops an active background task (spawned process or detached subagent) on user request.
      *
@@ -525,6 +573,16 @@ export class RunService {
     isRunning(conversationId) {
         return this.activeRuns.has(conversationId);
     }
+    /** Waits for this conversation's current producer, without waiting for unrelated sessions. */
+    async waitForConversationIdle(conversationId) {
+        while (this.activeRuns.has(conversationId)) {
+            const completion = this.runCompletions.get(conversationId)?.promise;
+            if (completion)
+                await completion;
+            else
+                await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
     /** Returns true while a stop has been requested and the old producer is still unwinding. */
     isStopping(conversationId) {
         // Use the same identity as the slot; a separate conversation-keyed flag can leak across owners.

package/dist/server/application/session-orchestrator-service.d.ts

@@ -4,6 +4,8 @@ import type { RunService } from "./run-service.js";
 import type { SessionLedger } from "../session-ledger.js";
 import type { EventBroadcaster } from "../server-context.js";
 import type { RunStatus } from "../types.js";
+export declare const SESSION_OUTPUT_CHAR_LIMIT: number;
+export declare const sessionResultRelativePath: (conversationId: string) => string;
 export interface SpawnSessionOptions {
     /** The high-level task to be performed by the sibling session. */
     task: string;
@@ -54,6 +56,9 @@ export interface SessionSummary {
     updatedAt: string;
     createdAt?: number;
     lastProgress?: string;
+    output?: string;
+    outputPath?: string;
+    outputTruncated?: boolean;
 }
 /**
  * Orchestrator service coordinating sibling and child conversations.
@@ -83,11 +88,14 @@ export declare class SessionOrchestratorService {
     }): Promise<{
         conversationId: string;
     }>;
+    private persistSessionResult;
     /**
      * Returns a high-level summary of a session's progress without returning full transcripts.
      * Uses narrow store reader `store.conversation(id)` to avoid cloning the entire state.
      */
-    status(conversationId: string): Promise<SessionSummary>;
+    status(conversationId: string, options?: {
+        includeOutput?: boolean;
+    }): Promise<SessionSummary>;
     /**
      * Lists summaries of all sessions, optionally filtered by parent conversation.
      */

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

@@ -1,3 +1,8 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { capText } from "../workflow.js";
+export const SESSION_OUTPUT_CHAR_LIMIT = 64 * 1024;
+export const sessionResultRelativePath = (conversationId) => `.super-pi/session-results/${conversationId}.md`;
 /**
  * Orchestrator service coordinating sibling and child conversations.
  *
@@ -84,22 +89,66 @@ export class SessionOrchestratorService {
             status: "running",
         });
         const runPromise = this.runService.enqueueAndRun(conversationId, content);
-        if (options?.wait) {
-            await runPromise;
-        }
-        else {
-            void runPromise.catch((error) => {
-                console.warn(`Super Pi: dispatch failed for conversation ${conversationId}:`, error instanceof Error ? error.message : String(error));
+        const completion = (async () => {
+            let failure;
+            try {
+                await runPromise;
+                // A dispatch into an already-running child returns after queueing, not after that child settles.
+                await this.runService.waitForConversationIdle(conversationId);
+            }
+            catch (error) {
+                failure = error;
+                await this.runService.waitForConversationIdle(conversationId);
+            }
+            try {
+                const result = await this.persistSessionResult(conversationId, failure);
+                if (result) {
+                    const current = this.store.conversation(conversationId);
+                    await this.runService.enqueueSessionResult({
+                        conversationId,
+                        parentConversationId: current?.parentConversationId,
+                        output: result.output,
+                        resultPath: result.resultPath,
+                        ...(failure !== undefined ? { error: result.output } : {}),
+                    });
+                }
+            }
+            catch (error) {
+                // Result reporting is best-effort: a missing/archived parent or a workspace I/O problem must not
+                // turn an already-finished child turn into a second failure.
+                console.warn(`Super Pi: session result callback failed for ${conversationId}:`, error instanceof Error ? error.message : String(error));
+            }
+            if (failure !== undefined) {
+                console.warn(`Super Pi: dispatch failed for conversation ${conversationId}:`, failure instanceof Error ? failure.message : String(failure));
                 this.ledger.update(conversationId, { status: "failed" });
-            });
-        }
+                throw failure;
+            }
+        })();
+        if (options?.wait)
+            await completion;
+        else
+            void completion.catch(() => undefined);
         return { conversationId };
     }
+    async persistSessionResult(conversationId, failure) {
+        const conversation = this.store.conversation(conversationId);
+        const workspace = conversation ? this.store.workspace(conversation.workspaceId) : undefined;
+        if (!conversation || !workspace)
+            return undefined;
+        const output = failure !== undefined
+            ? (failure instanceof Error ? failure.message : String(failure))
+            : ([...conversation.messages].reverse().find((message) => message.role === "assistant")?.content ?? "");
+        const resultPath = sessionResultRelativePath(conversationId);
+        const resultDirectory = join(workspace.path, ".super-pi", "session-results");
+        await mkdir(resultDirectory, { recursive: true });
+        await writeFile(join(resultDirectory, `${conversationId}.md`), output, "utf8");
+        return { output, resultPath };
+    }
     /**
      * Returns a high-level summary of a session's progress without returning full transcripts.
      * Uses narrow store reader `store.conversation(id)` to avoid cloning the entire state.
      */
-    async status(conversationId) {
+    async status(conversationId, options) {
         const conversation = this.store.conversation(conversationId);
         if (!conversation) {
             throw new Error(`找不到会话：${conversationId}`);
@@ -133,6 +182,24 @@ export class SessionOrchestratorService {
             }
         }
         const hasPendingQuestion = this.store.pendingQuestions(conversationId).length > 0;
+        let output;
+        let outputTruncated;
+        const resultPath = sessionResultRelativePath(conversationId);
+        if (options?.includeOutput) {
+            const workspace = this.store.workspace(conversation.workspaceId);
+            if (workspace) {
+                try {
+                    const fullOutput = await readFile(join(workspace.path, ".super-pi", "session-results", `${conversationId}.md`), "utf8");
+                    const capped = capText(fullOutput, SESSION_OUTPUT_CHAR_LIMIT, "会话输出");
+                    output = capped.text;
+                    outputTruncated = capped.truncated;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+        }
         // Sync ledger status if present
         if (ledgerEntry && ledgerEntry.status !== conversation.status) {
             this.ledger.update(conversationId, {
@@ -146,7 +213,7 @@ export class SessionOrchestratorService {
             title: conversation.title,
             status: conversation.status,
             origin: ledgerEntry?.origin ?? "user",
-            parentConversationId: ledgerEntry?.parentConversationId,
+            parentConversationId: conversation.parentConversationId ?? ledgerEntry?.parentConversationId,
             task: ledgerEntry?.task,
             messageCount: messages.length,
             turnCount,
@@ -158,6 +225,8 @@ export class SessionOrchestratorService {
             updatedAt: conversation.updatedAt,
             createdAt: ledgerEntry?.createdAt,
             lastProgress: ledgerEntry?.lastProgress ?? lastAssistantSnippet,
+            ...(options?.includeOutput ? { outputPath: resultPath } : {}),
+            ...(output !== undefined ? { output, outputTruncated } : {}),
         };
     }
     /**

package/dist/server/http-server.js

@@ -1472,15 +1472,10 @@ export function createHttpServer(options) {
                         json(503, { error: "编排服务未就绪" });
                         return;
                     }
-                    if (body.capability && body.parentConversationId) {
-                        const verdict = runService.verifyPrimaryCapability(body.parentConversationId, body.capability);
-                        if (!verdict.ok) {
-                            json(403, { error: verdict.message });
-                            return;
-                        }
-                    }
-                    else if (context.accessToken && !isAuthorized(request, context.accessToken)) {
-                        json(401, { error: "未授权" });
+                    const callerConversationId = body.callerConversationId ?? body.parentConversationId ?? "";
+                    const verdict = runService.verifyPrimaryCapability(callerConversationId, body.capability);
+                    if (!verdict.ok) {
+                        json(403, { error: verdict.message });
                         return;
                     }
                     const action = (body.action || "").trim();
@@ -1513,7 +1508,7 @@ export function createHttpServer(options) {
                     if (action === "status") {
                         if (!body.conversationId)
                             throw new Error("status requires conversationId");
-                        const summary = await service.status(body.conversationId);
+                        const summary = await service.status(body.conversationId, { includeOutput: body.includeOutput });
                         json(200, { ok: true, summary });
                         return;
                     }
@@ -1554,12 +1549,18 @@ export function createHttpServer(options) {
                     return;
                 }
                 const conversationId = url.searchParams.get("conversationId");
+                const callerConversationId = url.searchParams.get("callerConversationId") ?? url.searchParams.get("parentId") ?? "";
+                const verdict = runService.verifyPrimaryCapability(callerConversationId, url.searchParams.get("capability"));
+                if (!verdict.ok) {
+                    response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: verdict.message }));
+                    return;
+                }
                 if (!conversationId) {
                     response.writeHead(400, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "缺少 conversationId" }));
                     return;
                 }
                 try {
-                    const summary = await service.status(conversationId);
+                    const summary = await service.status(conversationId, { includeOutput: url.searchParams.get("includeOutput") === "true" });
                     response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ ok: true, summary }));
                 }
                 catch (error) {
@@ -1578,6 +1579,12 @@ export function createHttpServer(options) {
                     return;
                 }
                 const parentId = url.searchParams.get("parentId") || undefined;
+                const callerConversationId = url.searchParams.get("callerConversationId") ?? parentId ?? "";
+                const verdict = runService.verifyPrimaryCapability(callerConversationId, url.searchParams.get("capability"));
+                if (!verdict.ok) {
+                    response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: verdict.message }));
+                    return;
+                }
                 try {
                     const sessions = await service.list(parentId);
                     response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ ok: true, sessions }));

package/dist/server/runtime.js

@@ -21,7 +21,7 @@ import { describeDeliveredUserMessage, describePiQueue, handleSessionEvent, Turn
 // paths recognise a delivery identically. Re-exported because they were part of this module's surface.
 export { describeDeliveredUserMessage, describePiQueue } from "./pi-session-events.js";
 import { createPiSession, createSdkCatalog, piSdkAvailable, resolveTranscriptFile, superPiExtensionPaths } from "./pi-session.js";
-import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, ORCHESTRATOR_ENDPOINT_ENV, SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, rosterPayload, } from "./task-tool.js";
+import { TASK_CONVERSATION_ENV, PARENT_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, ORCHESTRATOR_ENDPOINT_ENV, SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
@@ -696,7 +696,7 @@ export class PiRpcRuntime {
      * its environment once, when it is loaded) and a token minted per turn would be replaced before the
      * second turn of the conversation, leaving the extension holding a value the server had forgotten.
      */
-    async taskExtensionEnv(conversationId) {
+    async taskExtensionEnv(conversationId, parentConversationId) {
         const { agents, problems } = await readAgents(this.agents.dir, { mode: "subagent" });
         for (const problem of problems)
             console.warn(`PiRpcRuntime: ${problem.file} is not a usable sub-agent - ${problem.message}`);
@@ -705,6 +705,7 @@ export class PiRpcRuntime {
             [TASK_EXEC_ENDPOINT_ENV]: this.options.execEndpoint ?? "",
             [TASK_ROSTER_ENV]: rosterPayload(agents),
             [TASK_CONVERSATION_ENV]: conversationId,
+            [PARENT_CONVERSATION_ENV]: parentConversationId ?? "",
             [TASK_DEPTH_ENV]: "0",
             [TODO_ENDPOINT_ENV]: this.options.todoEndpoint ?? "",
             [SCHEDULED_TASK_ENDPOINT_ENV]: this.options.scheduledTaskEndpoint ?? "",
@@ -737,9 +738,9 @@ export class PiRpcRuntime {
      * here. A session lives for many turns, so its credential is minted when the session is created (see
      * `PiSessionPool.acquire`) and the server separately requires a running turn for it to be usable.
      */
-    async oneShotExtensionEnv(conversationId, capability) {
+    async oneShotExtensionEnv(conversationId, capability, parentConversationId) {
         return {
-            ...(await this.taskExtensionEnv(conversationId)),
+            ...(await this.taskExtensionEnv(conversationId, parentConversationId)),
             [TASK_CAPABILITY_ENV]: capability,
             SUPER_PI_TOOLS_CAPABILITY: capability,
         };
@@ -800,7 +801,7 @@ export class PiRpcRuntime {
             ...(systemPromptFile ? { systemPromptFile } : {}),
             ...(agent?.promptMode ? { systemPromptMode: agent.promptMode } : {}),
             extensionPaths: superPiExtensionPaths(repositoryRootFrom()),
-            extensionEnv: await this.taskExtensionEnv(conversation.id),
+            extensionEnv: await this.taskExtensionEnv(conversation.id, conversation.parentConversationId),
             ...(conversation.model ? { model: { provider: conversation.model.provider, modelId: conversation.model.modelId } } : {}),
             ...(conversation.thinkingLevel ? { thinkingLevel: conversation.thinkingLevel } : {}),
         };
@@ -1476,7 +1477,7 @@ export class PiRpcRuntime {
             // every turn would silently replace the child's environment with whatever THIS process has at
             // spawn time. Inheriting is what an omitted `env` already does, so the two paths differ in nothing
             // but the four documented additions.
-            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled || documentsEnabled || webEnabled || feishuEnabled) ? { env: { ...process.env, ...(oneShotCapability ? await this.oneShotExtensionEnv(conversation.id, oneShotCapability) : {}), ...(memoryEnabled ? {
+            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled || documentsEnabled || webEnabled || feishuEnabled) ? { env: { ...process.env, ...(oneShotCapability ? await this.oneShotExtensionEnv(conversation.id, oneShotCapability, conversation.parentConversationId) : {}), ...(memoryEnabled ? {
                         SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT,
                         SUPER_PI_MEMORY_TOKEN: memoryToken,
                         SUPER_PI_MEMORY_REVIEW: memoryReview ? "1" : "0",

package/dist/server/store.d.ts

@@ -266,10 +266,11 @@ export declare class Store {
         conversationId?: string;
     }): AppState;
     createConversation(workspaceId: string, configuration?: {
-        agentId?: string;
+        agentId?: string | null;
         model?: ModelSelection | null;
         thinkingLevel?: string | null;
         modelNotice?: string;
+        agentNotice?: string;
         parentConversationId?: string;
         origin?: "user" | "orchestrator";
     }): Promise<Conversation>;
@@ -341,6 +342,16 @@ export declare class Store {
     /** Restoring deletes the key rather than setting it to null, so a fully restored conversation serializes
      *  byte-identically to one that was never archived. `delete` is legal here because the field is optional. */
     unarchiveConversation(conversationId: string): Promise<void>;
+    /**
+     * Archives one whole tree as one state write. Only a conversation with no existing parent may
+     * start it; an archived parent is still a parent, so its active descendants cannot be archived
+     * independently. All running checks happen before the first mutation, making rejection all-or-none.
+     */
+    archiveConversationTree(conversationId: string): Promise<void>;
+    /** Restores one archived tree in one write; active descendants are already restored by definition. */
+    unarchiveConversationTree(conversationId: string): Promise<void>;
+    /** Pre-order traversal with cycle protection; archived nodes are traversed, not treated as leaves. */
+    private conversationSubtree;
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
      * for exactly the reason archive is: `updatedAt` is the sidebar's recency key, so bumping it would

package/dist/server/store.js

@@ -2,6 +2,7 @@ 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";
+import { serverTimeZone } from "./time-zone.js";
 function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
  *
@@ -1031,7 +1032,7 @@ export class Store {
         // Legacy sockets still receive complete visible transcripts. Project before cloning so a closed
         // workspace's retained history is never copied just to discard it afterwards.
         if (scope === undefined)
-            return structuredClone({ ...this.state, workspaces, conversations: visible });
+            return structuredClone({ ...this.state, workspaces, conversations: visible, serverTimeZone: serverTimeZone() });
         // A focused socket keeps every sidebar row, but owns only the selected transcript. An empty scope
         // deliberately loads none; a missing/closed selection must not expose retained workspace history.
         const selectedId = visible.find((item) => item.id === scope.conversationId)?.id;
@@ -1045,6 +1046,11 @@ export class Store {
             ...this.state,
             workspaces,
             conversations,
+            // THE CLOCK THE SERVER SCHEDULES BY, NAMED. The scheduled-task panel renders 「每天 09:00」 and
+            // 「下次」 from two different sources - a configured string and an epoch millisecond - and a
+            // browser on another machine renders the epoch in ITS timezone. Without this field the two
+            // lines in one row mean two different wall clocks and nothing says so.
+            serverTimeZone: serverTimeZone(),
             subagentRuns: this.state.subagentRuns.filter((run) => run.conversationId === selectedId),
             ...(this.state.workflows ? { workflows: this.state.workflows.filter((run) => run.conversationId === selectedId) } : {}),
             ...(this.state.todosByConversation ? { todosByConversation: selectedId && this.state.todosByConversation[selectedId]
@@ -1060,7 +1066,7 @@ export class Store {
         // here and never consulted again: the session picker edits the conversation's own fields, so an
         // existing conversation is untouched by later workspace settings, and a workspace edit never
         // rewrites history. Field by field, never a spread, for the same reason setConversationModel
-        // narrows: the type declares three fields, so three fields are written.
+        // narrows: every inherited field has an explicit birth override, including null for Pi's default.
         if (workspace.defaultModel)
             conversation.model = { provider: workspace.defaultModel.provider, modelId: workspace.defaultModel.modelId, label: workspace.defaultModel.label };
         if (workspace.defaultThinkingLevel)
@@ -1072,6 +1078,8 @@ export class Store {
             // rewritten: it describes how this conversation came to be, not what is true right now.
             if (configuration.modelNotice !== undefined)
                 conversation.modelNotice = configuration.modelNotice;
+            if (configuration.agentNotice !== undefined)
+                conversation.agentNotice = configuration.agentNotice;
             if (configuration.model !== undefined) {
                 if (configuration.model)
                     conversation.model = { ...configuration.model };
@@ -1084,8 +1092,12 @@ export class Store {
                 else
                     delete conversation.thinkingLevel;
             }
-            if (configuration.agentId)
-                conversation.agentId = configuration.agentId;
+            if (configuration.agentId !== undefined) {
+                if (configuration.agentId)
+                    conversation.agentId = configuration.agentId;
+                else
+                    delete conversation.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.
@@ -1232,6 +1244,67 @@ export class Store {
         delete conversation.archivedAt;
         await this.persistMetadata(conversationId);
     }
+    /**
+     * Archives one whole tree as one state write. Only a conversation with no existing parent may
+     * start it; an archived parent is still a parent, so its active descendants cannot be archived
+     * independently. All running checks happen before the first mutation, making rejection all-or-none.
+     */
+    async archiveConversationTree(conversationId) {
+        const root = this.requireConversation(conversationId);
+        if (root.parentConversationId && this.state.conversations.some(item => item.id === root.parentConversationId)) {
+            throw new Error("子会话不能独立归档，请从根会话归档整棵树");
+        }
+        if (root.archivedAt)
+            return;
+        const active = this.conversationSubtree(root).filter(item => !item.archivedAt);
+        const running = active.find(item => item.status === "running");
+        if (running)
+            throw new Error(`会话「${running.title}」正在运行，无法归档整棵树，请先停止运行`);
+        const archivedAt = now();
+        for (const conversation of active)
+            conversation.archivedAt = archivedAt;
+        await this.persist();
+    }
+    /** Restores one archived tree in one write; active descendants are already restored by definition. */
+    async unarchiveConversationTree(conversationId) {
+        const root = this.requireConversation(conversationId);
+        const parent = root.parentConversationId
+            ? this.state.conversations.find(item => item.id === root.parentConversationId)
+            : undefined;
+        if (parent?.archivedAt)
+            throw new Error("归档树中的子会话不能独立恢复，请从归档树的根会话恢复整棵树");
+        if (!root.archivedAt)
+            return;
+        const archived = this.conversationSubtree(root).filter(item => item.archivedAt);
+        for (const conversation of archived)
+            delete conversation.archivedAt;
+        await this.persist();
+    }
+    /** Pre-order traversal with cycle protection; archived nodes are traversed, not treated as leaves. */
+    conversationSubtree(root) {
+        const byParent = new Map();
+        for (const conversation of this.state.conversations) {
+            if (conversation.workspaceId !== root.workspaceId || !conversation.parentConversationId)
+                continue;
+            const siblings = byParent.get(conversation.parentConversationId);
+            if (siblings)
+                siblings.push(conversation);
+            else
+                byParent.set(conversation.parentConversationId, [conversation]);
+        }
+        const result = [];
+        const visited = new Set();
+        const walk = (conversation) => {
+            if (visited.has(conversation.id))
+                return;
+            visited.add(conversation.id);
+            result.push(conversation);
+            for (const child of byParent.get(conversation.id) ?? [])
+                walk(child);
+        };
+        walk(root);
+        return result;
+    }
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
      * for exactly the reason archive is: `updatedAt` is the sidebar's recency key, so bumping it would