@evandu/super-pi 0.1.153 → 0.1.154

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

@@ -0,0 +1,573 @@
+import { randomUUID } from "node:crypto";
+const stamp = () => new Date().toISOString();
+const text = (value, label) => {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${label} 不能为空`);
+    if (value.length > 32_000)
+        throw new Error(`${label} 过长`);
+    return value.trim();
+};
+const optional = (value, label) => value === undefined ? undefined : text(value, label);
+const strings = (value, label) => {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 100)
+        throw new Error(`${label} 必须是最多 100 项的字符串数组`);
+    return [...new Set(value.map((item) => text(item, label)))];
+};
+const closed = (p) => ["completed", "cancelled", "failed"].includes(p.status);
+const busy = (status) => ["running", "waiting", "awaiting_background"].includes(status ?? "");
+const dependenciesComplete = (p, t) => t.dependencies.every((id) => p.tasks.find((candidate) => candidate.id === id)?.status === "completed");
+const tokens = (usage) => usage ? usage.input + usage.output + usage.cacheRead + usage.cacheWrite : 0;
+/** Persist explicit domain fields only; transport credentials never enter project records. */
+export class ProjectService {
+    store;
+    orchestrator;
+    queues = new Map();
+    constructor(store, orchestrator) {
+        this.store = store;
+        this.orchestrator = orchestrator;
+    }
+    workspace(workspaceId) {
+        const value = text(workspaceId, "workspaceId");
+        if (!this.store.workspace(value))
+            throw new Error("工作区不存在");
+        return value;
+    }
+    event(p, kind, summary, taskId, actorConversationId) {
+        p.updatedAt = stamp();
+        (p.events ??= []).push({ id: randomUUID(), kind, summary, taskId, actorConversationId, createdAt: p.updatedAt });
+    }
+    async change(id, workspaceId, work) {
+        this.workspace(workspaceId);
+        const previous = this.queues.get(id) ?? Promise.resolve();
+        const pending = previous.catch(() => { }).then(async () => {
+            const p = this.get(id, workspaceId);
+            delete p.resources;
+            const result = await work(p);
+            await this.store.setProject(p);
+            return structuredClone(result);
+        });
+        this.queues.set(id, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (this.queues.get(id) === pending)
+                this.queues.delete(id);
+        }
+    }
+    live(p) { if (closed(p))
+        throw new Error("项目已结束，不能继续修改或派发"); }
+    leader(p, actor) { if (actor && actor !== p.ownerConversationId)
+        throw new Error("仅项目负责人可以执行此操作"); }
+    manager(p, t, actor) {
+        const manager = t.parentTaskId ? this.task(p, t.parentTaskId).ownerConversationId : p.ownerConversationId;
+        if (actor && actor !== manager)
+            throw new Error("仅直属 Leader 可以管理此任务");
+        return manager;
+    }
+    requiredComplete(p, parentTaskId) {
+        const required = p.tasks.filter((t) => t.parentTaskId === parentTaskId && (t.status !== "cancelled" || !t.blockedReason));
+        return required.length > 0 && required.every((t) => t.status === "completed" && t.review?.verdict === "accepted" && t.review.reviewerConversationId === t.reviewerConversationId && Boolean(t.reviewerConversationId) && t.reviewerConversationId !== t.ownerConversationId);
+    }
+    task(p, taskId) {
+        const t = p.tasks.find((item) => item.id === taskId);
+        if (!t)
+            throw new Error("任务不存在");
+        return t;
+    }
+    member(p, actor) {
+        if (actor && actor !== p.ownerConversationId && !p.tasks.some((t) => t.ownerConversationId === actor || t.reviewerConversationId === actor))
+            throw new Error("调用会话不属于项目执行团队");
+    }
+    reconcile(p) {
+        if (closed(p))
+            return;
+        for (const t of p.tasks)
+            if (t.status === "pending" && dependenciesComplete(p, t)) {
+                t.status = "ready";
+                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";
+    }
+    resources(p) {
+        const state = this.store.snapshot();
+        const members = new Set([p.ownerConversationId, ...p.tasks.flatMap((t) => [t.ownerConversationId, t.reviewerConversationId])].filter(Boolean));
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const c of state.conversations)
+                if (c.workspaceId === p.workspaceId && c.parentConversationId && members.has(c.parentConversationId) && !members.has(c.id)) {
+                    members.add(c.id);
+                    changed = true;
+                }
+        }
+        const coordinatorIds = new Set([p.ownerConversationId, ...p.tasks.filter((t) => t.role === "leader").map((t) => t.ownerConversationId)].filter(Boolean));
+        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,
+            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));
+        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) && busy(s.status)).length + runs.filter((r) => r.status === "running").length, sessions };
+    }
+    list(workspaceId) {
+        const scope = this.workspace(workspaceId);
+        return this.store.projects().filter((p) => p.workspaceId === scope).map((p) => ({ ...p, resources: this.resources(p) }));
+    }
+    get(id, workspaceId) {
+        const scope = this.workspace(workspaceId);
+        const p = this.store.project(id);
+        if (!p || p.workspaceId !== scope)
+            throw new Error("项目不存在或不属于当前工作区");
+        return { ...p, resources: this.resources(p) };
+    }
+    projectForSession(conversationId) {
+        let c = this.store.conversation(conversationId);
+        const seen = new Set();
+        while (c && !seen.has(c.id)) {
+            seen.add(c.id);
+            const p = this.store.projects().find((p) => p.workspaceId === c.workspaceId && (p.ownerConversationId === c.id || p.tasks.some((t) => t.ownerConversationId === c.id || t.reviewerConversationId === c.id)));
+            if (p)
+                return p;
+            c = c.parentConversationId ? this.store.conversation(c.parentConversationId) : undefined;
+        }
+        return undefined;
+    }
+    async create(input) {
+        const workspaceId = this.workspace(input.workspaceId);
+        if (input.ownerConversationId !== undefined)
+            throw new Error("项目负责人由启动操作创建独立会话");
+        if (input.risk !== undefined && !["low", "medium", "high"].includes(input.risk))
+            throw new Error("项目风险等级不合法");
+        if (input.budget !== undefined && (!input.budget || typeof input.budget !== "object" || Array.isArray(input.budget)))
+            throw new Error("资源预算不合法");
+        for (const [key, value] of Object.entries(input.budget ?? {}))
+            if (!["maxTokens", "maxConcurrent"].includes(key) || !Number.isSafeInteger(value) || value <= 0)
+                throw new Error("资源预算必须是正整数");
+        const now = stamp();
+        const p = { id: `project_${randomUUID()}`, workspaceId, title: text(input.title, "项目标题"), objective: text(input.objective, "项目目标"),
+            deliverables: strings(input.deliverables, "交付物"), acceptanceCriteria: strings(input.acceptanceCriteria, "验收标准"), constraints: strings(input.constraints, "约束"),
+            risk: input.risk ?? "low", status: "planning", budget: { maxTokens: input.budget?.maxTokens ?? 100_000, maxConcurrent: input.budget?.maxConcurrent ?? 2 },
+            tasks: [], reports: [], escalations: [], events: [], createdAt: now, updatedAt: now };
+        this.event(p, "created", "Boss 触发项目");
+        return this.store.setProject(p);
+    }
+    admission(p, checkConcurrency = true, coordinator = false) {
+        this.live(p);
+        if (p.escalations.some((e) => e.status === "open" && e.severity === "high"))
+            throw new Error("等待 Boss 处理升级决策后才能继续派发");
+        const r = this.resources(p);
+        if (p.budget?.maxTokens && r.tokens >= p.budget.maxTokens)
+            throw new Error("已达到已报告 Token 预算，拒绝继续派发");
+        const reserved = p.tasks.filter((t) => {
+            if (t.status === "in_progress" && t.role === "leader")
+                return false;
+            const sessionId = t.status === "in_progress" ? t.ownerConversationId : t.status === "awaiting_review" ? t.reviewerConversationId : undefined;
+            const state = sessionId ? this.store.conversation(sessionId)?.status : undefined;
+            if (busy(state))
+                return true;
+            if (state !== "idle")
+                return false;
+            const last = p.events?.filter((e) => e.taskId === t.id && (e.kind === "dispatched" || e.kind === "review_requested")).at(-1);
+            return Boolean(last && Date.now() - Date.parse(last.createdAt) < 5000);
+        }).length;
+        if (checkConcurrency && !coordinator && p.budget?.maxConcurrent && Math.max(r.activeWorkers, reserved) >= p.budget.maxConcurrent)
+            throw new Error("项目执行并发已满，等待任务交付后重试");
+    }
+    context(p) {
+        return `项目 ${p.id}：${p.title}\n目标：${p.objective}\n交付物：${p.deliverables.join("；")}\n验收标准：${p.acceptanceCriteria.join("；")}\n约束：${p.constraints.join("；")}\n预算：${JSON.stringify(p.budget)}。预算是派发准入限制，运行中请求可能超额。`;
+    }
+    async start(id, workspaceId, actor) {
+        return this.change(id, workspaceId, async (p) => {
+            this.leader(p, actor);
+            this.admission(p, false);
+            if (!this.orchestrator)
+                throw new Error("会话编排服务未就绪");
+            if (p.ownerConversationId && busy(this.store.conversation(p.ownerConversationId)?.status))
+                throw new Error("项目负责人正在执行，请勿重复启动");
+            if (!p.ownerConversationId)
+                p.ownerConversationId = (await this.orchestrator.spawn({ workspaceId, title: `项目负责人 · ${p.title}`, task: p.objective, initialPrompt: "" })).conversationId;
+            this.event(p, "started", "项目负责人开始组织执行", undefined, actor);
+            p.status = "active";
+            await this.store.setProject(p);
+            await this.orchestrator.dispatch(p.ownerConversationId, `${this.context(p)}\n你是直接向 Boss 负责的项目 Leader，兼任秘书。先调用 project(action=get, projectId) 了解最新状态。小项目只拆最少必要任务，大项目按交付边界分工。用 add_task 登记任务（明确目标、交付物、验收标准、依赖）；需要继续拆解的工作设 role=leader，叶子执行任务设 role=executor，子 Leader 用 parentTaskId 登记自己的子任务，dispatch 启动执行子会话；不要用 session_spawn/session_dispatch 或 task/workflow 绕过项目资源限制。收到交付后用 request_review 启动独立复核。子会话结束会自动回报给你，届时继续派发 ready 任务、复核待验收任务或按 review.summary 返工。不要轮询等待，不要反复无进展重试，并发满时结束当前回复等待回报。用 report 登记关键进展，用 escalate 将重大偏差、权限或预算问题交给 Boss，不得自行解决升级事项。所有任务验收后，用 complete 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。`, { wait: false });
+            return p;
+        });
+    }
+    async addTask(id, input, workspaceId, actor) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            const parentTaskId = optional(input.parentTaskId, "父任务 id");
+            let manager = p.ownerConversationId;
+            if (parentTaskId) {
+                const parent = this.task(p, parentTaskId);
+                if (parent.role !== "leader" || parent.status !== "in_progress" || !parent.ownerConversationId)
+                    throw new Error("父任务必须是执行中的 Leader 任务");
+                if (actor && actor !== parent.ownerConversationId)
+                    throw new Error("仅父任务 Leader 可以拆解子任务");
+                manager = parent.ownerConversationId;
+                let depth = 1;
+                let ancestor = parent;
+                while (ancestor?.parentTaskId) {
+                    depth++;
+                    ancestor = this.task(p, ancestor.parentTaskId);
+                }
+                if (depth >= 3 && input.role === "leader")
+                    throw new Error("Leader 最多 3 层，请改为执行任务");
+            }
+            else
+                this.leader(p, actor);
+            if (input.role !== undefined && input.role !== "leader" && input.role !== "executor")
+                throw new Error("任务角色必须是 leader 或 executor");
+            const dependencies = strings(input.dependencies, "任务依赖");
+            for (const dependency of dependencies)
+                if (!p.tasks.some((t) => t.id === dependency))
+                    throw new Error(`任务依赖不存在：${dependency}`);
+            for (const dependency of dependencies)
+                if (this.task(p, dependency).parentTaskId !== parentTaskId)
+                    throw new Error("任务依赖只能指向同级任务，避免层级死锁");
+            if (input.status !== undefined && input.status !== "pending" && input.status !== "ready")
+                throw new Error("新任务必须从待派发或等待依赖开始");
+            if (input.ownerConversationId || input.reviewerConversationId)
+                throw new Error("执行和复核会话由派发操作创建");
+            if (input.priority !== undefined && !["low", "medium", "high", "urgent"].includes(input.priority))
+                throw new Error("任务优先级不合法");
+            if (p.tasks.length >= 100)
+                throw new Error("项目最多 100 个任务，请收敛分工范围");
+            const now = stamp();
+            const t = { id: `task_${randomUUID()}`, projectId: id, title: text(input.title, "任务标题"), objective: text(input.objective, "任务目标"),
+                status: dependencies.length ? "pending" : "ready", accountableConversationId: manager, parentTaskId, role: input.role ?? "executor", dependencies,
+                deliverables: strings(input.deliverables, "任务交付物"), acceptanceCriteria: strings(input.acceptanceCriteria, "任务验收标准"), priority: input.priority ?? "medium",
+                dueAt: optional(input.dueAt, "截止时间"), createdAt: now, updatedAt: now };
+            p.tasks.push(t);
+            this.reconcile(p);
+            this.event(p, "task_created", `登记任务：${t.title}`, t.id, actor);
+            return t;
+        });
+    }
+    async dispatchTask(id, taskId, workspaceId, actor) {
+        return this.change(id, workspaceId, async (p) => {
+            const t = this.task(p, taskId);
+            const manager = this.manager(p, t, actor);
+            if (!dependenciesComplete(p, t))
+                throw new Error("任务的前置依赖尚未全部完成，不能开始执行");
+            if (t.status !== "ready")
+                throw new Error("仅待派发任务可以启动");
+            this.admission(p, true, t.role === "leader");
+            if (t.role === "leader" && !t.ownerConversationId && p.tasks.filter((t) => t.role === "leader" && t.ownerConversationId).length >= 8)
+                throw new Error("分支 Leader 最多 8 个，请收敛组织层级");
+            if (!this.orchestrator || !p.ownerConversationId)
+                throw new Error("请先启动项目负责人");
+            if (t.parentTaskId && this.task(p, t.parentTaskId).status !== "in_progress")
+                throw new Error("父任务未处于执行中");
+            if (!t.ownerConversationId)
+                t.ownerConversationId = (await this.orchestrator.spawn({ workspaceId, parentConversationId: manager, title: `${t.role === "leader" ? "Leader" : "执行"} · ${t.title}`, task: t.objective, initialPrompt: "" })).conversationId;
+            if (busy(this.store.conversation(t.ownerConversationId)?.status))
+                throw new Error("执行会话尚未结束，请等待完成回报后派发");
+            t.status = "in_progress";
+            t.updatedAt = stamp();
+            delete t.blockedReason;
+            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"。用 project dispatch / request_review 管理直属子任务，子会话结束自动回报给你，不要轮询；并发满时结束本轮等待回报。所有必需子任务独立验收后才能 submit 聚合交付，上级还会独立复核你的集成结果。最多 3 层 Leader、8 个分支 Leader；小任务不要继续拆层。` : "你是执行者，不得自行拆解子任务。";
+            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你不是唯一执行者，遵守分工边界。完成后必须调用 project(action=submit, projectId="${p.id}", taskId="${t.id}", output="交付总结", evidenceRefs=["产物路径或验证记录"])，不能自行标记已完成。复核退回时修复后重新 submit。遇到阻塞用 report 或 escalate，保留证据、假设和未解决问题。不要自行创建其他执行会话或 task/workflow。`, { wait: false });
+            return t;
+        });
+    }
+    async submit(id, taskId, input, workspaceId, actor) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            const t = this.task(p, taskId);
+            if (actor && actor !== t.ownerConversationId)
+                throw new Error("仅任务执行者可以提交交付");
+            if (t.status !== "in_progress")
+                throw new Error("仅执行中的任务可以提交交付");
+            if (t.role === "leader" && !this.requiredComplete(p, t.id))
+                throw new Error("Leader 的必需子任务尚未全部独立验收");
+            t.output = text(input.output, "交付结果");
+            t.evidenceRefs = strings(input.evidenceRefs, "交付证据");
+            if (!t.evidenceRefs.length)
+                throw new Error("交付必须附上产物或验证证据");
+            t.status = "awaiting_review";
+            t.updatedAt = stamp();
+            delete t.review;
+            this.event(p, "submitted", `交付待独立复核：${t.title}`, t.id, actor);
+            this.reconcile(p);
+            return t;
+        });
+    }
+    async requestReview(id, taskId, workspaceId, actor) {
+        return this.change(id, workspaceId, async (p) => {
+            this.admission(p);
+            const t = this.task(p, taskId);
+            const manager = this.manager(p, t, actor);
+            if (t.status !== "awaiting_review")
+                throw new Error("任务尚未提交交付");
+            if (!this.orchestrator || !p.ownerConversationId)
+                throw new Error("请先启动项目负责人");
+            if (!t.reviewerConversationId)
+                t.reviewerConversationId = (await this.orchestrator.spawn({ workspaceId, parentConversationId: manager, title: `复核 · ${t.title}`, task: `独立复核 ${t.title}`, initialPrompt: "" })).conversationId;
+            if (busy(this.store.conversation(t.reviewerConversationId)?.status))
+                throw new Error("复核会话正在执行");
+            this.event(p, "review_requested", `启动独立复核：${t.title}`, t.id, actor);
+            await this.store.setProject(p);
+            await this.orchestrator.dispatch(t.reviewerConversationId, `${this.context(p)}\n你是独立复核人，只读检查，不修改执行者产物。任务 ${t.id}：${t.title}\n目标：${t.objective}\n验收标准：${t.acceptanceCriteria.join("；")}\n交付：${t.output}\n证据：${JSON.stringify(t.evidenceRefs)}\n主动寻找反例，核对真实产物、测试与证据，不能只复述作者结论。调用 project(action=review, projectId="${p.id}", taskId="${t.id}", verdict="accepted" 或 "changes_requested", summary="验收理由或具体返工项", evidenceRefs=["独立验证记录"])。完成后结束本轮，由上级安排后续。不创建额外会话。`, { wait: false });
+            return t;
+        });
+    }
+    async review(id, taskId, input, workspaceId, actor) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            const t = this.task(p, taskId);
+            if (!actor || actor !== t.reviewerConversationId || actor === t.ownerConversationId)
+                throw new Error("仅指定的独立复核人可以验收，禁止自审");
+            if (t.status !== "awaiting_review")
+                throw new Error("任务不处于待复核状态");
+            if (input.verdict !== "accepted" && input.verdict !== "changes_requested")
+                throw new Error("复核结论不合法");
+            const evidenceRefs = strings(input.evidenceRefs, "复核证据");
+            if (!evidenceRefs.length)
+                throw new Error("复核必须附独立验证证据");
+            t.review = { verdict: input.verdict, summary: text(input.summary, "复核意见"), evidenceRefs, reviewerConversationId: actor, createdAt: stamp() };
+            t.status = input.verdict === "accepted" ? "completed" : "ready";
+            t.updatedAt = stamp();
+            this.event(p, "reviewed", `${input.verdict === "accepted" ? "验收通过" : "退回返工"}：${t.title}；${t.review.summary}`, t.id, actor);
+            this.reconcile(p);
+            return t;
+        });
+    }
+    async updateTask(id, taskId, patch, actor) {
+        const result = await this.change(id, patch.workspaceId, (p) => {
+            this.live(p);
+            const t = this.task(p, taskId);
+            this.member(p, actor);
+            const manager = this.manager(p, t);
+            if (actor && actor !== manager && actor !== t.ownerConversationId)
+                throw new Error("无权更新此任务");
+            if (patch.status !== undefined) {
+                if (patch.status === "in_progress" && !dependenciesComplete(p, t))
+                    throw new Error("任务的前置依赖尚未全部完成，不能开始执行");
+                if (!["blocked", "failed", "cancelled", "ready"].includes(String(patch.status)))
+                    throw new Error("请使用派发、交付或独立复核操作流转任务");
+                if (t.status === "completed" || t.status === "cancelled")
+                    throw new Error("任务已结束");
+                if (patch.status === "ready" && !dependenciesComplete(p, t))
+                    throw new Error("前置依赖尚未完成");
+                if (patch.status === "cancelled" && actor)
+                    throw new Error("取消交付范围必须由 Boss 决策");
+                if (patch.status === "cancelled" && !patch.blockedReason)
+                    throw new Error("取消任务必须记录 Boss 的范围变更理由");
+                if (patch.status === "ready" && actor && actor !== manager)
+                    throw new Error("仅直属 Leader 可以重新派发任务");
+                t.status = patch.status;
+            }
+            if (patch.blockedReason !== undefined)
+                t.blockedReason = text(patch.blockedReason, "阻塞原因");
+            if (t.status === "blocked" && !t.blockedReason)
+                throw new Error("阻塞任务必须说明原因");
+            if (patch.dueAt !== undefined)
+                t.dueAt = text(patch.dueAt, "截止时间");
+            if (patch.output !== undefined)
+                t.output = text(patch.output, "任务产出");
+            if (patch.evidenceRefs !== undefined)
+                t.evidenceRefs = strings(patch.evidenceRefs, "交付证据");
+            if (patch.review !== undefined && !actor) {
+                const rev = patch.review;
+                if (rev === null) {
+                    delete t.review;
+                }
+                else if (typeof rev === "object") {
+                    t.review = {
+                        verdict: rev.verdict === "accepted" ? "accepted" : "changes_requested",
+                        summary: text(rev.summary, "复核意见"),
+                        evidenceRefs: strings(rev.evidenceRefs ?? ["verify.md"], "复核证据"),
+                        reviewerConversationId: typeof rev.reviewerConversationId === "string" ? rev.reviewerConversationId : (p.ownerConversationId ?? "boss"),
+                        createdAt: stamp(),
+                    };
+                }
+            }
+            if (patch.status === "cancelled") {
+                const descendants = new Set([t.id]);
+                for (let changed = true; changed;) {
+                    changed = false;
+                    for (const child of p.tasks)
+                        if (child.parentTaskId && descendants.has(child.parentTaskId) && !descendants.has(child.id)) {
+                            descendants.add(child.id);
+                            changed = true;
+                        }
+                }
+                for (const child of p.tasks)
+                    if (child.id !== t.id && descendants.has(child.id) && child.status !== "completed") {
+                        child.status = "cancelled";
+                        child.blockedReason = t.blockedReason;
+                        child.updatedAt = stamp();
+                        this.event(p, "task_updated", `范围变更取消子任务：${child.title}`, child.id);
+                    }
+            }
+            t.updatedAt = stamp();
+            this.event(p, "task_updated", `${t.title}：${t.status}`, t.id, actor);
+            this.reconcile(p);
+            return t;
+        });
+        if (patch.status === "cancelled") {
+            if (result.ownerConversationId)
+                await this.orchestrator?.stopSubtree?.(result.ownerConversationId);
+            if (result.reviewerConversationId)
+                await this.orchestrator?.stopSubtree?.(result.reviewerConversationId);
+        }
+        return result;
+    }
+    async updateStatus(id, status, workspaceId) {
+        const result = await this.change(id, workspaceId, (p) => {
+            this.live(p);
+            if (!["active", "cancelled", "failed"].includes(status))
+                throw new Error("项目完成必须提交最终交付，其他状态由任务和例外推导");
+            if (status === "active" && p.escalations.some((e) => e.status === "open"))
+                throw new Error("请先处理未解决的例外");
+            p.status = status;
+            if (closed(p))
+                p.closedAt = stamp();
+            this.event(p, "status", `项目状态：${status}`);
+            return p;
+        });
+        // Stop after releasing the write lock: an interrupted tool may itself be waiting for it.
+        if ((status === "cancelled" || status === "failed") && result.ownerConversationId)
+            await this.orchestrator?.stopSubtree?.(result.ownerConversationId);
+        return result;
+    }
+    async updateBudget(id, input, workspaceId) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            for (const key of ["maxTokens", "maxConcurrent"])
+                if (input[key] !== undefined) {
+                    if (!Number.isSafeInteger(input[key]) || input[key] <= 0)
+                        throw new Error("资源预算必须是正整数");
+                    (p.budget ??= {})[key] = input[key];
+                }
+            this.event(p, "budget", `Boss 调整派发预算：${p.budget?.maxTokens} Token，并发 ${p.budget?.maxConcurrent}`);
+            return p;
+        });
+    }
+    async addReport(id, input, workspaceId, actor) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            this.member(p, actor);
+            if (!["progress", "blocked", "delivery", "decision_request", "review"].includes(input.kind))
+                throw new Error("汇报类型不合法");
+            const t = input.taskId ? this.task(p, text(input.taskId, "任务 id")) : undefined;
+            if (t && ["completed", "cancelled"].includes(t.status) && input.kind === "blocked")
+                throw new Error("已结束的任务不能标记阻塞");
+            if (actor && actor !== p.ownerConversationId && (!t || ![t.ownerConversationId, t.reviewerConversationId, this.manager(p, t)].includes(actor)))
+                throw new Error("仅可汇报本人负责的任务");
+            const report = { id: randomUUID(), projectId: id, taskId: t?.id, authorConversationId: actor, kind: input.kind,
+                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();
+            }
+            this.event(p, "report", report.progress, t?.id, actor);
+            this.reconcile(p);
+            return report;
+        });
+    }
+    async addEscalation(id, input, workspaceId, actor) {
+        return 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() };
+            p.escalations.push(e);
+            this.event(p, "escalated", e.reason, t?.id, actor);
+            this.reconcile(p);
+            return e;
+        });
+    }
+    async resolveEscalation(id, escalationId, decision, status, workspaceId) {
+        const result = await this.change(id, workspaceId, (p) => {
+            this.live(p);
+            if (status !== "resolved" && status !== "dismissed")
+                throw new Error("升级处理状态不合法");
+            const e = p.escalations.find((e) => e.id === escalationId);
+            if (!e)
+                throw new Error("升级事项不存在");
+            if (e.status !== "open")
+                throw new Error("升级事项已处理");
+            e.status = status;
+            e.decision = text(decision, "处理意见");
+            e.resolvedAt = stamp();
+            this.event(p, "decision", `Boss 决策：${e.decision}`, e.taskId);
+            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;
+            }
+            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;
+            }
+        }
+        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) {
+        return this.change(id, workspaceId, (p) => {
+            this.live(p);
+            this.leader(p, actor);
+            const required = p.tasks.filter((t) => t.status !== "cancelled" || !t.blockedReason);
+            if (!required.length || required.some((t) => t.status !== "completed" || t.review?.verdict !== "accepted" || !t.review.reviewerConversationId || t.review.reviewerConversationId !== t.reviewerConversationId || t.review.reviewerConversationId === t.ownerConversationId))
+                throw new Error("所有任务必须经独立复核验收后才能完成项目");
+            if (p.escalations.some((e) => e.status === "open"))
+                throw new Error("尚有未处理例外");
+            const evidence = strings(evidenceRefs, "最终交付证据");
+            if (!evidence.length)
+                throw new Error("最终交付必须附证据");
+            const progress = text(summary, "最终交付总结");
+            p.reports.push({ id: randomUUID(), projectId: id, kind: "delivery", progress, evidenceRefs: evidence, authorConversationId: actor, createdAt: stamp() });
+            p.status = "completed";
+            p.closedAt = stamp();
+            this.event(p, "completed", progress, undefined, actor);
+            return p;
+        });
+    }
+    async tool(body, workspaceId, actor) {
+        const id = text(body.projectId, "projectId");
+        const p = this.get(id, workspaceId);
+        this.member(p, actor);
+        switch (body.action) {
+            case "get": return p;
+            case "add_task": return this.addTask(id, body, workspaceId, actor);
+            case "dispatch": return this.dispatchTask(id, text(body.taskId, "taskId"), workspaceId, actor);
+            case "submit": return this.submit(id, text(body.taskId, "taskId"), body, workspaceId, actor);
+            case "request_review": return this.requestReview(id, text(body.taskId, "taskId"), workspaceId, actor);
+            case "review": return this.review(id, text(body.taskId, "taskId"), body, workspaceId, actor);
+            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 "complete": return this.complete(id, body.summary, body.evidenceRefs, workspaceId, actor);
+            default: throw new Error("未知的项目工具操作");
+        }
+    }
+}