@evandu/super-pi 0.1.164 → 0.1.166

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

@@ -4,13 +4,22 @@ const stamp = () => new Date().toISOString();
  * WHAT THE PROJECT LEADER IS TOLD WHEN IT STARTS.
  *
  * The two prompts are kept apart on purpose. The standard one is the shape the project flow has
- * always had - decompose, delegate, review - and it is not touched. The lightweight one is a
- * different set of instructions about a different shape: one session, no decomposition, no
- * reviewer. Writing one prompt with holes in it would mean every sentence had to carry a
- * condition, and the model would have to work out which shape it was in.
+ * always had - decompose, delegate, review. The lightweight one is a different set of
+ * instructions about a different shape: one session, no decomposition, no reviewer. Writing one
+ * prompt with holes in it would mean every sentence had to carry a condition, and the model would
+ * have to work out which shape it was in.
+ *
+ * THE ESCALATION RULE IS SAID ONCE, IN ONE VOICE. The standard leader used to be told two
+ * opposite things about the same event - "your subordinates' escalations come to you first, you
+ * decide whether to handle them yourself or report them up" AND "you must not resolve escalations
+ * yourself" - and a model reading both has no way to pick, so it hesitates between them. The
+ * rule is now one sentence with three parts: handle it at your own level, escalate only what
+ * really needs the Boss, and never decide for the Boss or drop an escalation. The lightweight
+ * leader has no subordinates at all, so it is told the second half only - it must not decide
+ * alone either - and is never told about subordinates it does not have.
  */
-const STANDARD_LEADER_PROMPT = "你是直接向 Boss 负责的项目 Leader，兼任秘书。先调用 project(action=get, projectId) 了解最新状态。小项目只拆最少必要任务，大项目按交付边界分工。用 add_task 登记任务（明确目标、交付物、验收标准、依赖）；add_task / update_task 时可以带 executorProfile 与 reviewerProfile（支持指定 agentId、cwd、model、thinkingLevel、watchdogTimeoutSeconds），按任务性质将执行与复核委派给最合适的员工，不指定则继承项目默认；需要继续拆解的工作设 role=leader，叶子执行任务设 role=executor，子 Leader 用 parentTaskId 登记自己的子任务，dispatch 启动执行子会话；不要用 session_spawn/session_dispatch 或 task/workflow 绕过项目资源限制。收到交付后用 request_review 启动独立复核。子会话结束会自动回报给你，届时继续派发 ready 任务、复核待验收任务或按 review.summary 返工。不要轮询等待，不要反复无进展重试，并发满时结束当前回复等待回报。用 report 登记关键进展，用 escalate 将重大偏差、权限或预算问题交给 Boss，不得自行解决升级事项。所有任务验收后，用 complete 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。";
-const LIGHTWEIGHT_LEADER_PROMPT = "你是直接向 Boss 负责的项目 Leader，这是一个轻量项目：这个项目由你亲自完成，不要拆子任务、不要派发给别人、也没有独立复核。先调用 project(action=get, projectId) 了解最新状态。用 add_task 登记任务（明确目标、交付物、验收标准、依赖），任务一律登记为执行任务：role=leader 或带 parentTaskId 都会被拒绝。dispatch 会把任务交回给你自己，你亲自做完；做完后调用 project(action=submit, projectId, taskId, output, evidenceRefs) 提交交付，提交即完成，不会有人回来复核，证据必须附上。不要用 session_spawn/session_dispatch 或 task/workflow 绕过项目资源限制。不要轮询等待，不要反复无进展重试。用 report 登记关键进展，用 escalate 将重大偏差、权限或预算问题交给 Boss，不得自行解决升级事项。所有任务交付后，用 complete 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。";
+export const STANDARD_LEADER_PROMPT = "你是直接向 Boss 负责的项目 Leader，兼任秘书。先调用 project(action=get, projectId) 了解最新状态。小项目只拆最少必要任务，大项目按交付边界分工。用 add_task 登记任务（明确目标、交付物、验收标准、依赖）；add_task / update_task 时可以带 executorProfile 与 reviewerProfile（支持指定 agentId、cwd、model、thinkingLevel、watchdogTimeoutSeconds），按任务性质将执行与复核委派给最合适的员工，不指定则继承项目默认；需要继续拆解的工作设 role=leader，叶子执行任务设 role=executor，子 Leader 用 parentTaskId 登记自己的子任务，dispatch 启动执行子会话；不要用 session_spawn/session_dispatch 或 task/workflow 绕过项目资源限制。收到交付后用 request_review 启动独立复核。子会话结束会自动回报给你，届时继续派发 ready 任务、复核待验收任务或按 review.summary 返工。不要轮询等待，不要反复无进展重试，并发满时结束当前回复等待回报。用 report 登记关键进展。你的下属的升级先到你这里：你在自己这一层处理，能自己解决的自己解决；只有确实需要 Boss 决策的（重大偏差、权限或预算问题）才用 escalate 交给 Boss。你不能替 Boss 做决定，也不要把没处理的升级压下去不理。所有任务验收后，用 complete 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。";
+export const LIGHTWEIGHT_LEADER_PROMPT = "你是直接向 Boss 负责的项目 Leader，这是一个轻量项目：这个项目由你亲自完成，不要拆子任务、不要派发给别人、也没有独立复核。先调用 project(action=get, projectId) 了解最新状态。用 add_task 登记任务（明确目标、交付物、验收标准、依赖），任务一律登记为执行任务：role=leader 或带 parentTaskId 都会被拒绝。dispatch 会把任务交回给你自己，你亲自做完；做完后调用 project(action=submit, projectId, taskId, output, evidenceRefs) 提交交付，提交即完成，不会有人回来复核，证据必须附上。不要用 session_spawn/session_dispatch 或 task/workflow 绕过项目资源限制。不要轮询等待，不要反复无进展重试。用 report 登记关键进展，用 escalate 将重大偏差、权限或预算问题交给 Boss，不得自行解决升级事项。所有任务交付后，用 complete 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。";
 const text = (value, label) => {
     if (typeof value !== "string" || !value.trim())
         throw new Error(`${label} 不能为空`);
@@ -122,6 +131,16 @@ 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 PROJECTS ONE LIST CALL MAY CARRY.
+ *
+ * The list goes into an agent's context, and a workspace that has been alive for a year has
+ * hundreds of finished projects. Twenty is enough to answer "how are my projects doing" - the
+ * running ones and the ones that just finished are all in there - and small enough that the
+ * answer does not arrive wrapped in a year of history. The count that was cut is NOT hidden:
+ * the list carries the real total next to the truncated one.
+ */
+const PROJECT_LIST_LIMIT = 20;
 /**
  * HOW MANY EVENTS THE REPORT'S TIMELINE PRINTS.
  *
@@ -150,7 +169,7 @@ const EVENT_TEXT = {
     created: "创建项目", started: "启动执行", task_created: "登记任务", dispatched: "派发执行",
     submitted: "提交交付", reviewed: "复核", review_requested: "启动复核", task_updated: "任务更新", status: "状态变更",
     budget: "预算变更", report: "进展汇报", escalated: "例外升级", decision: "决定",
-    completed: "项目完成", ready: "依赖就绪",
+    completed: "项目完成", ready: "依赖就绪", unreachable: "转述对象不可达",
 };
 const ESCALATION_STATUS_TEXT = { open: "未决", resolved: "已解决", dismissed: "已忽略" };
 const SEVERITY_TEXT = { low: "低", medium: "中", high: "高" };
@@ -202,13 +221,24 @@ export class ProjectService {
             delete t.effectiveReviewerProfile;
         return t;
     }
-    projectView(p) {
+    filterEscalations(escalations, actor) {
+        return escalations.filter((e) => {
+            const audience = e.audience ?? "boss";
+            if (audience === "boss")
+                return true;
+            if (!actor)
+                return false;
+            return actor === e.targetConversationId || actor === e.requestedByConversationId;
+        });
+    }
+    projectView(p, actor) {
         const resources = this.resources(p);
         return {
             ...p,
             resources,
             suggestedMaxTokens: this.suggestedMaxTokens(p, resources.tokens),
             tasks: p.tasks.map((t) => ProjectService.taskView(t, p)),
+            escalations: this.filterEscalations(p.escalations ?? [], actor),
         };
     }
     /**
@@ -241,7 +271,7 @@ export class ProjectService {
         p.updatedAt = stamp();
         (p.events ??= []).push({ id: randomUUID(), kind, summary, taskId, actorConversationId, createdAt: p.updatedAt });
     }
-    async change(id, workspaceId, work) {
+    async change(id, workspaceId, work, actor) {
         this.workspace(workspaceId);
         const previous = this.queues.get(id) ?? Promise.resolve();
         const pending = previous.catch(() => { }).then(async () => {
@@ -253,7 +283,7 @@ export class ProjectService {
             }
             await this.store.setProject(p);
             if (result && typeof result === "object" && "tasks" in result && Array.isArray(result.tasks)) {
-                return structuredClone(this.projectView(result));
+                return structuredClone(this.projectView(result, actor));
             }
             return structuredClone(result);
         });
@@ -268,6 +298,45 @@ export class ProjectService {
     }
     live(p) { if (closed(p))
         throw new Error("项目已结束，不能继续修改或派发"); }
+    /**
+     * WAKING THE OTHER SIDE MUST NOT TAKE THE REPORT DOWN WITH IT.
+     *
+     * The report, the escalation or the decision is already written to the store by the time the
+     * other side is woken, so a dispatch that fails - a session that was archived, stopped or never
+     * existed - must NOT fail the request. It would: the caller would be told the whole thing
+     * failed although it succeeded, it would try again, and the same report would be written twice.
+     *
+     * So the wake is wrapped, the failure is written down, and the record is returned as the
+     * success it is.
+     *
+     * AND THE FAILURE IS NOT SILENT. A report nobody was told about is a report nobody will ever
+     * handle, so the project's own timeline gets an event saying exactly that, and the log line
+     * names the project and the escalation so the case can be found again later.
+     */
+    async wake(target, prompt, what, projectId, workspaceId, actor) {
+        if (!this.orchestrator)
+            return;
+        try {
+            await this.orchestrator.dispatch(target, prompt, { wait: false });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Super Pi: 项目 ${projectId} 的${what}已保存，但叫不醒会话 ${target}：${message}`);
+            await this.noteUnreachable(projectId, workspaceId, `${what}已保存，但转述对象会话不可达（${target}）：${message}`, actor);
+        }
+    }
+    /** THE TIMELINE SAYS THAT NOBODY COULD BE TOLD. Written after the fact, so it never loses the
+     *  record that was already saved. */
+    async noteUnreachable(projectId, workspaceId, summary, actor) {
+        if (workspaceId === undefined)
+            return;
+        try {
+            await this.change(projectId, workspaceId, (p) => { this.event(p, "unreachable", summary, undefined, actor); });
+        }
+        catch (error) {
+            console.warn(`Super Pi: 项目 ${projectId} 记录「转述对象不可达」事件失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     leader(p, actor) { if (actor && actor !== p.ownerConversationId)
         throw new Error("仅项目负责人可以执行此操作"); }
     topLevelAuthor(p, actor) {
@@ -320,6 +389,78 @@ export class ProjectService {
         if (actor && actor !== p.ownerConversationId && actor !== p.initiatorConversationId && !p.tasks.some((t) => t.ownerConversationId === actor || t.reviewerConversationId === actor))
             throw new Error("调用会话不属于项目执行团队");
     }
+    isMember(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;
+    }
+    directSupervisor(p, actor, taskId) {
+        if (!actor || actor === p.ownerConversationId || actor === p.initiatorConversationId)
+            return undefined;
+        const session = this.store.conversation(actor);
+        const parentId = session?.parentConversationId;
+        if (parentId && this.isMember(p, parentId))
+            return parentId;
+        const t = taskId
+            ? p.tasks.find((item) => item.id === taskId)
+            : p.tasks.find((item) => item.ownerConversationId === actor || item.reviewerConversationId === actor);
+        const manager = t ? this.manager(p, t) : undefined;
+        if (manager && this.isMember(p, manager))
+            return manager;
+        return undefined;
+    }
+    /**
+     * THE PROJECT A SESSION BELONGS TO RIGHT NOW.
+     *
+     * `projectForSession` answers a different question - "which project is this session part of" -
+     * and it counts the finished projects too, because the history of a project has to stay visible
+     * to the people who worked on it. This method answers the narrower question the QUESTION path
+     * needs: "is this session inside a project that is still running".
+     *
+     * WHY THAT DISTINCTION MATTERS. A conversation that took part in a project which has since been
+     * completed is not a project member any more - it is a conversation that happens to have a
+     * finished project in its history. The old lookup mixed the two, so asking the Boss a question
+     * from such a conversation was refused with "a project member may not ask the Boss directly",
+     * which is not what was true: the project was over, and nobody was being bypassed. The finished
+     * project is still found and still visible in the history; it just does not block the question.
+     *
+     * A session that is in a running project AND in a finished one belongs to the running one - it
+     * is the one that is still in charge of it.
+     */
+    liveProjectForSession(conversationId) {
+        let c = this.store.conversation(conversationId);
+        const seen = new Set();
+        while (c && !seen.has(c.id)) {
+            seen.add(c.id);
+            const projects = this.store.projects().filter((p) => p.workspaceId === c.workspaceId
+                && (p.ownerConversationId === c.id || p.tasks.some((t) => t.ownerConversationId === c.id || t.reviewerConversationId === c.id)));
+            const live = projects.find((p) => !closed(p));
+            if (live)
+                return live;
+            c = c.parentConversationId ? this.store.conversation(c.parentConversationId) : undefined;
+        }
+        return undefined;
+    }
+    canAskQuestion(conversationId) {
+        const project = this.liveProjectForSession(conversationId);
+        if (!project)
+            return { ok: true };
+        if (conversationId === project.ownerConversationId || conversationId === project.initiatorConversationId) {
+            return { ok: true };
+        }
+        return {
+            ok: false,
+            reason: "项目成员不能直接向 Boss 提问：请通过直接上级上报，由负责人代为转述",
+        };
+    }
     reconcile(p) {
         if (closed(p))
             return;
@@ -329,9 +470,15 @@ export class ProjectService {
                 t.updatedAt = stamp();
                 this.event(p, "ready", `前置交付已验收：${t.title}`, t.id);
             }
-        const open = p.escalations.filter((e) => e.status === "open");
-        p.status = open.some((e) => e.severity === "high") ? "awaiting_approval" : open.length || p.tasks.some((t) => t.status === "blocked") ? "blocked"
-            : p.tasks.some((t) => t.status === "awaiting_review") ? "awaiting_review" : p.tasks.length ? "active" : "planning";
+        const isLeader = (convId) => !convId || convId === p.ownerConversationId || convId === p.initiatorConversationId;
+        const openBoss = p.escalations.filter((e) => e.status === "open" && (e.audience === "boss" || !e.audience));
+        const hasLeaderBlockedTask = p.tasks.some((t) => t.status === "blocked" && isLeader(t.blockedReportedByConversationId));
+        const lastLeaderProjectReport = [...p.reports].reverse().find((r) => !r.taskId && isLeader(r.authorConversationId));
+        const leaderProjectBlocked = lastLeaderProjectReport?.kind === "blocked";
+        p.status = openBoss.some((e) => e.severity === "high") ? "awaiting_approval"
+            : openBoss.length || hasLeaderBlockedTask || leaderProjectBlocked ? "blocked"
+                : p.tasks.some((t) => t.status === "awaiting_review") ? "awaiting_review"
+                    : p.tasks.length ? "active" : "planning";
     }
     resources(p) {
         const state = this.store.snapshot();
@@ -374,7 +521,15 @@ export class ProjectService {
            report zero running agents. The concurrency guard is not touched by this: the in-flight task
            it counts (`reserved`) already covers the busy leader, so the cap behaves exactly as before. */
         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),
+        /* ONE ACCOUNTING PATH, AND IT IS THE SESSION TREE.
+           The number below is the sum of the member sessions' usage, and NOTHING ELSE. A one-shot call
+           (a sub-agent) used to be added here from the run records on top of that sum, which was a
+           SECOND path to the same money: the run's usage was already inside the conversation's usage
+           (the store folds it in when the run settles), so the same tokens were counted twice.
+           Now it is counted once - through the session - and a project's budget therefore includes what
+           its one-shot calls cost, which is the whole point of a budget a person can predict.
+           See `Store.accountSubagentUsage`. */
+        return { tokens: sessions.reduce((sum, s) => sum + s.tokens, 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,
             // THE PROJECT'S OWN MEMORY TREE, named once so the client does not have to infer it from
@@ -385,7 +540,7 @@ export class ProjectService {
         const scope = this.workspace(workspaceId);
         return this.store.projects().filter((p) => p.workspaceId === scope).map((p) => this.projectView(p));
     }
-    headline(p) {
+    headline(p, actor) {
         const total = p.tasks.length;
         const completed = p.tasks.filter((t) => t.status === "completed").length;
         if (p.status === "completed") {
@@ -395,9 +550,10 @@ export class ProjectService {
             return "项目已取消";
         if (p.status === "failed")
             return "项目失败";
-        const openEscalation = (p.escalations ?? []).find((e) => e.status === "open");
+        const visibleEscalations = this.filterEscalations(p.escalations ?? [], actor);
+        const openEscalation = visibleEscalations.find((e) => e.status === "open");
         if (openEscalation) {
-            return p.status === "awaiting_approval"
+            return (openEscalation.audience === "boss" || !openEscalation.audience) && p.status === "awaiting_approval"
                 ? `等待审批：${openEscalation.reason}`
                 : `项目已阻塞：${openEscalation.reason}`;
         }
@@ -424,26 +580,16 @@ export class ProjectService {
         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;
+        return this.isMember(p, actor);
     }
-    projectSummary(p) {
+    projectSummary(p, actor) {
         const resources = this.resources(p);
         return {
             id: p.id,
             name: p.title,
             status: p.status,
             mode: p.mode ?? "standard",
-            headline: this.headline(p),
+            headline: this.headline(p, actor),
             tasks: {
                 total: p.tasks.length,
                 completed: p.tasks.filter((t) => t.status === "completed").length,
@@ -455,15 +601,32 @@ export class ProjectService {
             updatedAt: p.updatedAt,
         };
     }
-    listForActor(workspaceId, actor) {
+    /**
+     * THE PROJECTS AN ACTOR IS PART OF, AND HOW MANY OF THEM THERE ARE.
+     *
+     * The list is capped, because the list is what goes into an agent's context: a workspace that
+     * has been alive for a year has hundreds of finished projects, and handing all of them over
+     * answers the question "how are my projects doing" with a wall of history. The cap is on the
+     * RECENT ones - the same order the list has always had, newest update first - so what the
+     * agent reads first is what actually changed.
+     *
+     * AND THE COUNT IS TOLD, NOT IMPLIED. `total` is how many projects the session is really
+     * related to, counted BEFORE the cut, and `returned` is how many came back. An agent that sees
+     * total 57 and returned 20 knows the workspace has more history than it was shown, and says so
+     * instead of telling the Boss the workspace only has 20 projects. A silently truncated list
+     * would be a lie the agent could not see through.
+     */
+    listForActor(workspaceId, actor, limit = PROJECT_LIST_LIMIT) {
         const scope = this.workspace(workspaceId);
-        return this.store.projects()
+        const related = 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));
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        const total = related.length;
+        const projects = related.slice(0, limit).map((p) => this.projectSummary(p, actor));
+        return { projects, total, returned: projects.length };
     }
-    get(id, workspaceId) {
-        return this.projectView(this.raw(id, workspaceId));
+    get(id, workspaceId, actor) {
+        return this.projectView(this.raw(id, workspaceId), actor);
     }
     /**
      * THE PROJECT AS A REPORT A HUMAN CAN READ.
@@ -524,7 +687,9 @@ export class ProjectService {
         lines.push(`- 预算上限：${p.budget?.maxTokens ?? DEFAULT_MAX_TOKENS} Token`);
         // THE USAGE IS REPORTED IN THE SAME BILLING-EQUIVALENT UNITS THE BUDGET IS SPENT IN, and the
         // formula is printed next to the number: a budget nobody can predict is a budget nobody trusts.
-        lines.push(`- 已用等效 Token：${this.resources(p).tokens}（口径：输入 + 输出 + 缓存写入×${CACHE_WRITE_WEIGHT} + 缓存读取×${CACHE_READ_WEIGHT}，取整）`);
+        // The sentence after the formula says what the number INCLUDES - a one-shot call (a sub-agent)
+        // is part of it, so a reader who dispatches children can see what that cost them.
+        lines.push(`- 已用等效 Token：${this.resources(p).tokens}（口径：输入 + 输出 + 缓存写入×${CACHE_WRITE_WEIGHT} + 缓存读取×${CACHE_READ_WEIGHT}，取整；含项目内的一次性调用（subagent））`);
         lines.push(`- 任务：共 ${p.tasks.length} 个，已完成 ${p.tasks.filter((t) => t.status === "completed").length} 个`);
         lines.push("", "## 交付与验收", "");
         if (!p.tasks.length)
@@ -634,7 +799,7 @@ export class ProjectService {
     }
     admission(p, checkConcurrency = true, coordinator = false) {
         this.live(p);
-        if (p.escalations.some((e) => e.status === "open" && e.severity === "high"))
+        if (p.escalations.some((e) => e.status === "open" && e.severity === "high" && (e.audience === "boss" || !e.audience)))
             throw new Error("等待 Boss 处理升级决策后才能继续派发");
         const r = this.resources(p);
         if (p.budget?.maxTokens && r.tokens >= p.budget.maxTokens)
@@ -810,15 +975,16 @@ export class ProjectService {
             t.status = "in_progress";
             t.updatedAt = stamp();
             delete t.blockedReason;
+            delete t.blockedReportedByConversationId;
             this.event(p, "dispatched", `派发执行：${t.title}`, t.id, actor);
             this.reconcile(p);
             await this.store.setProject(p);
-            const delegation = t.role === "leader" ? `你是分支 Leader，负责这项任务的拆解、委派、集成交付。用 project add_task 时必须带 parentTaskId="${t.id}"；可按必要性指定 role="leader" 或 "executor"；add_task / update_task 时可以带 executorProfile 与 reviewerProfile（支持指定 agentId、cwd、model、thinkingLevel、watchdogTimeoutSeconds），按任务性质将执行与复核委派给最合适的员工，不指定则继承项目默认。用 project dispatch / request_review 管理直属子任务，子会话结束自动回报给你，不要轮询；并发满时结束本轮等待回报。所有必需子任务独立验收后才能 submit 聚合交付，上级还会独立复核你的集成结果。最多 3 层 Leader、8 个分支 Leader；小任务不要继续拆层。` : "你是执行者，不得自行拆解子任务。";
+            const delegation = t.role === "leader" ? `你是分支 Leader，负责这项任务的拆解、委派、集成交付。用 project add_task 时必须带 parentTaskId="${t.id}"；可按必要性指定 role="leader" 或 "executor"；add_task / update_task 时可以带 executorProfile 与 reviewerProfile（支持指定 agentId、cwd、model、thinkingLevel、watchdogTimeoutSeconds），按任务性质将执行与复核委派给最合适的员工，不指定则继承项目默认。用 project dispatch / request_review 管理直属子任务，子会话结束自动回报给你，不要轮询；并发满时结束本轮等待回报。所有必需子任务独立验收后才能 submit 聚合交付，上级还会独立复核你的集成结果。最多 3 层 Leader、8 个分支 Leader；小任务不要继续拆层。你的下属的升级先到你这里；你决定是自己解决还是再向上级转述。` : "你是执行者，不得自行拆解子任务。";
             /* THE LIGHTWEIGHT TASK SAYS WHAT IS DIFFERENT, because the difference is the point: there is
                no reviewer coming back, so the evidence that the reviewer would have demanded is the only
                thing that stands behind the delivery. */
             const modeNote = lightweight(p) ? "本项目是轻量项目：你就是唯一的执行会话，不会有独立复核人回来，完成后调用 project(action=submit, …) 提交即完成，交付证据必须附上。" : "";
-            await this.orchestrator.dispatch(t.ownerConversationId, `${this.context(p)}\n${delegation}\n你负责执行任务 ${t.id}：${t.title}\n目标：${t.objective}\n交付物：${t.deliverables.join("；")}\n验收：${t.acceptanceCriteria.join("；")}\n上次复核意见与验证证据：${JSON.stringify(t.review ?? null)}\n已验收前置产物：${JSON.stringify(p.tasks.filter((d) => t.dependencies.includes(d.id)).map((d) => ({ title: d.title, output: d.output, evidenceRefs: d.evidenceRefs })))}\n你不是唯一执行者，遵守分工边界。${modeNote}完成后必须调用 project(action=submit, projectId="${p.id}", taskId="${t.id}", output="交付总结", evidenceRefs=["产物路径或验证记录"])，不能自行标记已完成。复核退回时修复后重新 submit。遇到阻塞用 report 或 escalate，保留证据、假设和未解决问题。不要自行创建其他执行会话或 task/workflow。`, { wait: false });
+            await this.orchestrator.dispatch(t.ownerConversationId, `${this.context(p)}\n${delegation}\n你负责执行任务 ${t.id}：${t.title}\n目标：${t.objective}\n交付物：${t.deliverables.join("；")}\n验收：${t.acceptanceCriteria.join("；")}\n上次复核意见与验证证据：${JSON.stringify(t.review ?? null)}\n已验收前置产物：${JSON.stringify(p.tasks.filter((d) => t.dependencies.includes(d.id)).map((d) => ({ title: d.title, output: d.output, evidenceRefs: d.evidenceRefs })))}\n你不是唯一执行者，遵守分工边界。${modeNote}完成后必须调用 project(action=submit, projectId="${p.id}", taskId="${t.id}", output="交付总结", evidenceRefs=["产物路径或验证记录"])，不能自行标记已完成。复核退回时修复后重新 submit。遇到阻塞用 report(阻塞) 或 escalate 上报给你的直接上级，不要直接找 Boss，保留证据、假设和未解决问题。不要自行创建其他执行会话或 task/workflow。`, { wait: false });
             return ProjectService.taskView(t, p);
         });
     }
@@ -938,6 +1104,12 @@ export class ProjectService {
                 if (patch.status === "ready" && actor && actor !== manager)
                     throw new Error("仅直属 Leader 可以重新派发任务");
                 t.status = patch.status;
+                if (t.status === "blocked") {
+                    t.blockedReportedByConversationId = actor;
+                }
+                else {
+                    delete t.blockedReportedByConversationId;
+                }
             }
             if (patch.executorProfile !== undefined) {
                 if (t.ownerConversationId)
@@ -1137,7 +1309,10 @@ export class ProjectService {
         return { ...raised, project };
     }
     async addReport(id, input, workspaceId, actor) {
-        return this.change(id, workspaceId, (p) => {
+        let supervisorToWake;
+        let taskForWake;
+        let memberBlockedReport = false;
+        const report = await this.change(id, workspaceId, (p) => {
             this.live(p);
             this.member(p, actor);
             if (!["progress", "blocked", "delivery", "decision_request", "review"].includes(input.kind))
@@ -1151,31 +1326,85 @@ export class ProjectService {
                 progress: text(input.progress, "汇报进展"), variance: optional(input.variance, "偏差"), nextStep: optional(input.nextStep, "下一步"), risks: strings(input.risks, "风险"),
                 decisionNeeded: optional(input.decisionNeeded, "所需决策"), evidenceRefs: strings(input.evidenceRefs, "证据"), createdAt: stamp() };
             p.reports.push(report);
-            if (report.kind === "blocked" && t) {
-                t.status = "blocked";
-                t.blockedReason = report.progress;
-                t.updatedAt = stamp();
+            if (report.kind === "blocked") {
+                if (t) {
+                    t.status = "blocked";
+                    t.blockedReason = report.progress;
+                    t.blockedReportedByConversationId = actor;
+                    t.updatedAt = stamp();
+                }
+                if (actor && actor !== p.ownerConversationId && actor !== p.initiatorConversationId) {
+                    memberBlockedReport = true;
+                    supervisorToWake = this.directSupervisor(p, actor, t?.id);
+                    taskForWake = t;
+                }
             }
             this.event(p, "report", report.progress, t?.id, actor);
             this.reconcile(p);
             return report;
-        });
+        }, actor);
+        if (supervisorToWake) {
+            const taskInfo = taskForWake ? `任务 ${taskForWake.id}（${taskForWake.title}）` : "所属任务";
+            await this.wake(supervisorToWake, `下级成员（会话：${actor}）汇报阻塞：${taskInfo}\n原因：${report.progress}\n请评估阻塞并跟进解决，必要时向 Boss 转述或升级。`, "阻塞上报", id, workspaceId, actor);
+        }
+        else if (memberBlockedReport) {
+            /* A MEMBER REPORTED A BLOCK AND NO SUPERVISOR COULD BE FOUND. The report is saved either
+             * way, but nobody has been told, so the case is written down instead of vanishing. */
+            const summary = "阻塞上报已保存，但找不到直接上级会话，上报没有被转述";
+            console.warn(`Super Pi: 项目 ${id} 的${summary}`);
+            await this.noteUnreachable(id, workspaceId, summary, actor);
+        }
+        return report;
     }
     async addEscalation(id, input, workspaceId, actor) {
-        return this.change(id, workspaceId, (p) => {
+        let supervisorToWake;
+        let wakeMemberRole;
+        const result = await this.change(id, workspaceId, (p) => {
             this.live(p);
             this.member(p, actor);
             if (!["low", "medium", "high"].includes(input.severity))
                 throw new Error("升级风险等级不合法");
-            const t = input.taskId ? this.task(p, text(input.taskId, "任务 id")) : undefined;
-            const e = { id: randomUUID(), projectId: id, taskId: t?.id, reason: text(input.reason, "升级原因"), severity: input.severity, status: "open", requestedByConversationId: actor, createdAt: stamp() };
+            const t = input.taskId
+                ? this.task(p, text(input.taskId, "任务 id"))
+                : p.tasks.find((task) => task.ownerConversationId === actor || task.reviewerConversationId === actor);
+            const isBossAudience = !actor || actor === p.ownerConversationId || actor === p.initiatorConversationId;
+            const audience = isBossAudience ? "boss" : "supervisor";
+            let targetConversationId;
+            if (!isBossAudience) {
+                targetConversationId = this.directSupervisor(p, actor, t?.id);
+                if (!targetConversationId) {
+                    throw new Error("无法确定直接上级会话：上级不在项目执行团队内且无法定位所属任务 Leader，升级已拒绝。");
+                }
+                supervisorToWake = targetConversationId;
+                wakeMemberRole = p.tasks.some((task) => task.role === "leader" && task.ownerConversationId === actor)
+                    ? "分支 Leader"
+                    : p.tasks.some((task) => task.reviewerConversationId === actor)
+                        ? "独立复核"
+                        : "执行者";
+            }
+            const e = {
+                id: randomUUID(),
+                projectId: id,
+                taskId: t?.id,
+                reason: text(input.reason, "升级原因"),
+                severity: input.severity,
+                status: "open",
+                requestedByConversationId: actor,
+                audience,
+                ...(targetConversationId ? { targetConversationId } : {}),
+                createdAt: stamp(),
+            };
             p.escalations.push(e);
             this.event(p, "escalated", e.reason, t?.id, actor);
             this.reconcile(p);
             return e;
-        });
+        }, actor);
+        if (supervisorToWake) {
+            await this.wake(supervisorToWake, `下级成员（会话：${actor}，身份：${wakeMemberRole ?? "执行者"}）发起例外升级（ID：${result.id}）：\n原因：${result.reason}\n严重级别：${result.severity}\n请及时处理该例外（调用 project action="resolve_escalation" 记录处理意见），或按需向上级转述升级。`, `例外升级（ID：${result.id}）`, id, workspaceId, actor);
+        }
+        return result;
     }
-    async resolveEscalation(id, escalationId, decision, status, workspaceId) {
+    async resolveEscalation(id, escalationId, decision, status, workspaceId, actor) {
         const result = await this.change(id, workspaceId, (p) => {
             this.live(p);
             if (status !== "resolved" && status !== "dismissed")
@@ -1185,33 +1414,54 @@ export class ProjectService {
                 throw new Error("升级事项不存在");
             if (e.status !== "open")
                 throw new Error("升级事项已处理");
+            const audience = e.audience ?? "boss";
+            if (audience === "boss") {
+                if (actor)
+                    throw new Error("此例外需由 Boss 决策，团队成员无权处理");
+            }
+            else if (audience === "supervisor") {
+                if (!actor)
+                    throw new Error("该例外属于直接上级处理范围，Boss 不能直接处理 supervisor 级别的例外");
+                if (actor !== e.targetConversationId)
+                    throw new Error("只有指定的直接上级可以处理此例外");
+                e.resolvedByConversationId = actor;
+            }
             e.status = status;
             e.decision = text(decision, "处理意见");
             e.resolvedAt = stamp();
-            this.event(p, "decision", `Boss 决策：${e.decision}`, e.taskId);
+            const decider = audience === "boss" ? "Boss" : "直接上级";
+            this.event(p, "decision", `${decider}决策：${e.decision}`, e.taskId, actor);
             this.reconcile(p);
             return e;
-        });
-        const p = this.get(id, workspaceId);
-        const targetTask = result.taskId
-            ? p.tasks.find((t) => t.id === result.taskId)
-            : p.tasks.find((t) => t.ownerConversationId === result.requestedByConversationId || t.reviewerConversationId === result.requestedByConversationId);
-        let directLeaderId;
-        if (targetTask) {
-            if (targetTask.role === "leader" && targetTask.ownerConversationId) {
-                directLeaderId = targetTask.ownerConversationId;
+        }, actor);
+        const p = this.raw(id, workspaceId);
+        if (result.audience === "supervisor") {
+            if (result.requestedByConversationId) {
+                await this.wake(result.requestedByConversationId, `直接上级已处理例外（ID：${result.id}）：${result.reason}\n处理意见：${result.decision}\n请按处理意见继续工作。`, `例外处理结果（ID：${result.id}）`, id, workspaceId, actor);
             }
-            else if (targetTask.parentTaskId) {
-                const parent = p.tasks.find((t) => t.id === targetTask.parentTaskId);
-                directLeaderId = parent?.ownerConversationId ?? targetTask.accountableConversationId;
+        }
+        else {
+            const targetTask = result.taskId
+                ? p.tasks.find((t) => t.id === result.taskId)
+                : p.tasks.find((t) => t.ownerConversationId === result.requestedByConversationId || t.reviewerConversationId === result.requestedByConversationId);
+            let directLeaderId;
+            if (targetTask) {
+                if (targetTask.role === "leader" && targetTask.ownerConversationId) {
+                    directLeaderId = targetTask.ownerConversationId;
+                }
+                else if (targetTask.parentTaskId) {
+                    const parent = p.tasks.find((t) => t.id === targetTask.parentTaskId);
+                    directLeaderId = parent?.ownerConversationId ?? targetTask.accountableConversationId;
+                }
+                else {
+                    directLeaderId = targetTask.accountableConversationId ?? p.ownerConversationId;
+                }
             }
-            else {
-                directLeaderId = targetTask.accountableConversationId ?? p.ownerConversationId;
+            const recipientId = directLeaderId || p.ownerConversationId;
+            if (recipientId) {
+                await this.wake(recipientId, `Boss 已处理项目 ${p.id} 的例外：${result.reason}\n决策：${result.decision}\n先读取 project 最新状态，按决策继续范围内的工作。`, `例外处理结果（ID：${result.id}）`, id, workspaceId, actor);
             }
         }
-        const recipientId = directLeaderId || p.ownerConversationId;
-        if (recipientId && this.orchestrator)
-            await this.orchestrator.dispatch(recipientId, `Boss 已处理项目 ${p.id} 的例外：${result.reason}\n决策：${result.decision}\n先读取 project 最新状态，按决策继续范围内的工作。`, { wait: false });
         return result;
     }
     async complete(id, summary, evidenceRefs, workspaceId, actor) {
@@ -1337,13 +1587,16 @@ export class ProjectService {
             return this.get(project.id, workspaceId);
         }
         if (body.action === "list") {
+            // THE LIST IS CAPPED, AND IT SAYS SO. `total` and `returned` travel with it, so an agent
+            // that sees a short list can tell the difference between "the workspace has three projects"
+            // and "the workspace has fifty and I was shown twenty".
             return this.listForActor(workspaceId, actor);
         }
         const id = text(body.projectId, "projectId");
-        const p = this.get(id, workspaceId);
-        this.member(p, actor);
+        const rawProject = this.raw(id, workspaceId);
+        this.member(rawProject, actor);
         switch (body.action) {
-            case "get": return p;
+            case "get": return this.get(id, workspaceId, actor);
             case "export": return this.exportReport(id, workspaceId);
             case "start": return this.start(id, workspaceId, actor);
             case "add_task": return this.addTask(id, body, workspaceId, actor);
@@ -1354,6 +1607,9 @@ export class ProjectService {
             case "update_task": return this.updateTask(id, text(body.taskId, "taskId"), { ...body, workspaceId }, actor);
             case "report": return this.addReport(id, body, workspaceId, actor);
             case "escalate": return this.addEscalation(id, body, workspaceId, actor);
+            case "resolve_escalation":
+            case "resolveEscalation":
+                return this.resolveEscalation(id, text(body.escalationId, "escalationId"), text(body.decision, "decision"), body.status ?? "resolved", workspaceId, actor);
             case "complete": return this.complete(id, body.summary, body.evidenceRefs, workspaceId, actor);
             case "cancel": return this.cancel(id, body, workspaceId, actor);
             default: throw new Error("未知的项目工具操作");

package/dist/server/http-server.js

@@ -2099,6 +2099,13 @@ export function createHttpServer(options) {
                         response.writeHead(403, { "content-type": "application/json" }).end(JSON.stringify({ error: verdict.message }));
                         return;
                     }
+                    if (context.projectService) {
+                        const check = context.projectService.canAskQuestion(body.conversationId);
+                        if (!check.ok) {
+                            response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: check.reason }));
+                            return;
+                        }
+                    }
                     const result = await runService.askQuestion(body.conversationId);
                     response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
                 }