@evandu/super-pi 0.1.142 → 0.1.144

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-CX5gWDve.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DMhigTiY.css">
+    <script type="module" crossorigin src="/assets/index-BLWr70ej.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Xaui0uUI.css">
   </head>
   <body>
     <div id="root"></div>

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.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]

package/dist/server/task-tool.d.ts

@@ -71,6 +71,8 @@ export declare const TASK_EXEC_ENDPOINT_ENV = "SUPER_PI_EXEC_ENDPOINT";
 export declare const TASK_ROSTER_ENV = "SUPER_PI_TASK_ROSTER";
 /** The conversation the dispatch belongs to. The server resolves the workspace from this itself. */
 export declare const TASK_CONVERSATION_ENV = "SUPER_PI_TASK_CONVERSATION";
+/** The conversation that spawned this one. Empty means a top-level conversation. */
+export declare const PARENT_CONVERSATION_ENV = "SUPER_PI_PARENT_CONVERSATION";
 /** How many task hops deep this process already is. A primary is `0`. See `DEFAULT_SUBAGENT_DEPTH`. */
 export declare const TASK_DEPTH_ENV = "SUPER_PI_TASK_DEPTH";
 /**
@@ -255,9 +257,9 @@ export declare const SESSION_STATUS_TOOL_NAME = "session_status";
 export declare const SESSION_DISPATCH_TOOL_NAME = "session_dispatch";
 export declare const SESSION_STOP_TOOL_NAME = "session_stop";
 /** Model-facing description for session_spawn. */
-export declare const SESSION_SPAWN_DESCRIPTION = "Create a new sibling conversation in the current workspace and immediately dispatch its initial task.\n\nDIFFERENCE FROM THE 'task' TOOL:\n- The 'task' tool delegates to a transient, one-shot subagent process (scout, critic, patcher) that runs once, returns its final text, and terminates. It has no conversation history and does not appear in the workspace sidebar.\n- 'session_spawn' creates a real, persistent sibling CONVERSATION in Super Pi. It appears in the sidebar, retains multi-turn message history, can receive follow-up messages via session_dispatch, can be inspected via session_status, and can be stopped via session_stop. The user can also switch to it in the Web UI.\n\nWHEN TO USE THIS:\n- Long-running, multi-phase tracks of work that require ongoing context, multiple turns of dialogue, or independent user visibility.\n- Parallel work streams (e.g., Track A: backend refactor, Track B: frontend component update) where both need full conversational capabilities.\n- When the user asks you to act as an orchestrator/manager who delegates to multiple sessions.\n\nWHEN NOT TO USE THIS:\n- For one-off, focused delegation with a single answer: use 'task' (with scout/critic/patcher). It is faster, cheaper, and returns directly to your transcript.\n- For running shell commands or build watchers: use 'run_async'.\n- For a linear multi-step subagent pipeline: use 'workflow'.\n\nUsage notes:\n1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.\n2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.\n3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.";
+export declare const SESSION_SPAWN_DESCRIPTION = "Create a new sibling conversation in the current workspace and immediately dispatch its initial task.\n\nDIFFERENCE FROM THE 'task' TOOL:\n- The 'task' tool delegates to a transient, one-shot subagent process (scout, critic, patcher) that runs once, returns its final text, and terminates. It has no conversation history and does not appear in the workspace sidebar.\n- 'session_spawn' creates a real, persistent sibling CONVERSATION in Super Pi. It appears in the sidebar, retains multi-turn message history, can receive follow-up messages via session_dispatch, can be inspected via session_status, and can be stopped via session_stop. The user can also switch to it in the Web UI.\n\nWHEN TO USE THIS:\n- Long-running, multi-phase tracks of work that require ongoing context, multiple turns of dialogue, or independent user visibility.\n- Parallel work streams (e.g., Track A: backend refactor, Track B: frontend component update) where both need full conversational capabilities.\n- When the user asks you to act as an orchestrator/manager who delegates to multiple sessions.\n\nWHEN NOT TO USE THIS:\n- For one-off, focused delegation with a single answer: use 'task' (with scout/critic/patcher). It is faster, cheaper, and returns directly to your transcript.\n- For running shell commands or build watchers: use 'run_async'.\n- For a linear multi-step subagent pipeline: use 'workflow'.\n\nUsage notes:\n1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.\n2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.\n3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.\n4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.";
 /** Model-facing description for session_status. */
-export declare const SESSION_STATUS_DESCRIPTION = "Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.\n\nWHEN TO USE THIS:\n- To check whether a spawned sibling conversation is still running, has finished (idle), is stopped, or encountered an error.\n- To read the latest assistant progress snippet without bloating your context with the session's entire raw message transcript.\n- To list all sibling conversations under your coordination when conversationId is omitted.\n\nUsage notes:\n1. When 'conversationId' is provided: returns a compact summary for that specific session, including its run status ('idle', 'running', 'waiting', 'stopped', 'failed'), messageCount, turnCount, lastAssistantSnippet, lastUserSnippet, activeTool, and error (if any).\n2. When 'conversationId' is omitted: returns a summary list of ALL sibling conversations spawned by this orchestrator session.\n3. This tool never returns full transcripts; it returns concise summaries and snippets to keep your context window lean.";
+export declare const SESSION_STATUS_DESCRIPTION = "Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.\n\nWHEN TO USE THIS:\n- To check whether a spawned sibling conversation is still running, has finished (idle), is stopped, or encountered an error.\n- To read the latest assistant progress snippet without bloating your context with the session's entire raw message transcript.\n- To list all sibling conversations under your coordination when conversationId is omitted.\n\nUsage notes:\n1. When 'conversationId' is provided: returns a compact summary for that specific session, including its run status ('idle', 'running', 'waiting', 'stopped', 'failed'), messageCount, turnCount, lastAssistantSnippet, lastUserSnippet, activeTool, and error (if any).\n2. When 'conversationId' is omitted: returns a summary list of sibling conversations whose direct parent is 'parentConversationId' (the calling session by default).\n3. By default it never returns full transcripts; concise summaries keep your context window lean. Set 'includeOutput' with a conversationId to read the final output from its result file, capped to the last 64Ki characters with an explicit truncation notice.";
 /** Model-facing description for session_dispatch. */
 export declare const SESSION_DISPATCH_DESCRIPTION = "Send a message, follow-up instructions, or steering guidance to an existing sibling conversation.\n\nWHEN TO USE THIS:\n- To follow up with a sibling session after reading its progress with session_status.\n- To give feedback, provide additional requirements, or answer a question from a sibling session.\n- To kick off a new turn on an idle or stopped sibling session.\n\nUsage notes:\n1. 'conversationId' is required and must identify an existing sibling conversation.\n2. 'content' is the text instruction sent to that session, just as if typed by a user in that session's chat.\n3. Dispatch is ASYNCHRONOUS by default: it enqueues the message into the session's queue and returns immediately.\n4. If the sibling session is currently busy running a turn, the dispatched message is placed in its waiting queue and processed when the active turn completes.";
 /** Model-facing description for session_stop. */

package/dist/server/task-tool.js

@@ -70,6 +70,8 @@ export const TASK_EXEC_ENDPOINT_ENV = "SUPER_PI_EXEC_ENDPOINT";
 export const TASK_ROSTER_ENV = "SUPER_PI_TASK_ROSTER";
 /** The conversation the dispatch belongs to. The server resolves the workspace from this itself. */
 export const TASK_CONVERSATION_ENV = "SUPER_PI_TASK_CONVERSATION";
+/** The conversation that spawned this one. Empty means a top-level conversation. */
+export const PARENT_CONVERSATION_ENV = "SUPER_PI_PARENT_CONVERSATION";
 /** How many task hops deep this process already is. A primary is `0`. See `DEFAULT_SUBAGENT_DEPTH`. */
 export const TASK_DEPTH_ENV = "SUPER_PI_TASK_DEPTH";
 /**
@@ -379,7 +381,8 @@ WHEN NOT TO USE THIS:
 Usage notes:
 1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.
 2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.
-3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.`;
+3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.
+4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.`;
 /** Model-facing description for session_status. */
 export const SESSION_STATUS_DESCRIPTION = `Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.
 
@@ -390,8 +393,8 @@ WHEN TO USE THIS:
 
 Usage notes:
 1. When 'conversationId' is provided: returns a compact summary for that specific session, including its run status ('idle', 'running', 'waiting', 'stopped', 'failed'), messageCount, turnCount, lastAssistantSnippet, lastUserSnippet, activeTool, and error (if any).
-2. When 'conversationId' is omitted: returns a summary list of ALL sibling conversations spawned by this orchestrator session.
-3. This tool never returns full transcripts; it returns concise summaries and snippets to keep your context window lean.`;
+2. When 'conversationId' is omitted: returns a summary list of sibling conversations whose direct parent is 'parentConversationId' (the calling session by default).
+3. By default it never returns full transcripts; concise summaries keep your context window lean. Set 'includeOutput' with a conversationId to read the final output from its result file, capped to the last 64Ki characters with an explicit truncation notice.`;
 /** Model-facing description for session_dispatch. */
 export const SESSION_DISPATCH_DESCRIPTION = `Send a message, follow-up instructions, or steering guidance to an existing sibling conversation.
 

package/dist/server/time-zone.d.ts

@@ -0,0 +1,20 @@
+/**
+ * THE CLOCK THIS PROCESS SCHEDULES BY.
+ *
+ * A scheduled task's 「每天 09:00」 is a WALL CLOCK, and the wall clock it means is the one this
+ * process runs on - the machine holding the server. The browser that reads the result may be on a
+ * different clock entirely, so a moment computed here and rendered there says one thing in one place
+ * and another thing in the other.
+ *
+ * The name is the IANA zone rather than an offset, because an offset is ambiguous twice a year: it
+ * does not say whether 「09:00」 is the summer or the winter offset, and a task that drifts by an
+ * hour twice a year is the kind of bug nobody reports.
+ */
+export declare function serverTimeZone(): string;
+/**
+ * The zone's short name for the moment, the way a person would say it: 「GMT+8」, 「UTC」.
+ *
+ * Used in the panel next to a time, so the reader can tell WHICH clock they are looking at without
+ * having to know what 「Asia/Shanghai」 means.
+ */
+export declare function timeZoneLabel(at?: number): string;

package/dist/server/time-zone.js

@@ -0,0 +1,32 @@
+/**
+ * THE CLOCK THIS PROCESS SCHEDULES BY.
+ *
+ * A scheduled task's 「每天 09:00」 is a WALL CLOCK, and the wall clock it means is the one this
+ * process runs on - the machine holding the server. The browser that reads the result may be on a
+ * different clock entirely, so a moment computed here and rendered there says one thing in one place
+ * and another thing in the other.
+ *
+ * The name is the IANA zone rather than an offset, because an offset is ambiguous twice a year: it
+ * does not say whether 「09:00」 is the summer or the winter offset, and a task that drifts by an
+ * hour twice a year is the kind of bug nobody reports.
+ */
+export function serverTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+/**
+ * The zone's short name for the moment, the way a person would say it: 「GMT+8」, 「UTC」.
+ *
+ * Used in the panel next to a time, so the reader can tell WHICH clock they are looking at without
+ * having to know what 「Asia/Shanghai」 means.
+ */
+export function timeZoneLabel(at = Date.now()) {
+    const zone = serverTimeZone();
+    try {
+        const parts = new Intl.DateTimeFormat("en-US", { timeZone: zone, timeZoneName: "shortOffset" }).formatToParts(at);
+        const name = parts.find((part) => part.type === "timeZoneName")?.value;
+        return name ?? zone;
+    }
+    catch {
+        return zone;
+    }
+}

package/dist/server/types.d.ts

@@ -888,6 +888,12 @@ export type AppState = {
      * "nothing collapsed", which is the correct reading of a preference that did not exist yet.
      */
     collapsedConversationIds?: string[];
+    /**
+     * THE CLOCK THIS SERVER SCHEDULES BY. A scheduled task's 「每天 09:00」 is the SERVER's wall clock,
+     * and the panel has to say so, because the browser rendering 「下次」 may be on a different clock
+     * entirely. Without this the two lines in one row quietly mean two different things.
+     */
+    serverTimeZone?: string;
 };
 export type TodoItem = {
     id?: string;
@@ -917,6 +923,9 @@ export type OrchestratorSessionSummary = {
     updatedAt: string;
     createdAt?: number;
     lastProgress?: string;
+    output?: string;
+    outputPath?: string;
+    outputTruncated?: boolean;
 };
 /**
  * What Pi reports about ITS OWN queue, forwarded to the browser as it arrives.