@evandu/super-pi 0.1.140 → 0.1.142

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,13 +1086,55 @@ 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.
+            // Written only when present, so a conversation created without them (the user's own "+") reads
+            // as a top-level one on every code path, including every state.json from before this field.
+            if (configuration.parentConversationId)
+                conversation.parentConversationId = configuration.parentConversationId;
+            if (configuration.origin)
+                conversation.origin = configuration.origin;
         }
         this.state.conversations.unshift(conversation);
         await this.persist();
         return structuredClone(conversation);
     }
+    /**
+     * Records (or clears) one conversation as collapsed in the sidebar's session tree. The list is a
+     * SET in array clothing - order means nothing, duplicates must not accumulate - and it follows the
+     * assign -> persist -> rollback pattern `setTerminalShell` established: the in-memory value is the
+     * previous value again the moment persistence fails, so a rejected write can never leave the
+     * screen and the disk disagreeing.
+     */
+    async setConversationCollapsed(conversationId, collapsed) {
+        const previous = this.state.collapsedConversationIds;
+        const next = new Set(previous ?? []);
+        if (collapsed)
+            next.add(conversationId);
+        else
+            next.delete(conversationId);
+        if (next.size === 0)
+            delete this.state.collapsedConversationIds;
+        else
+            this.state.collapsedConversationIds = [...next];
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            if (previous === undefined)
+                delete this.state.collapsedConversationIds;
+            else
+                this.state.collapsedConversationIds = previous;
+            throw error;
+        }
+    }
     /**
      * Copies a conversation into a NEW one, under an id the caller has already minted.
      *
@@ -1194,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;
@@ -516,6 +519,21 @@ export type Conversation = {
      * deleted agent degrades to "no role" instead of leaving a stale snapshot in state.json.
      */
     agentId?: string;
+    /**
+     * The conversation that opened this one, when an orchestrator agent created it. Absent for a
+     * conversation the user started. This is the session tree's edge, and it PERSISTS: the sidebar
+     * draws the hierarchy from it after a restart, which a server-side in-memory ledger cannot do.
+     * Absence also reads correctly on every state.json written before this field existed - no parent
+     * recorded simply means "top level", which is what those conversations genuinely are.
+     */
+    parentConversationId?: string;
+    /**
+     * Who opened this conversation. "user" for one the user started, "orchestrator" for one an agent
+     * created. Kept beside the parent id because a conversation can be an orchestrator's without
+     * having a parent (the top-level orchestrator), and because the context menu's "stop the session
+     * AND its queue" needs to know a queue exists without polling the orchestrator's ledger.
+     */
+    origin?: "user" | "orchestrator";
 };
 /**
  * One parsed agent definition, as read from an `agents/*.md` file. `prompt` is the file body and is the
@@ -863,7 +881,13 @@ export type AppState = {
     todosByConversation?: Record<string, TodoItem[]>;
     workflows?: WorkflowRun[];
     scheduledTasks?: ScheduledTask[];
-    customAgentDirs?: string[];
+    customAgentDirs?: string[]; /**
+     * Which conversations the reader has collapsed in the sidebar's session tree, by conversation id.
+     * Server-side so the tree looks the same after a restart and on another machine - the sidebar is a
+     * view of the PRODUCT's state, not of one browser's session. Absent (older state.json) means
+     * "nothing collapsed", which is the correct reading of a preference that did not exist yet.
+     */
+    collapsedConversationIds?: string[];
 };
 export type TodoItem = {
     id?: string;
@@ -1158,6 +1182,17 @@ export type ClientCommandBody =
 } | {
     type: "conversation.unarchive";
     conversationId: string;
+}
+/**
+ * Collapses or expands one conversation's whole subtree in the sidebar's session tree. The state
+ * lives SERVER-SIDE (`AppState.collapsedConversationIds`), not in the browser: the tree must look
+ * the same after a restart and on another machine, and a bare WS client must not be able to leave
+ * the server's truth and the screen's truth disagreeing about a preference the product owns.
+ */
+ | {
+    type: "conversation.collapse";
+    conversationId: string;
+    collapsed: boolean;
 } | {
     type: "conversation.rename";
     conversationId: string;