@evandu/super-pi 0.1.139 → 0.1.140

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

@@ -0,0 +1,234 @@
+/**
+ * Orchestrator service coordinating sibling and child conversations.
+ *
+ * Provides lifecycle methods (spawn, dispatch, status, list, stop, resume) without
+ * duplicating message history or inflating memory.
+ */
+export class SessionOrchestratorService {
+    store;
+    conversationService;
+    runService;
+    ledger;
+    broadcaster;
+    constructor(store, conversationService, runService, ledger, broadcaster) {
+        this.store = store;
+        this.conversationService = conversationService;
+        this.runService = runService;
+        this.ledger = ledger;
+        this.broadcaster = broadcaster;
+    }
+    /**
+     * Spawns a new sibling conversation and immediately dispatches its initial task.
+     */
+    async spawn(options) {
+        let workspaceId = options.workspaceId;
+        if (!workspaceId && options.parentConversationId) {
+            const parent = this.store.conversation(options.parentConversationId);
+            workspaceId = parent?.workspaceId;
+        }
+        if (!workspaceId) {
+            throw new Error("创建兄弟会话需要指定工作区（或提供有效的父会话 ID）。");
+        }
+        const conversationId = await this.conversationService.createConversation(workspaceId);
+        // Set title if requested or derive from task
+        if (options.title) {
+            await this.conversationService.renameConversation(conversationId, options.title);
+        }
+        else if (options.task) {
+            const titleSnippet = options.task.trim().replace(/\s+/g, " ").slice(0, 30);
+            await this.conversationService.renameConversation(conversationId, `任务：${titleSnippet}`);
+        }
+        // Apply configuration overrides if provided
+        if (options.agentId) {
+            await this.conversationService.setAgent(conversationId, options.agentId);
+        }
+        if (options.model) {
+            await this.conversationService.setModel(conversationId, options.model.provider, options.model.modelId);
+        }
+        if (options.thinkingLevel) {
+            await this.conversationService.setThinking(conversationId, options.thinkingLevel);
+        }
+        // Register in relationship ledger
+        this.ledger.register({
+            conversationId,
+            workspaceId,
+            origin: options.parentConversationId ? "orchestrator" : "user",
+            parentConversationId: options.parentConversationId,
+            task: options.task,
+            status: "idle",
+        });
+        // Immediately dispatch initial work
+        const prompt = options.initialPrompt ?? options.task;
+        if (prompt && prompt.trim()) {
+            await this.dispatch(conversationId, prompt, { wait: options.wait });
+        }
+        return { conversationId };
+    }
+    /**
+     * Dispatches a message to an arbitrary session (server-to-server).
+     * By default dispatches asynchronously so the orchestrator caller is not blocked.
+     */
+    async dispatch(conversationId, content, options) {
+        const conversation = this.store.conversation(conversationId);
+        if (!conversation) {
+            throw new Error(`找不到会话：${conversationId}`);
+        }
+        this.ledger.update(conversationId, {
+            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));
+                this.ledger.update(conversationId, { status: "failed" });
+            });
+        }
+        return { conversationId };
+    }
+    /**
+     * 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) {
+        const conversation = this.store.conversation(conversationId);
+        if (!conversation) {
+            throw new Error(`找不到会话：${conversationId}`);
+        }
+        const ledgerEntry = this.ledger.get(conversationId);
+        const messages = conversation.messages ?? [];
+        let turnCount = 0;
+        let lastAssistantSnippet;
+        let lastUserSnippet;
+        let activeTool;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (!lastAssistantSnippet && msg.role === "assistant") {
+                const raw = msg.content || (msg.thinkingBlocks ? msg.thinkingBlocks.map((b) => b.text).join(" ") : "") || "";
+                lastAssistantSnippet = raw.slice(0, 300);
+            }
+            if (!lastUserSnippet && msg.role === "user") {
+                lastUserSnippet = (msg.content || "").slice(0, 300);
+            }
+            if (msg.role === "assistant") {
+                turnCount++;
+            }
+        }
+        if (conversation.status === "running" || conversation.status === "waiting") {
+            const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+            if (lastAssistant?.toolCalls?.length) {
+                const lastCall = lastAssistant.toolCalls[lastAssistant.toolCalls.length - 1];
+                if (!lastCall.status || lastCall.live || lastCall.preparing) {
+                    activeTool = { label: lastCall.label, detail: lastCall.detail };
+                }
+            }
+        }
+        const hasPendingQuestion = this.store.pendingQuestions(conversationId).length > 0;
+        // Sync ledger status if present
+        if (ledgerEntry && ledgerEntry.status !== conversation.status) {
+            this.ledger.update(conversationId, {
+                status: conversation.status,
+                lastProgress: lastAssistantSnippet ?? ledgerEntry.lastProgress,
+            });
+        }
+        return {
+            conversationId: conversation.id,
+            workspaceId: conversation.workspaceId,
+            title: conversation.title,
+            status: conversation.status,
+            origin: ledgerEntry?.origin ?? "user",
+            parentConversationId: ledgerEntry?.parentConversationId,
+            task: ledgerEntry?.task,
+            messageCount: messages.length,
+            turnCount,
+            lastAssistantSnippet,
+            lastUserSnippet,
+            hasPendingQuestion,
+            activeTool,
+            error: conversation.error,
+            updatedAt: conversation.updatedAt,
+            createdAt: ledgerEntry?.createdAt,
+            lastProgress: ledgerEntry?.lastProgress ?? lastAssistantSnippet,
+        };
+    }
+    /**
+     * Lists summaries of all sessions, optionally filtered by parent conversation.
+     */
+    async list(parentConversationId) {
+        const entries = parentConversationId
+            ? this.ledger.listByParent(parentConversationId)
+            : this.ledger.listAll();
+        const summaries = [];
+        for (const entry of entries) {
+            try {
+                const summary = await this.status(entry.conversationId);
+                summaries.push(summary);
+            }
+            catch {
+                // Conversation was removed from store; prune ledger
+                this.ledger.delete(entry.conversationId);
+            }
+        }
+        return summaries;
+    }
+    /**
+     * Stops a target session.
+     * Can distinguish between interrupting an active turn, cancelling queued messages, or both.
+     */
+    async stop(conversationId, options) {
+        const conversation = this.store.conversation(conversationId);
+        if (!conversation) {
+            throw new Error(`找不到会话：${conversationId}`);
+        }
+        let mode = options?.mode ?? "all";
+        if (options?.messageId) {
+            await this.runService.interruptQueued(conversationId, options.messageId);
+            mode = "queued-interrupt";
+        }
+        else if (mode === "queued") {
+            const waiting = this.store.listWaitingMessages(conversationId);
+            for (const msg of waiting) {
+                await this.runService.cancelQueued(conversationId, msg.id);
+            }
+            mode = "queued-cancel";
+        }
+        else if (mode === "active") {
+            await this.runService.stopRun(conversationId);
+            mode = "active-stop";
+        }
+        else {
+            // mode === "all"
+            await this.runService.stopRun(conversationId);
+            const waiting = this.store.listWaitingMessages(conversationId);
+            for (const msg of waiting) {
+                await this.runService.cancelQueued(conversationId, msg.id);
+            }
+            mode = "all";
+        }
+        this.ledger.update(conversationId, { status: "stopped" });
+        return { stopped: true, mode };
+    }
+    /**
+     * 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.
+     */
+    async resume(conversationId, prompt, options) {
+        const conversation = this.store.conversation(conversationId);
+        if (!conversation) {
+            throw new Error(`找不到会话：${conversationId}`);
+        }
+        if (prompt && prompt.trim()) {
+            return this.dispatch(conversationId, prompt, options);
+        }
+        const waiting = this.store.listWaitingMessages(conversationId).find((item) => item.delivery === "waiting");
+        if (waiting) {
+            await this.runService.sendQueued(conversationId, waiting.id);
+            this.ledger.update(conversationId, { status: "running" });
+            return { conversationId };
+        }
+        throw new Error("该会话没有排队的消息可恢复，请提供 prompt 发送新消息。");
+    }
+}

package/dist/server/http-server.js

@@ -1452,6 +1452,141 @@ export function createHttpServer(options) {
                 }
                 return;
             }
+            if (url.pathname === "/api/orchestrator") {
+                if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                    response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Orchestrator requires a loopback or private network POST");
+                    return;
+                }
+                const asked = await readRequestText(request, MAX_FILE_BYTES * 2);
+                if (asked.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
+                    return;
+                }
+                const json = (status, body) => {
+                    response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
+                };
+                try {
+                    const body = JSON.parse(asked.text);
+                    const service = context.sessionOrchestratorService;
+                    if (!service) {
+                        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: "未授权" });
+                        return;
+                    }
+                    const action = (body.action || "").trim();
+                    if (action === "spawn") {
+                        if (!body.task)
+                            throw new Error("spawn requires task");
+                        const result = await service.spawn({
+                            task: body.task,
+                            parentConversationId: body.parentConversationId,
+                            workspaceId: body.workspaceId,
+                            title: body.title,
+                            agentId: body.agentId,
+                            model: body.model,
+                            thinkingLevel: body.thinkingLevel,
+                            initialPrompt: body.initialPrompt,
+                            wait: body.wait,
+                        });
+                        json(200, { ok: true, ...result });
+                        return;
+                    }
+                    if (action === "dispatch") {
+                        if (!body.conversationId)
+                            throw new Error("dispatch requires conversationId");
+                        if (!body.content)
+                            throw new Error("dispatch requires content");
+                        const result = await service.dispatch(body.conversationId, body.content, { wait: body.wait });
+                        json(200, { ok: true, ...result });
+                        return;
+                    }
+                    if (action === "status") {
+                        if (!body.conversationId)
+                            throw new Error("status requires conversationId");
+                        const summary = await service.status(body.conversationId);
+                        json(200, { ok: true, summary });
+                        return;
+                    }
+                    if (action === "list") {
+                        const sessions = await service.list(body.parentConversationId);
+                        json(200, { ok: true, sessions });
+                        return;
+                    }
+                    if (action === "stop") {
+                        if (!body.conversationId)
+                            throw new Error("stop requires conversationId");
+                        const result = await service.stop(body.conversationId, { mode: body.mode, messageId: body.messageId });
+                        json(200, { ok: true, ...result });
+                        return;
+                    }
+                    if (action === "resume") {
+                        if (!body.conversationId)
+                            throw new Error("resume requires conversationId");
+                        const result = await service.resume(body.conversationId, body.prompt, { wait: body.wait });
+                        json(200, { ok: true, ...result });
+                        return;
+                    }
+                    json(400, { error: `不支持的编排操作：${action}` });
+                }
+                catch (error) {
+                    json(400, { error: error instanceof Error ? error.message : "orchestrator request failed" });
+                }
+                return;
+            }
+            if (url.pathname === "/api/orchestrator/status" && request.method === "GET") {
+                if (!isLocalOrPrivateAddress(remote)) {
+                    response.writeHead(403).end();
+                    return;
+                }
+                const service = context.sessionOrchestratorService;
+                if (!service) {
+                    response.writeHead(503, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "编排服务未就绪" }));
+                    return;
+                }
+                const conversationId = url.searchParams.get("conversationId");
+                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);
+                    response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ ok: true, summary }));
+                }
+                catch (error) {
+                    response.writeHead(400, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "status failed" }));
+                }
+                return;
+            }
+            if (url.pathname === "/api/orchestrator/list" && request.method === "GET") {
+                if (!isLocalOrPrivateAddress(remote)) {
+                    response.writeHead(403).end();
+                    return;
+                }
+                const service = context.sessionOrchestratorService;
+                if (!service) {
+                    response.writeHead(503, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "编排服务未就绪" }));
+                    return;
+                }
+                const parentId = url.searchParams.get("parentId") || undefined;
+                try {
+                    const sessions = await service.list(parentId);
+                    response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ ok: true, sessions }));
+                }
+                catch (error) {
+                    response.writeHead(400, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "list failed" }));
+                }
+                return;
+            }
             if (url.pathname === "/api/question") {
                 if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
                     response.writeHead(403).end();

package/dist/server/index.js

@@ -24,6 +24,8 @@ import { RunService } from "./application/run-service.js";
 import { FileChangeTracker } from "./file-changes.js";
 import { ConversationService } from "./application/conversation-service.js";
 import { ScheduledTaskService } from "./application/scheduled-task-service.js";
+import { SessionLedger } from "./session-ledger.js";
+import { SessionOrchestratorService } from "./application/session-orchestrator-service.js";
 import { WorkspaceService } from "./application/workspace-service.js";
 import { CommandHandler } from "./command-handler.js";
 import { TerminalService, terminalDisabledReason } from "./terminal.js";
@@ -114,6 +116,7 @@ const workflowEndpoint = `http://${internalHost}:${port}/api/workflow/run`;
 const questionEndpoint = `http://${internalHost}:${port}/api/question`;
 const toolsEndpoint = `http://${internalHost}:${port}/api/tools`;
 const documentsEndpoint = `http://${internalHost}:${port}/api/documents/tool`;
+const orchestratorEndpoint = `http://${internalHost}:${port}/api/orchestrator`;
 // ------------------------------------------------------------- Core singletons
 const store = await openStateStore(dataDir, process.env.SUPER_PI_PERSISTENCE ?? "sqlite");
 const toolRegistry = new ToolRegistry(dataDir);
@@ -136,7 +139,7 @@ const paths = {
 };
 const runtime = process.env.SUPER_PI_RUNTIME === "welcome"
     ? new WelcomeRuntime()
-    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, scheduledTaskEndpoint, uploadsDir });
+    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, scheduledTaskEndpoint, orchestratorEndpoint, uploadsDir });
 // Closed workspaces stay in the store for reopening. Focused sockets receive all visible sidebar
 // summaries and only their selected transcript; legacy sockets retain the complete visible state.
 const broadcaster = new WsBroadcaster((scope) => store.clientState(scope));
@@ -173,13 +176,24 @@ supervisor.setMemory(memory);
 const validateModel = (conversationId, selection) => validateConversationModel(store, runtime, conversationId, selection);
 runtime.setModelValidator?.(validateModel);
 supervisor.setModelValidator(validateModel);
+/**
+ * DIAGNOSTIC ONLY - reproduces the pre-fix flood wire-for-wire (a full `state` broadcast per
+ * `subagent.event`, uncapped live output) so probes and regression tests can A/B the fix. Never set
+ * outside a probe; see docs/SUBAGENT-WS-FLOOD-FIX-2026-10-29.md.
+ */
+const legacySubagentFlood = process.env.SUPER_PI_LEGACY_SUBAGENT_FLOOD === "1";
 const subagents = new SubagentRunRecorder(supervisor, {
     store,
     broadcast: (event) => {
         broadcaster.broadcast(event);
-        if (event.type === "subagent.event")
+        if (legacySubagentFlood && event.type === "subagent.event")
             broadcaster.broadcastState();
     },
+    // The full state broadcast moved from "every delta" to "on settle": a browser that reloads mid-run
+    // rebuilds the card from the store (written per delta); the settle frame is what puts the FINAL
+    // record into `state` so a reload after the finish sees it too.
+    onSettled: legacySubagentFlood ? undefined : () => broadcaster.broadcastState(),
+    liveTailCap: legacySubagentFlood ? Number.POSITIVE_INFINITY : undefined,
     host: (conversationId, runId) => extensionUiService.createHost(conversationId, runId),
 });
 /**
@@ -275,6 +289,8 @@ runService.setExecService(execService);
  * message takes.
  */
 const scheduledTaskService = new ScheduledTaskService(store, runService, conversationService, broadcaster);
+const sessionLedger = new SessionLedger();
+const sessionOrchestratorService = new SessionOrchestratorService(store, conversationService, runService, sessionLedger, broadcaster);
 const serverContext = {
     memory,
     knowledge,
@@ -294,6 +310,8 @@ const serverContext = {
     catalogService,
     providerService,
     scheduledTaskService,
+    sessionLedger,
+    sessionOrchestratorService,
     execService,
     toolRegistry,
     toolRunner,

package/dist/server/runtime.d.ts

@@ -742,6 +742,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
         toolsEndpoint?: string;
         documentsEndpoint?: string;
         scheduledTaskEndpoint?: string;
+        orchestratorEndpoint?: string;
         uploadsDir?: string;
         sessionFactory?: PiSessionFactory;
         sessionMode?: "sdk" | "oneshot";

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, rosterPayload, } from "./task-tool.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 { 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";
@@ -709,6 +709,8 @@ export class PiRpcRuntime {
             [TODO_ENDPOINT_ENV]: this.options.todoEndpoint ?? "",
             [SCHEDULED_TASK_ENDPOINT_ENV]: this.options.scheduledTaskEndpoint ?? "",
             [WORKFLOW_ENDPOINT_ENV]: this.options.workflowEndpoint ?? "",
+            [ORCHESTRATOR_ENDPOINT_ENV]: this.options.orchestratorEndpoint ?? "",
+            SUPER_PI_ORCHESTRATOR_CONVERSATION: conversationId,
             SUPER_PI_QUESTION_ENDPOINT: this.options.questionEndpoint ?? "",
             SUPER_PI_TOOLS_ENDPOINT: this.options.toolsEndpoint ?? "",
             // The document tools' endpoint and the conversation they act for. The CREDENTIAL is not here:
@@ -1240,6 +1242,8 @@ export class PiRpcRuntime {
         // loaded-but-undeclared tool - broken with no error to explain it.
         if (process.env.SUPER_PI_FEISHU_ENDPOINT)
             names.push(FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME);
+        if (this.options.orchestratorEndpoint)
+            names.push(SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME);
         return names;
     }
     /**
@@ -1458,7 +1462,7 @@ export class PiRpcRuntime {
         // allowlist and naming a tool Pi has not registered would change the spawn line for every other
         // mode. The prompt asks for a bare JSON array and nothing else; if the model spends a turn on a
         // tool call anyway the reranker times out and falls back to the lexical order.
-        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register", ...(this.options.orchestratorEndpoint ? [SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME] : [])] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)

package/dist/server/server-context.d.ts

@@ -71,6 +71,8 @@ export interface ServerContext {
      * task of its own.
      */
     scheduledTaskService?: import("./application/scheduled-task-service.js").ScheduledTaskService;
+    sessionLedger?: import("./session-ledger.js").SessionLedger;
+    sessionOrchestratorService?: import("./application/session-orchestrator-service.js").SessionOrchestratorService;
     execService: ExecService;
     toolRegistry: ToolRegistry;
     toolRunner: ToolRunner;

package/dist/server/session-ledger.d.ts

@@ -0,0 +1,60 @@
+export type SessionOrigin = "user" | "orchestrator";
+export type SessionLedgerStatus = "idle" | "running" | "waiting" | "stopped" | "failed" | "completed";
+/**
+ * Metadata entry for a conversation managed or observed by the orchestrator.
+ * Crucially, NO transcript or message history is retained here to keep memory footprint bounded.
+ */
+export interface SessionLedgerEntry {
+    conversationId: string;
+    workspaceId: string;
+    /** Whether created manually by user or by orchestrator agent */
+    origin: SessionOrigin;
+    /** If created by orchestrator: the parent conversation that dispatched it */
+    parentConversationId?: string;
+    /** One-line task description assigned to this session */
+    task?: string;
+    /** Current status */
+    status: SessionLedgerStatus;
+    createdAt: number;
+    updatedAt: number;
+    /** High-level progress snippet or latest outcome */
+    lastProgress?: string;
+}
+/**
+ * In-memory relationship ledger for sibling and child sessions.
+ * Holds only metadata (parent-child relationships, tasks, statuses) - never transcripts.
+ */
+export declare class SessionLedger {
+    private readonly entries;
+    /**
+     * Registers a session into the ledger.
+     */
+    register(entry: Omit<SessionLedgerEntry, "createdAt" | "updatedAt"> & {
+        createdAt?: number;
+        updatedAt?: number;
+    }): SessionLedgerEntry;
+    /**
+     * Updates metadata for an existing session in the ledger.
+     */
+    update(conversationId: string, patch: Partial<Omit<SessionLedgerEntry, "conversationId" | "createdAt">>): SessionLedgerEntry | undefined;
+    /**
+     * Retrieves metadata for one session.
+     */
+    get(conversationId: string): SessionLedgerEntry | undefined;
+    /**
+     * Lists all sessions dispatched by a given parent conversation, sorted newest first.
+     */
+    listByParent(parentConversationId: string): SessionLedgerEntry[];
+    /**
+     * Lists all recorded sessions in the ledger, sorted newest first.
+     */
+    listAll(): SessionLedgerEntry[];
+    /**
+     * Removes a session from the ledger.
+     */
+    delete(conversationId: string): boolean;
+    /**
+     * Clears all ledger entries (primarily for test cleanup).
+     */
+    clear(): void;
+}

package/dist/server/session-ledger.js

@@ -0,0 +1,76 @@
+/**
+ * In-memory relationship ledger for sibling and child sessions.
+ * Holds only metadata (parent-child relationships, tasks, statuses) - never transcripts.
+ */
+export class SessionLedger {
+    entries = new Map();
+    /**
+     * Registers a session into the ledger.
+     */
+    register(entry) {
+        const now = Date.now();
+        const fullEntry = {
+            ...entry,
+            createdAt: entry.createdAt ?? now,
+            updatedAt: entry.updatedAt ?? now,
+        };
+        this.entries.set(entry.conversationId, fullEntry);
+        return { ...fullEntry };
+    }
+    /**
+     * Updates metadata for an existing session in the ledger.
+     */
+    update(conversationId, patch) {
+        const existing = this.entries.get(conversationId);
+        if (!existing)
+            return undefined;
+        const updated = {
+            ...existing,
+            ...patch,
+            updatedAt: Date.now(),
+        };
+        this.entries.set(conversationId, updated);
+        return { ...updated };
+    }
+    /**
+     * Retrieves metadata for one session.
+     */
+    get(conversationId) {
+        const entry = this.entries.get(conversationId);
+        return entry ? { ...entry } : undefined;
+    }
+    /**
+     * Lists all sessions dispatched by a given parent conversation, sorted newest first.
+     */
+    listByParent(parentConversationId) {
+        const result = [];
+        for (const entry of this.entries.values()) {
+            if (entry.parentConversationId === parentConversationId) {
+                result.push({ ...entry });
+            }
+        }
+        return result.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Lists all recorded sessions in the ledger, sorted newest first.
+     */
+    listAll() {
+        const result = [];
+        for (const entry of this.entries.values()) {
+            result.push({ ...entry });
+        }
+        return result.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Removes a session from the ledger.
+     */
+    delete(conversationId) {
+        return this.entries.delete(conversationId);
+    }
+    /**
+     * Clears all ledger entries (primarily for test cleanup).
+     */
+    clear() {
+        this.entries.clear();
+    }
+}