@evandu/super-pi 0.1.145 → 0.1.147

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-BGsP8pt_.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CiIc734l.css">
+    <script type="module" crossorigin src="/assets/index-Dzyp_7sf.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BMpqviwU.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/active-memory.d.ts

@@ -77,6 +77,23 @@ export declare class ActiveMemory {
         score: number;
         content: string;
     }[];
+    /**
+     * Rebuilds one conversation's postings after a rare destructive transcript mutation (revert/delete).
+     *
+     * WHY THIS EXISTS. The index is a CACHE of the store, and `removeFromIndex` is the surgical half of
+     * that contract: the caller tells it which ids LEFT, and exactly those postings go. This is the other
+     * half - it rebuilds what is there NOW. A destructive mutation can also change a message's CONTENT
+     * (a withdrawn turn replaced by a rewritten one), and a posting that still carries the old text
+     * answers a search with a turn the transcript no longer holds. So the rare path pays a full
+     * re-tokenize of ONE conversation, and the rest of the workspace stays indexed.
+     *
+     * THE REMOVAL LOOP WALKS EVERY WORKSPACE, because a posting remembers the conversation it came from:
+     * the conversation's terms must stop answering searches wherever they were indexed, not only in the
+     * workspace it lives in. The reverse index (`termsByMessage`) is pruned in the same loop, so the two
+     * halves of the index cannot disagree about which messages are indexed - a stale entry would point
+     * the surgical removal at terms that are no longer there.
+     */
+    syncConversation(conversation: Conversation): void;
     private ensureIndex;
     /**
      * Drops exactly the given messages from the search index, leaving the rest of the workspace indexed.

package/dist/server/active-memory.js

@@ -135,6 +135,41 @@ export class ActiveMemory {
                 void id, candidates.set(value.messageId, value);
         return [...candidates.values()].filter(m => !sessionId || m.conversationId === sessionId).map(m => ({ ...m, score: words.reduce((n, word) => n + (m.content.toLocaleLowerCase().includes(word) ? 1 : 0), 0) })).filter(m => m.score > 0).sort((a, b) => b.score - a.score).slice(0, 6).map(m => ({ ...m, content: m.content.slice(0, 1200) }));
     }
+    /**
+     * Rebuilds one conversation's postings after a rare destructive transcript mutation (revert/delete).
+     *
+     * WHY THIS EXISTS. The index is a CACHE of the store, and `removeFromIndex` is the surgical half of
+     * that contract: the caller tells it which ids LEFT, and exactly those postings go. This is the other
+     * half - it rebuilds what is there NOW. A destructive mutation can also change a message's CONTENT
+     * (a withdrawn turn replaced by a rewritten one), and a posting that still carries the old text
+     * answers a search with a turn the transcript no longer holds. So the rare path pays a full
+     * re-tokenize of ONE conversation, and the rest of the workspace stays indexed.
+     *
+     * THE REMOVAL LOOP WALKS EVERY WORKSPACE, because a posting remembers the conversation it came from:
+     * the conversation's terms must stop answering searches wherever they were indexed, not only in the
+     * workspace it lives in. The reverse index (`termsByMessage`) is pruned in the same loop, so the two
+     * halves of the index cannot disagree about which messages are indexed - a stale entry would point
+     * the surgical removal at terms that are no longer there.
+     */
+    syncConversation(conversation) {
+        for (const [, terms] of this.inverted) {
+            for (const [term, postings] of terms) {
+                for (const [messageId, value] of postings) {
+                    if (value.conversationId === conversation.id) {
+                        postings.delete(messageId);
+                        this.indexedMessages.delete(messageId);
+                        this.termsByMessage.delete(messageId);
+                    }
+                }
+                if (!postings.size)
+                    terms.delete(term);
+            }
+        }
+        if (!this.indexedWorkspaces.has(conversation.workspaceId))
+            return;
+        for (const message of conversation.messages)
+            this.addToIndex(conversation, message);
+    }
     ensureIndex(workspaceId) {
         if (this.indexedWorkspaces.has(workspaceId))
             return;
@@ -224,6 +259,10 @@ export class ActiveMemory {
                 terms.set(term, bucket = new Map());
             bucket.set(message.id, value);
         }
+        // THE MESSAGE IS IN THE INDEX NOW, SO THE SET MUST SAY SO. `completed()` walks this set to find
+        // the messages it has never indexed, and a message that is indexed without being marked here is
+        // re-tokenized on EVERY turn end - the whole-conversation cost this file exists to avoid.
+        this.indexedMessages.add(message.id);
     }
     async tool(token, body) {
         const identity = this.identity(token);

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),
         });
@@ -433,6 +435,12 @@ export class ConversationService {
         const withdrawn = conversation.messages.find(item => item.id === messageId);
         const withdrawnContent = withdrawn ? { content: withdrawn.content, images: withdrawn.images } : undefined;
         const applied = await this.store.revertMessages(conversationId, messageId, withdraw);
+        // THE RECALL INDEX MUST SEE THE TRUNCATED TRANSCRIPT. `conversation` above is the DETACHED COPY
+        // that `turnContext` took BEFORE the store spliced its live array, so it still holds the withdrawn
+        // turns - re-syncing from it would put the text the person just withdrew straight back into the
+        // index, which is the exact leak this path exists to close. The store's post-revert conversation is
+        // the truth, and this rare destructive path is where one clone of it is the right price.
+        this.memory?.syncConversation(this.store.conversation(conversationId) ?? conversation);
         // THE MEMORY HALF OF THE REWIND, and the half that used to be missing. Everything above removes the
         // turn from Pi's file and from state.json; the memory store is a second durable copy of what the turn
         // said, and it is spliced into every later prompt. So the model kept being told about a turn the person
@@ -480,7 +488,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

@@ -161,6 +161,15 @@ export declare class RunService {
         resultPath: string;
         error?: string;
     }): Promise<void>;
+    /**
+     * Dispatches a background result (exec or child session) into the conversation.
+     *
+     * IDLE: starts a fresh turn via `processWaitingMessage`.
+     * BUSY: attempts to steer the message into the running turn so it is delivered at the
+     *       very next tool batch boundary rather than waiting for the entire turn to complete.
+     * INTERRUPTING: quietly leaves the message waiting; the interrupted or next turn will pick it up.
+     */
+    private dispatchBackgroundResult;
     /**
      * Stops an active background task (spawned process or detached subagent) on user request.
      *
@@ -171,6 +180,8 @@ export declare class RunService {
      *    updates immediately.
      */
     stopBackgroundTask(taskId: string): Promise<void>;
+    hasActiveBackgroundTasks(conversationId: string): boolean;
+    settleBackgroundStatus(conversationId: string): Promise<void>;
     /** Per-conversation command lane.  All queue mutations and run claims use the same lane, so
      * two browser tabs cannot both observe an idle conversation and start duplicate turns. */
     private readonly conversationOps;
@@ -236,10 +247,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.
      */
@@ -379,11 +390,30 @@ export declare class RunService {
      * stream it - which is why the two cases are expressed identically and cannot drift apart.
      */
     runConversationTurns(conversation: Conversation, workspace: Workspace, prompt: string, controller: AbortController, firstMessageId: string, initialImages?: MessageImage[]): Promise<void>;
+    /**
+     * Refuses a turn when the selected model cannot accept image input, either because the incoming
+     * message carries images or because previous messages in the conversation contain images.
+     */
+    private assertModelSupportsImages;
     /** Keep admission owned through final persistence and recheck the durable queue before releasing. */
     private runUntilDrained;
     /**
      * 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.