@evandu/super-pi 0.1.162 → 0.1.163

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-CLV7t20O.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

@@ -331,6 +331,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 +348,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 +362,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));
     }
@@ -1219,6 +1313,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/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.163",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",