@evandu/super-pi 0.1.139 → 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-B32VZVYx.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Bdym8BPo.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.d.ts

@@ -0,0 +1,113 @@
+import type { Store } from "../store.js";
+import type { ConversationService } from "./conversation-service.js";
+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 interface SpawnSessionOptions {
+    /** The high-level task to be performed by the sibling session. */
+    task: string;
+    /** Parent conversation initiating the orchestration, if any. */
+    parentConversationId?: string;
+    /** Workspace ID for the new session. Inherited from parent if omitted. */
+    workspaceId?: string;
+    /** Optional custom title for the new session. */
+    title?: string;
+    /** Optional agent override for the new session. */
+    agentId?: string;
+    /** Optional model override for the new session. */
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    /** Optional thinking level override for the new session. */
+    thinkingLevel?: string;
+    /** Initial prompt to send immediately. Defaults to `task`. */
+    initialPrompt?: string;
+    /** Whether to await turn completion before returning (default: false, asynchronous dispatch). */
+    wait?: boolean;
+}
+export interface StopSessionOptions {
+    /** Stop mode: "active" (active turn), "queued" (waiting messages in queue), or "all" (both, default). */
+    mode?: "active" | "queued" | "all";
+    /** Optional specific waiting messageId to interrupt directly. */
+    messageId?: string;
+}
+export interface SessionSummary {
+    conversationId: string;
+    workspaceId: string;
+    title: string;
+    status: RunStatus;
+    origin: "user" | "orchestrator";
+    parentConversationId?: string;
+    task?: string;
+    messageCount: number;
+    turnCount: number;
+    lastAssistantSnippet?: string;
+    lastUserSnippet?: string;
+    hasPendingQuestion: boolean;
+    activeTool?: {
+        label: string;
+        detail?: string;
+    };
+    error?: string;
+    updatedAt: string;
+    createdAt?: number;
+    lastProgress?: string;
+}
+/**
+ * Orchestrator service coordinating sibling and child conversations.
+ *
+ * Provides lifecycle methods (spawn, dispatch, status, list, stop, resume) without
+ * duplicating message history or inflating memory.
+ */
+export declare class SessionOrchestratorService {
+    private readonly store;
+    private readonly conversationService;
+    private readonly runService;
+    private readonly ledger;
+    private readonly broadcaster?;
+    constructor(store: Store, conversationService: ConversationService, runService: RunService, ledger: SessionLedger, broadcaster?: EventBroadcaster | undefined);
+    /**
+     * Spawns a new sibling conversation and immediately dispatches its initial task.
+     */
+    spawn(options: SpawnSessionOptions): Promise<{
+        conversationId: string;
+    }>;
+    /**
+     * Dispatches a message to an arbitrary session (server-to-server).
+     * By default dispatches asynchronously so the orchestrator caller is not blocked.
+     */
+    dispatch(conversationId: string, content: string, options?: {
+        wait?: boolean;
+    }): Promise<{
+        conversationId: string;
+    }>;
+    /**
+     * 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>;
+    /**
+     * Lists summaries of all sessions, optionally filtered by parent conversation.
+     */
+    list(parentConversationId?: string): Promise<SessionSummary[]>;
+    /**
+     * Stops a target session.
+     * Can distinguish between interrupting an active turn, cancelling queued messages, or both.
+     */
+    stop(conversationId: string, options?: StopSessionOptions): Promise<{
+        stopped: boolean;
+        mode: string;
+    }>;
+    /**
+     * Resumes execution in a conversation.
+     * If prompt is provided, sends it as a new turn.
+     * Otherwise, if there is a waiting message in the queue, kicks off its execution.
+     */
+    resume(conversationId: string, prompt?: string, options?: {
+        wait?: boolean;
+    }): Promise<{
+        conversationId: string;
+    }>;
+}