@evandu/super-pi 0.1.162 → 0.1.164

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-PN2dNRnQ.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-unAm6EaY.css">
+    <script type="module" crossorigin src="/assets/index-1hS3wVqF.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Wtlj0s4R.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -1,5 +1,5 @@
 import type { Store } from "../store.js";
-import type { Project, ProjectEscalation, ProjectMode, ProjectReport, ProjectRisk, ProjectTask, SessionProfile } from "../types.js";
+import type { Project, ProjectEscalation, ProjectMode, ProjectReport, ProjectRisk, ProjectSummary, ProjectTask, SessionProfile } from "../types.js";
 import type { SessionOrchestratorService } from "./session-orchestrator-service.js";
 export declare const profile: (value: unknown, label: string) => SessionProfile | undefined;
 export declare const mergeProfile: (taskProfile?: SessionProfile, projectDefault?: SessionProfile) => SessionProfile | undefined;
@@ -95,6 +95,10 @@ export declare class ProjectService {
     private reconcile;
     private resources;
     list(workspaceId?: string): Project[];
+    headline(p: Project): string;
+    private isActorRelated;
+    private projectSummary;
+    listForActor(workspaceId: string, actor: string): ProjectSummary[];
     get(id: string, workspaceId?: string): Project;
     /**
      * THE PROJECT AS A REPORT A HUMAN CAN READ.

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

@@ -122,6 +122,20 @@ const CACHE_WRITE_WEIGHT = 1.25;
 const tokens = (usage) => usage ? Math.round(usage.input + usage.output + usage.cacheWrite * CACHE_WRITE_WEIGHT + usage.cacheRead * CACHE_READ_WEIGHT) : 0;
 /** The budget a project starts with, and the floor the one-click raise falls back to. */
 const DEFAULT_MAX_TOKENS = 100_000;
+/**
+ * HOW MANY EVENTS THE REPORT'S TIMELINE PRINTS.
+ *
+ * A project that ran for weeks has thousands of events, and a timeline that lists all of them
+ * is not a document - it is a wall of text nobody reads, and it makes the report too big to
+ * paste into a weekly note. So the timeline prints the MOST RECENT 200 events and says, in
+ * front of the list, how many there were in total: a reader then knows that the list is the
+ * tail of a longer story rather than the whole of it.
+ *
+ * ONLY THE EVENT STREAM IS CONVERGED. The tasks, the deliveries, the acceptances, the
+ * exceptions and the recent reports are the report itself - they are all still printed, one by
+ * one, because dropping any of them would drop the answer to "what did this project do".
+ */
+const REPORT_EVENT_LIMIT = 200;
 // THE WORDS THE REPORT SPEAKS IN. A reader of the report is a person, not a console, so every
 // state and every role is written the way a person would say it out loud.
 const PROJECT_STATUS_TEXT = {
@@ -331,6 +345,16 @@ export class ProjectService {
                 }
         }
         const coordinatorIds = new Set([p.ownerConversationId, ...p.tasks.filter((t) => t.role === "leader").map((t) => t.ownerConversationId)].filter(Boolean));
+        /* THE MEMORY TREE OF THE PROJECT, AND OF EVERY SESSION IN IT.
+         *
+         * Since 0.1.161 a project opens its OWN memory tree: the leader session is the root of it and
+         * the workers inherit it, so the project's memories never mix with the Boss's chat. That is
+         * invisible from the outside - the client draws a tree of sessions and cannot tell which
+         * memories are behind it. So the server says it outright: the tree each session belongs to,
+         * and whether that tree is the project's own ("project") or the one it shares with the
+         * initiator's conversation ("shared"). The leader is the root of the project's tree, so it is
+         * "project" by the same rule as everybody else - there is no special case for it. */
+        const projectTreeId = p.ownerConversationId ? this.store.conversation(p.ownerConversationId)?.treeId : undefined;
         const sessions = state.conversations.filter((c) => c.workspaceId === p.workspaceId && members.has(c.id)).map((c) => ({
             id: c.id, title: c.title, status: c.status, tokens: tokens(c.usage), contextPercent: c.contextUsage?.percent,
             // THE TREE SKELETON. The client draws the agents of a project as a tree, and the only
@@ -338,6 +362,10 @@ export class ProjectService {
             // verbatim (including the undefined case, which means "this session has no parent in
             // this collection" - i.e. it is a root of the tree).
             parentConversationId: c.parentConversationId,
+            // WHOSE MEMORY THIS SESSION WORKS FROM. The project's own tree is the one the leader
+            // opened; anything else is a session that still shares the initiator's chat memory.
+            memoryTreeId: c.treeId,
+            memoryScope: projectTreeId && c.treeId === projectTreeId ? "project" : "shared",
             role: c.id === p.ownerConversationId ? "项目负责人" : coordinatorIds.has(c.id) ? "分支 Leader" : p.tasks.some((t) => t.reviewerConversationId === c.id) ? "独立复核" : "执行者",
         }));
         const runs = state.subagentRuns.filter((r) => members.has(r.conversationId));
@@ -348,12 +376,92 @@ export class ProjectService {
         const leaderIsWorker = lightweight(p) && p.ownerConversationId !== undefined;
         return { tokens: sessions.reduce((sum, s) => sum + s.tokens, 0) + runs.reduce((sum, r) => sum + tokens(r.usage), 0),
             usageKnown: sessions.length > 0 && sessions.every((s) => Boolean(this.store.conversation(s.id)?.usage)) && runs.every((r) => Boolean(r.usage)),
-            activeWorkers: sessions.filter((s) => (!coordinatorIds.has(s.id) || (leaderIsWorker && s.id === p.ownerConversationId)) && busy(s.status)).length + runs.filter((r) => r.status === "running").length, sessions };
+            activeWorkers: sessions.filter((s) => (!coordinatorIds.has(s.id) || (leaderIsWorker && s.id === p.ownerConversationId)) && busy(s.status)).length + runs.filter((r) => r.status === "running").length,
+            // THE PROJECT'S OWN MEMORY TREE, named once so the client does not have to infer it from
+            // the sessions. Absent only when the project has no leader session yet.
+            memoryTreeId: projectTreeId, sessions };
     }
     list(workspaceId) {
         const scope = this.workspace(workspaceId);
         return this.store.projects().filter((p) => p.workspaceId === scope).map((p) => this.projectView(p));
     }
+    headline(p) {
+        const total = p.tasks.length;
+        const completed = p.tasks.filter((t) => t.status === "completed").length;
+        if (p.status === "completed") {
+            return total > 0 ? `项目已完成（${completed}/${total} 任务已验收）` : "项目已完成";
+        }
+        if (p.status === "cancelled")
+            return "项目已取消";
+        if (p.status === "failed")
+            return "项目失败";
+        const openEscalation = (p.escalations ?? []).find((e) => e.status === "open");
+        if (openEscalation) {
+            return p.status === "awaiting_approval"
+                ? `等待审批：${openEscalation.reason}`
+                : `项目已阻塞：${openEscalation.reason}`;
+        }
+        const blockedTask = p.tasks.find((t) => t.status === "blocked");
+        if (blockedTask) {
+            const reason = blockedTask.blockedReason ? `（${blockedTask.blockedReason}）` : "";
+            return `项目已阻塞：${blockedTask.title}${reason}`;
+        }
+        const inProgressTask = p.tasks.find((t) => t.status === "in_progress");
+        if (inProgressTask) {
+            return `${completed}/${total} 任务完成，正在执行${inProgressTask.title}`;
+        }
+        const reviewTask = p.tasks.find((t) => t.status === "awaiting_review");
+        if (reviewTask) {
+            return `${completed}/${total} 任务完成，正在复核${reviewTask.title}`;
+        }
+        const readyTask = p.tasks.find((t) => t.status === "ready");
+        if (readyTask) {
+            return `${completed}/${total} 任务完成，待派发${readyTask.title}`;
+        }
+        if (total > 0) {
+            return `${completed}/${total} 任务完成，等待前置依赖`;
+        }
+        return "项目规划中，尚未拆解任务";
+    }
+    isActorRelated(p, actor) {
+        if (!actor)
+            return false;
+        if (actor === p.initiatorConversationId)
+            return true;
+        if (actor === p.ownerConversationId)
+            return true;
+        if (p.tasks?.some((t) => t.ownerConversationId === actor || t.reviewerConversationId === actor))
+            return true;
+        if (this.projectForSession(actor)?.id === p.id)
+            return true;
+        return false;
+    }
+    projectSummary(p) {
+        const resources = this.resources(p);
+        return {
+            id: p.id,
+            name: p.title,
+            status: p.status,
+            mode: p.mode ?? "standard",
+            headline: this.headline(p),
+            tasks: {
+                total: p.tasks.length,
+                completed: p.tasks.filter((t) => t.status === "completed").length,
+                inProgress: p.tasks.filter((t) => t.status === "in_progress").length,
+                blocked: p.tasks.filter((t) => t.status === "blocked").length,
+            },
+            activeWorkers: resources.activeWorkers,
+            tokens: resources.tokens,
+            updatedAt: p.updatedAt,
+        };
+    }
+    listForActor(workspaceId, actor) {
+        const scope = this.workspace(workspaceId);
+        return this.store.projects()
+            .filter((p) => p.workspaceId === scope && this.isActorRelated(p, actor))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+            .map((p) => this.projectSummary(p));
+    }
     get(id, workspaceId) {
         return this.projectView(this.raw(id, workspaceId));
     }
@@ -450,8 +558,17 @@ export class ProjectService {
         const events = [...(p.events ?? [])].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
         if (!events.length)
             lines.push("无");
-        for (const e of events)
-            lines.push(`- ${moment(e.createdAt)} · ${EVENT_TEXT[e.kind] ?? e.kind} · ${oneLine(e.summary)} · ${session(e.actorConversationId)}`);
+        else {
+            /* THE TIMELINE IS CONVERGED, AND SAYS SO. The list is the tail of the project's story -
+               the most recent events, still in time order - and the number in front of it is how
+               long the whole story was, so a reader never mistakes the tail for the whole. */
+            const shown = events.length > REPORT_EVENT_LIMIT ? events.slice(-REPORT_EVENT_LIMIT) : events;
+            lines.push(events.length > REPORT_EVENT_LIMIT
+                ? `共 ${events.length} 条事件，以下是最近 ${REPORT_EVENT_LIMIT} 条（更早的省略）`
+                : `共 ${events.length} 条事件`);
+            for (const e of shown)
+                lines.push(`- ${moment(e.createdAt)} · ${EVENT_TEXT[e.kind] ?? e.kind} · ${oneLine(e.summary)} · ${session(e.actorConversationId)}`);
+        }
         lines.push("", "## 最近汇报", "");
         if (!p.reports.length)
             lines.push("无");
@@ -1219,6 +1336,9 @@ export class ProjectService {
             await this.registerTopLevelTasks(project.id, plan, workspaceId, actor);
             return this.get(project.id, workspaceId);
         }
+        if (body.action === "list") {
+            return this.listForActor(workspaceId, actor);
+        }
         const id = text(body.projectId, "projectId");
         const p = this.get(id, workspaceId);
         this.member(p, actor);

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

@@ -102,6 +102,9 @@ export declare class RunService {
     private readonly runCompletions;
     /** A selected interrupt owns the next free run slot, even while the old child exits. */
     private readonly interruptTargets;
+    private shuttingDown;
+    /** Preserve incoming background results as waiting messages while the server drains its producers. */
+    beginShutdown(): void;
     /** Claims the run slot and arms its completion promise. Call sites release with `releaseRunSlot`. */
     private claimRunSlot;
     /** Releases the run slot and settles its completion promise, so a waiter wakes on the SAME instruction. */

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

@@ -176,8 +176,15 @@ export class RunService {
     runCompletions = new Map();
     /** A selected interrupt owns the next free run slot, even while the old child exits. */
     interruptTargets = new Map();
+    shuttingDown = false;
+    /** Preserve incoming background results as waiting messages while the server drains its producers. */
+    beginShutdown() {
+        this.shuttingDown = true;
+    }
     /** Claims the run slot and arms its completion promise. Call sites release with `releaseRunSlot`. */
     claimRunSlot(conversationId, controller) {
+        if (this.shuttingDown)
+            throw new Error("服务正在关闭，请重启后再发送消息。");
         let resolve;
         const promise = new Promise((resolvePromise) => { resolve = resolvePromise; });
         this.runCompletions.set(conversationId, { promise, resolve });
@@ -322,7 +329,7 @@ export class RunService {
                 //
                 // BUSY: steer the result into the running turn so Pi drains it at the very next tool batch
                 // boundary instead of waiting for the whole turn to complete.
-                void this.dispatchBackgroundResult(task.conversationId, queued.id).catch(async (error) => {
+                void this.trackDetached(this.dispatchBackgroundResult(task.conversationId, queued.id)).catch(async (error) => {
                     console.warn(`Super Pi: dispatch background exec result failed: ${error instanceof Error ? error.message : "unknown error"}`);
                     await this.settleBackgroundStatus(task.conversationId);
                 });
@@ -378,7 +385,7 @@ export class RunService {
             });
             if (!queued)
                 return;
-            void this.dispatchBackgroundResult(parentId, queued.id).catch((error) => {
+            void this.trackDetached(this.dispatchBackgroundResult(parentId, queued.id)).catch((error) => {
                 console.warn(`Super Pi: dispatch child session result failed: ${error instanceof Error ? error.message : "unknown error"}`);
             });
         })());
@@ -392,6 +399,8 @@ export class RunService {
      * INTERRUPTING: quietly leaves the message waiting; the interrupted or next turn will pick it up.
      */
     async dispatchBackgroundResult(conversationId, messageId) {
+        if (this.shuttingDown)
+            return;
         if (this.interruptTargets.has(conversationId))
             return;
         if (!this.activeRuns.has(conversationId)) {
@@ -404,7 +413,7 @@ export class RunService {
             // so calling it from inside the serialized callback re-enters the lane and deadlocks: the
             // outer work waits for the inner one, and the inner one waits for the outer one.
             const startWaiting = await this.serializeConversation(conversationId, async () => {
-                if (this.interruptTargets.has(conversationId))
+                if (this.shuttingDown || this.interruptTargets.has(conversationId))
                     return false;
                 // `processWaitingMessage` acquires this lane, so the fallback must run after serialization exits.
                 if (!this.activeRuns.has(conversationId))
@@ -421,6 +430,11 @@ export class RunService {
                 this.broadcaster.broadcastState();
                 const claimed = await this.store.claimWaitingMessage(conversationId, messageId);
                 this.broadcaster.broadcastState();
+                if (this.shuttingDown) {
+                    await this.store.releaseWaitingMessage(conversationId, claimed.id);
+                    this.broadcaster.broadcastState();
+                    return false;
+                }
                 try {
                     await this.runtime.steer(conversationId, composePrompt(claimed), claimed.images);
                 }
@@ -1788,14 +1802,15 @@ export class RunService {
             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();
+        const queueOnly = busy || this.shuttingDown;
+        const reservedController = queueOnly ? 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" } : {}) });
+            message = await this.store.addAgentMessage(conversationId, trimmed, { ...(queueOnly ? { delivery: "waiting" } : {}) });
         }
         catch (error) {
             if (reservedController)
@@ -1896,16 +1911,17 @@ export class RunService {
         }
         this.assertHistoryAvailable(conversationId);
         const busy = this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id);
+        const queueOnly = busy || this.shuttingDown;
         // Reserve BEFORE the first persistence await. Revert/stop must see this admitted send even while
         // its message write is pending; otherwise a cut can start while this send goes on to launch Pi.
-        const reservedController = busy ? undefined : new AbortController();
+        const reservedController = queueOnly ? undefined : new AbortController();
         if (reservedController) {
             this.cancelledQuestionConversations.delete(conversation.id);
             this.claimRunSlot(conversation.id, reservedController);
         }
         let message;
         try {
-            message = await this.store.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(busy ? { delivery: "waiting" } : {}) });
+            message = await this.store.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(queueOnly ? { delivery: "waiting" } : {}) });
         }
         catch (error) {
             if (reservedController)
@@ -2140,6 +2156,8 @@ export class RunService {
         // steer/reorder/cancel wait until that turn ends, which is especially visible after a background
         // result auto-starts a long follow-up. The activeRuns slot protects the turn after this lane exits.
         const controller = await this.serializeConversation(conversationId, async () => {
+            if (this.shuttingDown)
+                return undefined;
             this.assertHistoryAvailable(conversationId);
             const reserved = this.interruptTargets.get(conversationId);
             if (reserved && reserved !== messageId)
@@ -2154,6 +2172,8 @@ export class RunService {
             this.claimRunSlot(conversationId, controller);
             return controller;
         });
+        if (!controller)
+            return;
         try {
             const { conversation, workspace } = this.turnContext(conversationId);
             const message = conversation.messages.find((item) => item.id === messageId);

package/dist/server/application/session-watchdog.d.ts

@@ -83,6 +83,12 @@ export declare class SessionWatchdog {
     private readonly timers;
     /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
     private readonly writes;
+    /** A shutdown is a fence: no timer may start another reminder after it is raised. */
+    private disposed;
+    /** Reminders already accepted by a timer before shutdown still own their state and disk writes. */
+    private readonly inFlight;
+    /** Every caller must observe the same drain, including callers that arrive while it is running. */
+    private disposal;
     constructor(host: WatchdogHost);
     /**
      * Declares (or re-declares) the watchdog for a child.
@@ -121,8 +127,14 @@ export declare class SessionWatchdog {
      * remaining time is measured from the last sign of life, not from the restart.
      */
     restore(): Promise<void>;
-    /** Stops every timer. The process is going away; the state stays on disk. */
-    dispose(): void;
+    /**
+     * Stops reminder production and drains work the timers had already accepted.
+     *
+     * `disposed` is set before the first await so a timer cannot sneak a second reminder into the
+     * shutdown window. A reminder that was already in `onTimeout` remains owned by this instance:
+     * its parent delivery and the state write must finish before its workspace can be removed.
+     */
+    dispose(): Promise<void>;
     /**
      * Arms the timer for one entry.
      *

package/dist/server/application/session-watchdog.js

@@ -19,6 +19,12 @@ export class SessionWatchdog {
     timers = new Map();
     /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
     writes = new Map();
+    /** A shutdown is a fence: no timer may start another reminder after it is raised. */
+    disposed = false;
+    /** Reminders already accepted by a timer before shutdown still own their state and disk writes. */
+    inFlight = new Set();
+    /** Every caller must observe the same drain, including callers that arrive while it is running. */
+    disposal;
     constructor(host) {
         this.host = host;
     }
@@ -30,6 +36,8 @@ export class SessionWatchdog {
      * watchdog that quietly switched itself off would leave the parent believing it was still watched.
      */
     async arm(input) {
+        if (this.disposed)
+            return;
         const { childConversationId } = input;
         if (!childConversationId.trim())
             return;
@@ -64,6 +72,8 @@ export class SessionWatchdog {
      * the child is out of sight.
      */
     async noteSignal(childConversationId) {
+        if (this.disposed)
+            return;
         const entry = this.entries.get(childConversationId);
         if (!entry)
             return;
@@ -99,6 +109,8 @@ export class SessionWatchdog {
      * remaining time is measured from the last sign of life, not from the restart.
      */
     async restore() {
+        if (this.disposed)
+            return;
         for (const workspaceId of this.host.workspaceIds()) {
             const path = this.statePath(workspaceId);
             if (!path)
@@ -117,6 +129,8 @@ export class SessionWatchdog {
             if (!records || typeof records !== "object")
                 continue;
             for (const [childConversationId, record] of Object.entries(records)) {
+                if (this.disposed)
+                    return;
                 if (!record || typeof record.timeoutSeconds !== "number" || !record.parentConversationId)
                     continue;
                 const entry = {
@@ -132,11 +146,27 @@ export class SessionWatchdog {
             }
         }
     }
-    /** Stops every timer. The process is going away; the state stays on disk. */
+    /**
+     * Stops reminder production and drains work the timers had already accepted.
+     *
+     * `disposed` is set before the first await so a timer cannot sneak a second reminder into the
+     * shutdown window. A reminder that was already in `onTimeout` remains owned by this instance:
+     * its parent delivery and the state write must finish before its workspace can be removed.
+     */
     dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
         for (const timer of this.timers.values())
             clearTimeout(timer);
         this.timers.clear();
+        this.disposal = (async () => {
+            await Promise.allSettled([...this.inFlight]);
+            // In-flight reminders can append state writes after the first drain starts, so take this
+            // snapshot only after they have settled.
+            await Promise.allSettled([...this.writes.values()]);
+        })();
+        return this.disposal;
     }
     /**
      * Arms the timer for one entry.
@@ -145,11 +175,17 @@ export class SessionWatchdog {
      * allowed to shut down with a watchdog in flight, and the state is on disk anyway.
      */
     schedule(entry) {
+        if (this.disposed || this.entries.get(entry.childConversationId) !== entry)
+            return;
         this.clearTimer(entry.childConversationId);
         const elapsed = Date.now() - entry.lastSignalAt;
         const remaining = Math.max(0, entry.timeoutSeconds * 1000 - elapsed);
         const timer = setTimeout(() => {
-            void this.fire(entry.childConversationId);
+            if (this.disposed)
+                return;
+            const firing = this.fire(entry.childConversationId);
+            this.inFlight.add(firing);
+            void firing.then(() => this.inFlight.delete(firing), () => this.inFlight.delete(firing));
         }, remaining);
         timer.unref?.();
         this.timers.set(entry.childConversationId, timer);
@@ -174,6 +210,8 @@ export class SessionWatchdog {
      * cannot speak any more is noise, not information.
      */
     async fire(childConversationId) {
+        if (this.disposed)
+            return;
         const entry = this.entries.get(childConversationId);
         if (!entry)
             return;
@@ -195,6 +233,8 @@ export class SessionWatchdog {
         catch (error) {
             this.host.warn?.(`Super Pi: watchdog reminder for ${childConversationId} failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+        // Shutdown must preserve a reminder that was already accepted, but it must not schedule its
+        // successor after that reminder has drained.
         entry.endedReminded = !childWorking;
         entry.lastSignalAt = Date.now();
         await this.persist(entry.workspaceId);

package/dist/server/index.js

@@ -108,7 +108,12 @@ const agentPromptDir = join(dataDir, "agent-prompts");
 const clientDir = join(rootDir, "dist", "client");
 const accessToken = process.env.SUPER_PI_ACCESS_TOKEN;
 const uploadsDir = join(dataDir, "uploads");
-await mkdir(uploadsDir, { recursive: true }).catch(() => { });
+try {
+    await mkdir(uploadsDir, { recursive: true });
+}
+catch (error) {
+    logging.write("warn", `uploads directory unavailable: ${error instanceof Error ? error.message : String(error)}`);
+}
 const taskEndpoint = `http://${internalHost}:${port}/api/subagent/dispatch`;
 const execEndpoint = `http://${internalHost}:${port}/api/exec`;
 const todoEndpoint = `http://${internalHost}:${port}/api/todos`;
@@ -339,6 +344,7 @@ async function shutdown(reason) {
         return shutdownPromise;
     shutdownPromise = (async () => {
         console.log(`Super Pi is shutting down (${reason}).`);
+        runService.beginShutdown();
         // Stop accepting new connections first. Existing clients stay connected until
         // their cancelled work has recorded its terminal state.
         const httpClosed = closeHttpServer();
@@ -354,6 +360,7 @@ async function shutdown(reason) {
         for (const c of store.snapshot().conversations) {
             extensionUiService.cancelPendingUi(c.id, "aborted");
         }
+        await sessionOrchestratorService.watchdog.dispose();
         await Promise.all([runService.waitForIdle(), workflows.waitForIdle()]);
         // THE LIVE SESSIONS GO NEXT, AND THEY HAVE TO GO EXPLICITLY. `runService.abortAll()` stops the
         // TURNS, and a stopped turn is not a stopped session: a session with nothing running on it is idle,

package/dist/server/tool-runner.js

@@ -8,6 +8,15 @@ const MAX_TIMEOUT_MS = 10 * 60_000;
 /** The environment build gets its OWN budget: a cold `pip install` must not eat the tool's timeout. */
 const MAX_ENV_TIMEOUT_MS = 10 * 60_000;
 const isWindows = process.platform === "win32";
+/** Keep OS architecture fallback data without exposing unrelated host configuration to Python. */
+function pythonEnvironment() {
+    return {
+        PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP,
+        PROCESSOR_ARCHITECTURE: process.env.PROCESSOR_ARCHITECTURE,
+        PROCESSOR_ARCHITEW6432: process.env.PROCESSOR_ARCHITEW6432,
+        PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1",
+    };
+}
 /** Runs a registered Python entrypoint without a shell. It intentionally accepts no command string. */
 export class ToolRunner {
     dataDir;
@@ -154,7 +163,7 @@ export class ToolRunner {
     }
     launch(id, active, python, input) {
         // -I ignores user Python configuration and user site packages. No shell means params never become code.
-        const child = spawn(python.path, ["-I", "-u", input.script], { cwd: input.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP, PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1", SUPER_PI_TOOL_ID: input.toolId } });
+        const child = spawn(python.path, ["-I", "-u", input.script], { cwd: input.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { ...pythonEnvironment(), SUPER_PI_TOOL_ID: input.toolId } });
         active.child = child;
         // A PIPE CARRIES BYTES, AND A READ BOUNDARY CAN LAND INSIDE A CHARACTER. A Chinese character is
         // three bytes, so decoding one chunk at a time turns every character that straddles a boundary
@@ -210,7 +219,7 @@ export class ToolRunner {
 function runCapture(python, args, timeoutMs, onOutput) {
     return new Promise((resolve) => {
         let stdout = "", stderr = "", settled = false;
-        const child = spawn(python, args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP, PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1" } });
+        const child = spawn(python, args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env: pythonEnvironment() });
         const timer = setTimeout(() => { if (settled)
             return; settled = true; try {
             child.kill();

package/dist/server/types.d.ts

@@ -1033,10 +1033,25 @@ export type Project = {
      * and any orphan left behind by an older layout). Without it the panel can only show a row
      * per session, and the hierarchy - who reported to whom - stays invisible.
      */
+    /**
+     * The project's live sessions, with the tree skeleton and the memory scope attached.
+     *
+     * `parentConversationId` is what lets the client draw a TREE rather than a flat list: a
+     * session whose parent is not in this collection is a ROOT of the tree (the project leader,
+     * and any orphan left behind by an older layout). Without it the panel can only show a row
+     * per session, and the hierarchy - who reported to whom - stays invisible.
+     *
+     * `memoryScope` says whose memory a session works from: "project" for the sessions that live
+     * in the PROJECT'S OWN memory tree (the leader, and every worker that inherited it), "shared"
+     * for a session that still reads the initiator's chat memory. The panel shows it as a small
+     * mark on every agent, because a reader who cannot tell the two apart cannot tell what a
+     * session remembers.
+     */
     resources?: {
         tokens: number;
         usageKnown: boolean;
         activeWorkers: number;
+        memoryTreeId?: string;
         sessions: {
             id: string;
             title: string;
@@ -1045,6 +1060,8 @@ export type Project = {
             tokens: number;
             contextPercent?: number | null;
             parentConversationId?: string;
+            memoryTreeId?: string;
+            memoryScope?: "project" | "shared";
         }[];
     };
     /**
@@ -1063,6 +1080,22 @@ export type Project = {
     updatedAt: string;
     closedAt?: string;
 };
+export type ProjectSummary = {
+    id: string;
+    name: string;
+    status: string;
+    mode: "standard" | "lightweight";
+    headline: string;
+    tasks: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        blocked: number;
+    };
+    activeWorkers: number;
+    tokens: number;
+    updatedAt: string;
+};
 export type AppState = {
     modelFilterRules?: ModelFilterRule[];
     defaultModel?: ModelSelection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.162",
+  "version": "0.1.164",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",