@evandu/super-pi 0.1.144 → 0.1.146

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

package/dist/server/agents.d.ts

@@ -38,7 +38,7 @@ type Frontmatter = Record<string, unknown>;
  */
 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"];
+export declare const SUPER_PI_TOOL_NAMES: readonly ["task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register", "memory", "skill_manage", "session_search", "session_spawn", "session_status", "session_dispatch", "session_stop", "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

@@ -39,7 +39,9 @@ export const 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",
+    "memory", "skill_manage", "session_search",
+    "session_spawn", "session_status", "session_dispatch", "session_stop",
+    "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];

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

@@ -48,7 +48,7 @@ export declare class ConversationService {
     createConversation(workspaceId: string, parentage?: {
         parentConversationId?: string;
         origin?: "user" | "orchestrator";
-    }): Promise<string>;
+    }, cwd?: string): 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

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

@@ -1,5 +1,6 @@
 import { assertModelAllowed } from "../model-filter.js";
 import { newConversationId } from "../store.js";
+import { normalizeSessionCwd, resolveSessionCwd } from "../session-cwd.js";
 function isMissingPrimaryAgent(error, agentId) {
     const message = error instanceof Error ? error.message : String(error);
     const id = JSON.stringify(agentId);
@@ -50,7 +51,7 @@ export class ConversationService {
      * 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, parentage) {
+    async createConversation(workspaceId, parentage, cwd) {
         const workspace = this.store.workspace(workspaceId);
         if (!workspace)
             throw new Error("找不到这个工作区。");
@@ -126,7 +127,8 @@ export class ConversationService {
         }
         // `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, agentId: resolved.agentId ?? null, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(modelNotice ? { modelNotice } : {}), ...(agentNotice ? { agentNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
+        const sessionCwd = await normalizeSessionCwd(workspace.path, cwd);
+        const defaults = { ...resolved, agentId: resolved.agentId ?? null, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(sessionCwd ? { cwd: sessionCwd } : {}), ...(modelNotice ? { modelNotice } : {}), ...(agentNotice ? { agentNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
         const created = await this.store.createConversation(workspaceId, defaults);
         this.broadcaster.broadcastState();
         return created.id;
@@ -422,7 +424,7 @@ export class ConversationService {
         }
         const outcome = await this.runtime.revert({
             conversation,
-            cwd: workspace.path,
+            cwd: await resolveSessionCwd(workspace.path, conversation.cwd),
             boundaryEntryId: plan.boundaryEntryId,
             beforeBoundary: withdraw && Boolean(conversation.messages.find(item => item.id === messageId)?.piEntryId),
         });
@@ -480,7 +482,7 @@ export class ConversationService {
         }
         try {
             const forkedId = newConversationId();
-            const outcome = await this.runtime.fork({ conversation, cwd: workspace.path, forkedConversationId: forkedId });
+            const outcome = await this.runtime.fork({ conversation, cwd: await resolveSessionCwd(workspace.path, conversation.cwd), forkedConversationId: forkedId });
             const forked = await this.store.forkConversation(conversationId, forkedId);
             console.log(`Super Pi: forked conversation ${conversation.id} into ${forked.id}: ` +
                 `${forked.messages.length} message(s) copied in state.json` +

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

@@ -236,10 +236,10 @@ export declare class RunService {
     /**
      * Resolves conversation and workspace working directory for subagent dispatch.
      */
-    dispatchContext(conversationId: string): {
+    dispatchContext(conversationId: string): Promise<{
         conversation: Conversation;
         cwd: string;
-    };
+    }>;
     /**
      * Checks whether a conversation has an active turn running.
      */
@@ -384,6 +384,20 @@ export declare class RunService {
     /**
      * Enqueues or starts execution for a user message.
      */
+    /**
+     * STARTS A TURN FROM A SENDER THAT IS NOT THE READER.
+     *
+     * `enqueueAndRun` below is the person's path: it writes the words under the reader's own name, in
+     * the reader's bubble, so the reader can see that they said it. The orchestrator's path is the
+     * same machinery with a different speaker - a primary agent handing a task to a child session -
+     * and writing THAT under the reader's name was the bug the reader reported: the child's
+     * transcript showed an instruction they never typed, wearing their avatar.
+     *
+     * So the write goes through `addAgentMessage` instead, which records the words as the system's,
+     * and the turn runs on them exactly as before. `composePrompt` is what tells the model who is
+     * speaking, so the model is addressed in the same words.
+     */
+    enqueueAndRunAsAgent(conversationId: string, content: string): Promise<void>;
     enqueueAndRun(conversationId: string, content: string, images?: MessageImage[], attachments?: import("../types.js").MessageAttachments, clientId?: string): Promise<void>;
     /**
      * Steers a queued message into the in-flight turn.

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

@@ -4,11 +4,12 @@ import { newSubagentRunId } from "../subagents.js";
 import { readAgents } from "../agents.js";
 import { verifyCapability } from "../capability.js";
 import { capText, validateWorkflowPlan, workflowSummary } from "../workflow.js";
-import { ensureNameIndex } from "../file-name-index.js";
+import { ensureNameIndex, recordWorkspacePath } from "../file-name-index.js";
 import { formatTurnFailure } from "../turn-failure.js";
 import { describeThrownWithStack } from "../failure-text.js";
 import { toWorkspaceRelative } from "../files.js";
 import { refreshWorkspaceIndex } from "../file-index.js";
+import { resolveSessionCwd } from "../session-cwd.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
@@ -56,10 +57,32 @@ async function expandAtReferences(store, workspace, content) {
  * The envelope and the prose are NOT redundant: the envelope is what the reader sees in the transcript
  * column, what they cancel or reorder; the prose is what leaves the server for Pi.
  */
+/**
+ * THE TEXT THE MODEL IS HANDED WHEN A 后台回传 BECOMES ITS TURN.
+ *
+ * Pi's SDK has ONE entry point for a new turn - `session.prompt(text)` - and every text sent
+ * through it is a USER MESSAGE in Pi's transcript. There is no "the agent said this" channel to
+ * use. So a delivered result has to travel as prose, and the only question left is what that prose
+ * SAYS.
+ *
+ * IT USED TO SAY `[后台任务「...」已完成]`, which reads as a thing the PERSON said - a bracketed
+ * label, then the body, with nothing saying who is speaking. The model therefore answered it as a
+ * user would be answered ("已收到：[后台任务「...」]"), and the reader saw their own result coming
+ * back in the user's voice, inside the user's own turn. The delivery had become a quotation.
+ *
+ * So the prose now says WHO IS SPEAKING and that this is information, not an instruction:
+ * 「子会话「...」已完成，结果如下」. The model is told what happened and what it received, and it
+ * answers about THAT - which is what a primary agent should do with a child's result.
+ */
 function composePrompt(message) {
     if (message.role !== "tool")
         return message.content;
     const content = message.content;
+    // A DISPATCHED ORDER IS NOT A DELIVERED RESULT. The two both travel as a `tool` message, and the
+    // envelope tells them apart: a result carries `<task ...>`, an order does not.
+    if (!/<task id="[^"]+" state="[^"]+"/.test(content)) {
+        return `上级智能体下发的任务：\n\n${content}`;
+    }
     const summaryMatch = /<summary>([\s\S]*?)<\/summary>/.exec(content);
     const summary = summaryMatch ? summaryMatch[1].trim() : "后台任务";
     const stateMatch = /<task id="[^"]+" state="([^"]+)"/.exec(content);
@@ -74,7 +97,10 @@ function composePrompt(message) {
     const bodyMatch = /<task_(?:result|error)>\n?([\s\S]*)\n?<\/(?:task_result|task_error)>/.exec(content);
     const body = bodyMatch ? bodyMatch[1] : content;
     const stateLabel = state === "completed" ? "已完成" : state === "error" ? "失败" : state;
-    return `[后台任务「${summary}」${stateLabel}]\n\n${body}`;
+    // THE SPEAKER IS NAMED, AND IT IS NOT THE READER. A line that starts 「[」 looks like a note the
+    // person pasted in; a line that starts 「子会话」 or 「后台任务」 says the SYSTEM is reporting.
+    const speaker = /kind="session"/.test(content) ? "子会话" : "后台任务";
+    return `${speaker}「${summary}」${stateLabel}，结果如下：\n\n${body}`;
 }
 /**
  * Service managing execution of conversation turns, message queueing,
@@ -563,9 +589,9 @@ export class RunService {
     /**
      * Resolves conversation and workspace working directory for subagent dispatch.
      */
-    dispatchContext(conversationId) {
+    async dispatchContext(conversationId) {
         const { conversation, workspace } = this.turnContext(conversationId);
-        return { conversation, cwd: workspace.path };
+        return { conversation, cwd: await resolveSessionCwd(workspace.path, conversation.cwd) };
     }
     /**
      * Checks whether a conversation has an active turn running.
@@ -1205,13 +1231,15 @@ export class RunService {
             // does not exist.
             const relative = toWorkspaceRelative(workspace.path, path);
             tracker.record(workspace.id, relative, { root: workspace.path, conversationId: conversation.id });
-            refreshWorkspaceIndex(this.fileIndexes, workspace.id, relative);
+            refreshWorkspaceIndex(this.fileIndexes, workspace.id, relative, workspace.path);
             // The name index learns about the write as well, so the file the agent just created is
             // findable by name straight away rather than after the next background scan. It goes through
             // the SAME `ensureNameIndex` the HTTP layer uses, so there is one index per workspace rather
             // than one per layer.
-            if (this.nameIndexes)
-                ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(relative);
+            if (this.nameIndexes) {
+                ensureNameIndex(this.nameIndexes, workspace.id, workspace.path);
+                recordWorkspacePath(this.nameIndexes, workspace.id, workspace.path, relative);
+            }
             if (toolCallId)
                 fileWritePaths.set(toolCallId, relative);
             this.broadcastFileChanges(workspace.id);
@@ -1294,9 +1322,11 @@ export class RunService {
             const writtenPath = call.id ? fileWritePaths.get(call.id) : undefined;
             if (writtenPath) {
                 this.fileChanges?.confirm(workspace.id, writtenPath, workspace.path);
-                refreshWorkspaceIndex(this.fileIndexes, workspace.id, writtenPath);
-                if (this.nameIndexes)
-                    ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(writtenPath);
+                refreshWorkspaceIndex(this.fileIndexes, workspace.id, writtenPath, workspace.path);
+                if (this.nameIndexes) {
+                    ensureNameIndex(this.nameIndexes, workspace.id, workspace.path);
+                    recordWorkspacePath(this.nameIndexes, workspace.id, workspace.path, writtenPath);
+                }
                 if (call.id)
                     fileWritePaths.delete(call.id);
                 this.broadcastFileChanges(workspace.id);
@@ -1377,7 +1407,7 @@ export class RunService {
                 conversation,
                 prompt,
                 signal: controller.signal,
-                cwd: workspace.path,
+                cwd: await resolveSessionCwd(workspace.path, conversation.cwd),
                 host: {
                     notify: (request) => { if (acceptsEvent("ui.notify"))
                         uiHost.notify(request); },
@@ -1394,6 +1424,10 @@ export class RunService {
                     if (acceptsEvent("transcript.file", true))
                         await this.store.setConversationPiSessionFile(conversation.id, path);
                 },
+                onUsage: async (readout) => {
+                    if (acceptsEvent("usage", true))
+                        await this.store.recordConversationUsage(conversation.id, readout);
+                },
                 onToolCall,
                 onFileWrite,
                 onToolPreparing,
@@ -1608,6 +1642,79 @@ export class RunService {
     /**
      * Enqueues or starts execution for a user message.
      */
+    /**
+     * STARTS A TURN FROM A SENDER THAT IS NOT THE READER.
+     *
+     * `enqueueAndRun` below is the person's path: it writes the words under the reader's own name, in
+     * the reader's bubble, so the reader can see that they said it. The orchestrator's path is the
+     * same machinery with a different speaker - a primary agent handing a task to a child session -
+     * and writing THAT under the reader's name was the bug the reader reported: the child's
+     * transcript showed an instruction they never typed, wearing their avatar.
+     *
+     * So the write goes through `addAgentMessage` instead, which records the words as the system's,
+     * and the turn runs on them exactly as before. `composePrompt` is what tells the model who is
+     * speaking, so the model is addressed in the same words.
+     */
+    async enqueueAndRunAsAgent(conversationId, content) {
+        this.assertHistoryAvailable(conversationId);
+        this.memory?.cancel(conversationId);
+        const trimmed = content.trim();
+        if (!trimmed)
+            return;
+        const { conversation, workspace } = this.turnContext(conversationId);
+        const active = this.activeRuns.get(conversation.id);
+        if (active?.signal.aborted)
+            await this.awaitRunSlotReleased(conversation.id, false);
+        this.assertHistoryAvailable(conversationId);
+        const busy = this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id);
+        const reservedController = busy ? undefined : new AbortController();
+        if (reservedController) {
+            this.cancelledQuestionConversations.delete(conversation.id);
+            this.claimRunSlot(conversation.id, reservedController);
+        }
+        let message;
+        try {
+            message = await this.store.addAgentMessage(conversationId, trimmed, { ...(busy ? { delivery: "waiting" } : {}) });
+        }
+        catch (error) {
+            if (reservedController)
+                this.releaseRunSlot(conversation.id, reservedController);
+            throw error;
+        }
+        this.broadcaster.broadcastState();
+        if (!reservedController) {
+            const waiting = this.store.listWaitingMessages(conversationId).find((item) => item.id === message.id && item.delivery === "waiting");
+            if (!waiting)
+                return;
+            if (!this.activeRuns.has(conversationId) && !this.interruptTargets.has(conversationId))
+                await this.processWaitingMessage(conversationId, message.id);
+            else
+                await this.submitToPiQueue(conversationId, message);
+            return;
+        }
+        const controller = reservedController;
+        try {
+            if (controller.signal.aborted) {
+                await this.store.setStatus(conversation.id, "stopped");
+                return;
+            }
+            await this.runUntilDrained(conversation, workspace, composePrompt(message), controller, message.id);
+        }
+        catch (error) {
+            await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "failed");
+            if (controller.signal.aborted)
+                return;
+            await this.store.setFailureReason(conversationId, formatTurnFailure(error));
+            console.error("Super Pi agent-dispatched turn failed:", describeThrownWithStack(error));
+            throw error;
+        }
+        finally {
+            this.releaseRunSlot(conversation.id, controller);
+            if (!this.activeRuns.has(conversation.id))
+                this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+            this.broadcaster.broadcastState();
+        }
+    }
     async enqueueAndRun(conversationId, content, images, attachments, clientId) {
         this.assertHistoryAvailable(conversationId);
         /**
@@ -2004,7 +2111,7 @@ export class RunService {
         const task = params.task.trim();
         if (!task)
             throw new Error("子 agent 的任务不能为空");
-        const { conversation, cwd } = this.dispatchContext(params.conversationId);
+        const { conversation, cwd } = await this.dispatchContext(params.conversationId);
         void this.trackDetached(this.subagents.dispatch({
             conversationId: conversation.id,
             agentId: params.agentId,
@@ -2039,7 +2146,7 @@ export class RunService {
         if (body.depth !== undefined)
             checkSubagentDepth(body.depth);
         const signal = this.activeRuns.get(conversationId)?.signal;
-        const { conversation, cwd } = this.dispatchContext(conversationId);
+        const { conversation, cwd } = await this.dispatchContext(conversationId);
         const parent = body.parentRunId ? this.store.snapshot().subagentRuns.find((run) => run.id === body.parentRunId) : undefined;
         if (body.parentRunId && (!parent || parent.conversationId !== conversation.id)) {
             throw new Error("Invalid parentRunId: dispatch ancestry is not recorded for this conversation");
@@ -2173,7 +2280,7 @@ export class RunService {
         const capability = this.verifyPrimaryCapability(conversationId, body.capability);
         if (!capability.ok)
             throw new Error(capability.message);
-        const { conversation, cwd } = this.dispatchContext(conversationId);
+        const { conversation, cwd } = await this.dispatchContext(conversationId);
         const signal = this.activeRuns.get(conversationId)?.signal;
         // Validated against the roster THIS CALL reads from disk, for the same freshness reason the task tool
         // builds its roster per turn: a sub-agent added while the server is running is dispatchable on the next

package/dist/server/application/scheduled-task-service.d.ts

@@ -98,7 +98,20 @@ export declare class ScheduledTaskService {
     update(id: string, input: ScheduledTaskInput): Promise<ScheduledTask>;
     /** Turns a task on or off. */
     setEnabled(id: string, enabled: boolean): Promise<ScheduledTask>;
-    /** Removes a task. Its conversation stays: it holds the answers the task produced. */
+    /**
+     * Removes a task. Its conversation is ARCHIVED, not deleted.
+     *
+     * THE ANSWERS ARE WORTH KEEPING, so the session is not thrown away - and archiving is the keeping
+     * that can be undone: the session moves into the sidebar's 已归档 group and can be restored from
+     * there. The old behaviour was to leave it in the LIVE list, and that was the defect: a 「定时：xxx」
+     * session with no task behind it is an orphan the reader cannot explain (there is no delete-session
+     * control at all) and cannot get rid of.
+     *
+     * THE DELETE ITSELF IS NEVER REFUSED. The task is removed first and the archive is best-effort: a
+     * conversation that is still running cannot be archived, and a reader who deletes a task must not be
+     * told "no" because a session happens to be busy. The session simply stays where it is, and the
+     * reason is in the server log rather than in the reader's face.
+     */
     remove(id: string): Promise<void>;
     /**
      * Runs a task NOW, once.

package/dist/server/application/scheduled-task-service.js

@@ -186,10 +186,35 @@ export class ScheduledTaskService {
             return task;
         return this.update(id, { enabled });
     }
-    /** Removes a task. Its conversation stays: it holds the answers the task produced. */
+    /**
+     * Removes a task. Its conversation is ARCHIVED, not deleted.
+     *
+     * THE ANSWERS ARE WORTH KEEPING, so the session is not thrown away - and archiving is the keeping
+     * that can be undone: the session moves into the sidebar's 已归档 group and can be restored from
+     * there. The old behaviour was to leave it in the LIVE list, and that was the defect: a 「定时：xxx」
+     * session with no task behind it is an orphan the reader cannot explain (there is no delete-session
+     * control at all) and cannot get rid of.
+     *
+     * THE DELETE ITSELF IS NEVER REFUSED. The task is removed first and the archive is best-effort: a
+     * conversation that is still running cannot be archived, and a reader who deletes a task must not be
+     * told "no" because a session happens to be busy. The session simply stays where it is, and the
+     * reason is in the server log rather than in the reader's face.
+     */
     async remove(id) {
-        this.require(id);
+        const task = this.require(id);
         await this.store.removeScheduledTask(id);
+        const conversationId = task.conversationId;
+        if (conversationId) {
+            const conversation = this.store.conversation(conversationId);
+            if (conversation && !conversation.archivedAt) {
+                try {
+                    await this.conversationService.archiveConversation(conversationId);
+                }
+                catch (error) {
+                    console.warn(`Super Pi: the deleted task's conversation ${conversationId} could not be archived:`, error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
         this.broadcaster.broadcastState();
     }
     /**

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

@@ -11,8 +11,13 @@ export interface SpawnSessionOptions {
     task: string;
     /** Parent conversation initiating the orchestration, if any. */
     parentConversationId?: string;
-    /** Workspace ID for the new session. Inherited from parent if omitted. */
-    workspaceId?: string;
+    /** Explicit target workspace. A parent conversation records only the session-tree relationship. */
+    workspaceId: string;
+    /**
+     * Optional workspace-root-relative subdirectory for the new session. Invalid or out-of-bounds
+     * values are rejected before the conversation is created.
+     */
+    cwd?: string;
     /** Optional custom title for the new session. */
     title?: string;
     /** Optional agent override for the new session. */
@@ -98,6 +103,10 @@ export declare class SessionOrchestratorService {
     }): Promise<SessionSummary>;
     /**
      * Lists summaries of all sessions, optionally filtered by parent conversation.
+     *
+     * Persisted store conversations are the authoritative source for session tree
+     * parent-child relationships across server restarts, while SessionLedger
+     * enriches live in-memory task, progress, and activeTool state.
      */
     list(parentConversationId?: string): Promise<SessionSummary[]>;
     /**