@evandu/super-pi 0.1.141 → 0.1.142

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

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

@@ -74,7 +74,8 @@ export declare class ConversationService {
      */
     archiveConversation(conversationId: string): Promise<void>;
     /**
-     * Unarchives a conversation.
+     * Unarchives an archived tree root and every archived descendant. Descendants that are
+     * already active need no write; they are already in the live tree this restore rejoins.
      */
     unarchiveConversation(conversationId: string): Promise<void>;
     /**

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

@@ -1,5 +1,11 @@
 import { assertModelAllowed } from "../model-filter.js";
 import { newConversationId } from "../store.js";
+function isMissingPrimaryAgent(error, agentId) {
+    const message = error instanceof Error ? error.message : String(error);
+    const id = JSON.stringify(agentId);
+    return message.includes(`Agent ${id} 已失效或不是可用的 primary agent`)
+        || message.includes(`Agent ${id} 不存在或不是可用的 primary agent`);
+}
 /**
  * Service managing conversation lifecycle: creation, selection, archiving,
  * model/thinking/agent configuration, message reversion, and session forking.
@@ -104,12 +110,23 @@ export class ConversationService {
                 thinkingLevel = undefined;
             }
         }
-        const resolved = workspace.defaultAgentId
-            ? await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId)
-            : { model, thinkingLevel };
+        let agentNotice;
+        let resolved = { model, thinkingLevel };
+        if (workspace.defaultAgentId) {
+            try {
+                resolved = await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId);
+            }
+            catch (error) {
+                // Only an absent definition is downgraded. A present agent whose model, thinking level or
+                // workspace rules are invalid must still refuse rather than silently dropping its configuration.
+                if (!isMissingPrimaryAgent(error, workspace.defaultAgentId))
+                    throw error;
+                agentNotice = `你设的默认 Agent「${workspace.defaultAgentId}」已经不存在了，这个会话改用 Pi 默认 Agent。请在工作区设置里重新选择默认 Agent。`;
+            }
+        }
         // `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 } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
+        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 created = await this.store.createConversation(workspaceId, defaults);
         this.broadcaster.broadcastState();
         return created.id;
@@ -169,14 +186,15 @@ export class ConversationService {
      */
     async archiveConversation(conversationId) {
         this.runService.reviewMemoryBoundary(conversationId);
-        await this.store.archiveConversation(conversationId);
+        await this.store.archiveConversationTree(conversationId);
         this.broadcaster.broadcastState();
     }
     /**
-     * Unarchives a conversation.
+     * Unarchives an archived tree root and every archived descendant. Descendants that are
+     * already active need no write; they are already in the live tree this restore rejoins.
      */
     async unarchiveConversation(conversationId) {
-        await this.store.unarchiveConversation(conversationId);
+        await this.store.unarchiveConversationTree(conversationId);
         this.broadcaster.broadcastState();
     }
     /**

package/dist/server/store.d.ts

@@ -266,10 +266,11 @@ export declare class Store {
         conversationId?: string;
     }): AppState;
     createConversation(workspaceId: string, configuration?: {
-        agentId?: string;
+        agentId?: string | null;
         model?: ModelSelection | null;
         thinkingLevel?: string | null;
         modelNotice?: string;
+        agentNotice?: string;
         parentConversationId?: string;
         origin?: "user" | "orchestrator";
     }): Promise<Conversation>;
@@ -341,6 +342,16 @@ export declare class Store {
     /** Restoring deletes the key rather than setting it to null, so a fully restored conversation serializes
      *  byte-identically to one that was never archived. `delete` is legal here because the field is optional. */
     unarchiveConversation(conversationId: string): Promise<void>;
+    /**
+     * Archives one whole tree as one state write. Only a conversation with no existing parent may
+     * start it; an archived parent is still a parent, so its active descendants cannot be archived
+     * independently. All running checks happen before the first mutation, making rejection all-or-none.
+     */
+    archiveConversationTree(conversationId: string): Promise<void>;
+    /** Restores one archived tree in one write; active descendants are already restored by definition. */
+    unarchiveConversationTree(conversationId: string): Promise<void>;
+    /** Pre-order traversal with cycle protection; archived nodes are traversed, not treated as leaves. */
+    private conversationSubtree;
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
      * for exactly the reason archive is: `updatedAt` is the sidebar's recency key, so bumping it would

package/dist/server/store.js

@@ -1060,7 +1060,7 @@ export class Store {
         // here and never consulted again: the session picker edits the conversation's own fields, so an
         // existing conversation is untouched by later workspace settings, and a workspace edit never
         // rewrites history. Field by field, never a spread, for the same reason setConversationModel
-        // narrows: the type declares three fields, so three fields are written.
+        // narrows: every inherited field has an explicit birth override, including null for Pi's default.
         if (workspace.defaultModel)
             conversation.model = { provider: workspace.defaultModel.provider, modelId: workspace.defaultModel.modelId, label: workspace.defaultModel.label };
         if (workspace.defaultThinkingLevel)
@@ -1072,6 +1072,8 @@ export class Store {
             // rewritten: it describes how this conversation came to be, not what is true right now.
             if (configuration.modelNotice !== undefined)
                 conversation.modelNotice = configuration.modelNotice;
+            if (configuration.agentNotice !== undefined)
+                conversation.agentNotice = configuration.agentNotice;
             if (configuration.model !== undefined) {
                 if (configuration.model)
                     conversation.model = { ...configuration.model };
@@ -1084,8 +1086,12 @@ export class Store {
                 else
                     delete conversation.thinkingLevel;
             }
-            if (configuration.agentId)
-                conversation.agentId = configuration.agentId;
+            if (configuration.agentId !== undefined) {
+                if (configuration.agentId)
+                    conversation.agentId = configuration.agentId;
+                else
+                    delete conversation.agentId;
+            }
             // THE SESSION TREE'S EDGE, WRITTEN AT BIRTH. Both fields describe how this conversation CAME TO
             // BE, exactly like modelNotice above, so they are set once here and never rewritten: the tree
             // the sidebar draws after a restart is the tree that was true when each session was opened.
@@ -1232,6 +1238,67 @@ export class Store {
         delete conversation.archivedAt;
         await this.persistMetadata(conversationId);
     }
+    /**
+     * Archives one whole tree as one state write. Only a conversation with no existing parent may
+     * start it; an archived parent is still a parent, so its active descendants cannot be archived
+     * independently. All running checks happen before the first mutation, making rejection all-or-none.
+     */
+    async archiveConversationTree(conversationId) {
+        const root = this.requireConversation(conversationId);
+        if (root.parentConversationId && this.state.conversations.some(item => item.id === root.parentConversationId)) {
+            throw new Error("子会话不能独立归档，请从根会话归档整棵树");
+        }
+        if (root.archivedAt)
+            return;
+        const active = this.conversationSubtree(root).filter(item => !item.archivedAt);
+        const running = active.find(item => item.status === "running");
+        if (running)
+            throw new Error(`会话「${running.title}」正在运行，无法归档整棵树，请先停止运行`);
+        const archivedAt = now();
+        for (const conversation of active)
+            conversation.archivedAt = archivedAt;
+        await this.persist();
+    }
+    /** Restores one archived tree in one write; active descendants are already restored by definition. */
+    async unarchiveConversationTree(conversationId) {
+        const root = this.requireConversation(conversationId);
+        const parent = root.parentConversationId
+            ? this.state.conversations.find(item => item.id === root.parentConversationId)
+            : undefined;
+        if (parent?.archivedAt)
+            throw new Error("归档树中的子会话不能独立恢复，请从归档树的根会话恢复整棵树");
+        if (!root.archivedAt)
+            return;
+        const archived = this.conversationSubtree(root).filter(item => item.archivedAt);
+        for (const conversation of archived)
+            delete conversation.archivedAt;
+        await this.persist();
+    }
+    /** Pre-order traversal with cycle protection; archived nodes are traversed, not treated as leaves. */
+    conversationSubtree(root) {
+        const byParent = new Map();
+        for (const conversation of this.state.conversations) {
+            if (conversation.workspaceId !== root.workspaceId || !conversation.parentConversationId)
+                continue;
+            const siblings = byParent.get(conversation.parentConversationId);
+            if (siblings)
+                siblings.push(conversation);
+            else
+                byParent.set(conversation.parentConversationId, [conversation]);
+        }
+        const result = [];
+        const visited = new Set();
+        const walk = (conversation) => {
+            if (visited.has(conversation.id))
+                return;
+            visited.add(conversation.id);
+            result.push(conversation);
+            for (const child of byParent.get(conversation.id) ?? [])
+                walk(child);
+        };
+        walk(root);
+        return result;
+    }
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
      * for exactly the reason archive is: `updatedAt` is the sidebar's recency key, so bumping it would

package/dist/server/types.d.ts

@@ -503,6 +503,9 @@ export type Conversation = {
      * not what is true right now.
      */
     modelNotice?: string;
+    /** Why this conversation started on Pi's default agent instead of the workspace's deleted default.
+     *  Written once at birth, like modelNotice, and rendered verbatim. */
+    agentNotice?: string;
     /** Absent means "Pi's own default", which is why a conversation created before the picker existed still works. */
     model?: ModelSelection;
     thinkingLevel?: string;