@evandu/super-pi 0.1.160 → 0.1.162

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

@@ -1,5 +1,16 @@
 import { randomUUID } from "node:crypto";
 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.
+ */
+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 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。";
 const text = (value, label) => {
     if (typeof value !== "string" || !value.trim())
         throw new Error(`${label} 不能为空`);
@@ -100,7 +111,60 @@ export const mergeProfile = (taskProfile, projectDefault) => {
 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;
+// THE BUDGET IS COUNTED IN BILLING-EQUIVALENT TOKENS, NOT RAW TOKENS. A cache read costs a
+// fraction of a fresh input token (0.1x on every provider we know), and a cache write costs a
+// little more than one (1.25x). Counting them at 1:1 inflates an agent run by an order of
+// magnitude, so a budget written by intuition always blows up. The formula is:
+//   input + output + cacheWrite * 1.25 + cacheRead * 0.1
+// and it is shown to the reader, because a budget nobody can predict is a budget nobody trusts.
+const CACHE_READ_WEIGHT = 0.1;
+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;
+// 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 = {
+    planning: "草稿", active: "进行中", blocked: "已阻塞", awaiting_approval: "等待审批",
+    awaiting_review: "等待复核", completed: "已完成", cancelled: "已取消", failed: "失败",
+};
+const TASK_STATUS_TEXT = {
+    pending: "等待依赖", ready: "待派发", in_progress: "执行中", blocked: "已阻塞",
+    awaiting_review: "待复核", completed: "已完成", failed: "失败", cancelled: "已取消",
+};
+const EVENT_TEXT = {
+    created: "创建项目", started: "启动执行", task_created: "登记任务", dispatched: "派发执行",
+    submitted: "提交交付", reviewed: "复核", review_requested: "启动复核", task_updated: "任务更新", status: "状态变更",
+    budget: "预算变更", report: "进展汇报", escalated: "例外升级", decision: "决定",
+    completed: "项目完成", ready: "依赖就绪",
+};
+const ESCALATION_STATUS_TEXT = { open: "未决", resolved: "已解决", dismissed: "已忽略" };
+const SEVERITY_TEXT = { low: "低", medium: "中", high: "高" };
+const REPORT_KIND_TEXT = {
+    progress: "进展", blocked: "阻塞", delivery: "交付", decision_request: "决策请求", review: "复核",
+};
+/** ONE LINE, ONE MEANING: a value that carries newlines must not break the layout of the report. */
+const oneLine = (value) => value.replace(/\r?\n+/g, " ").trim();
+/** A table cell must not carry a pipe of its own, or the row it sits in falls apart. */
+const cell = (value) => oneLine(value).replace(/\|/g, "\\|");
+/** A long delivery is trimmed, and the trim says so - a silent cut would read as the whole truth. */
+const truncate = (value, limit) => value.length > limit ? `${value.slice(0, limit)}…（已截断）` : value;
+/** A timestamp a person can read at a glance, and a missing one that says so. */
+const moment = (value) => value ? value.replace("T", " ").replace(/\.\d+Z$/, "") : "无";
+/**
+ * THE TWO SHAPES A PROJECT CAN HAVE.
+ *
+ * A standard project spends three sessions on every piece of work - the leader, the worker, and
+ * the reviewer - and pays two handovers for it. That is the right shape when the work needs an
+ * independent check, and it is too expensive for a project with one small task in it: the cost of
+ * the project flow then exceeds the cost of the work.
+ *
+ * A lightweight project collapses the flow to the leader session: it IS the worker, and a
+ * delivery is accepted on the executor's own evidence. Every guardrail is unchanged - the budget,
+ * the concurrency cap, the mandatory evidence, the escalation path, the event timeline - because
+ * what makes a project a project is the guardrails, not the number of sessions.
+ */
+const lightweight = (p) => p.mode === "lightweight";
 /** Persist explicit domain fields only; transport credentials never enter project records. */
 export class ProjectService {
     store;
@@ -125,12 +189,27 @@ export class ProjectService {
         return t;
     }
     projectView(p) {
+        const resources = this.resources(p);
         return {
             ...p,
-            resources: this.resources(p),
+            resources,
+            suggestedMaxTokens: this.suggestedMaxTokens(p, resources.tokens),
             tasks: p.tasks.map((t) => ProjectService.taskView(t, p)),
         };
     }
+    /**
+     * THE NUMBER THE ONE-CLICK PATH OFFERS.
+     *
+     * The Boss does not type a budget when the budget runs out: a number typed in a hurry is a
+     * number nobody predicted, and a budget that is guessed wrong is the failure this whole path
+     * exists to remove. So the server suggests one instead - double what has already been spent,
+     * because an agent run that needed twice its first budget will need twice its second one, and
+     * never less than one token more than the current cap, so the offer always really raises it.
+     */
+    suggestedMaxTokens(p, usedTokens) {
+        const current = p.budget?.maxTokens ?? DEFAULT_MAX_TOKENS;
+        return Math.max(current + 1, usedTokens * 2);
+    }
     raw(id, workspaceId) {
         const scope = this.workspace(workspaceId);
         const p = this.store.project(id);
@@ -192,9 +271,30 @@ export class ProjectService {
             throw new Error("仅直属 Leader 可以管理此任务");
         return manager;
     }
+    /**
+     * DOES THIS TASK COUNT AS ACCEPTED?
+     *
+     * In a STANDARD project, acceptance means another session reviewed this delivery: the reviewer
+     * of the review must be the session that was spawned to review, and it must NOT be the session
+     * that did the work. Those conditions are the whole point of an independent review, so they
+     * stand exactly as they were.
+     *
+     * In a LIGHTWEIGHT project there is no reviewer session at all - the leader session does the
+     * work itself - so a delivery is accepted on the executor's own evidence. The flag that says so
+     * is written by `submit` and nowhere else, and it names the session that made the call, so a
+     * task with no accepted review at all still counts for nothing.
+     */
+    taskAccepted(t) {
+        if (t.status !== "completed")
+            return false;
+        if (t.review?.lightweight === true)
+            return Boolean(t.review.reviewerConversationId);
+        return t.review?.verdict === "accepted" && t.review.reviewerConversationId === t.reviewerConversationId
+            && Boolean(t.reviewerConversationId) && t.reviewerConversationId !== t.ownerConversationId;
+    }
     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);
+        return required.length > 0 && required.every((t) => this.taskAccepted(t));
     }
     task(p, taskId) {
         const t = p.tasks.find((item) => item.id === taskId);
@@ -233,12 +333,22 @@ export class ProjectService {
         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,
+            // THE TREE SKELETON. The client draws the agents of a project as a tree, and the only
+            // thing that knows who spawned whom is the conversation's own parent link. It is sent
+            // 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,
             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));
+        /* A COORDINATOR IS NOT A WORKER - EXCEPT IN A LIGHTWEIGHT PROJECT, WHERE THE LEADER IS THE
+           WORKER. There the leader session does the work itself, so a project that is running must not
+           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),
             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 };
+            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 };
     }
     list(workspaceId) {
         const scope = this.workspace(workspaceId);
@@ -247,6 +357,109 @@ export class ProjectService {
     get(id, workspaceId) {
         return this.projectView(this.raw(id, workspaceId));
     }
+    /**
+     * THE PROJECT AS A REPORT A HUMAN CAN READ.
+     *
+     * Everything the panel shows in pieces - the objective, the tasks and who did them, the
+     * deliveries and their evidence, the reviews that accepted them, the exceptions and how they
+     * were decided - in one piece of Markdown, in reading order.
+     *
+     * TWO THINGS THIS REPORT REFUSES TO DO. It prints no session handle: a conversation id is a
+     * machine address, and a report full of addresses is not something a person can read or paste
+     * into a weekly note - the session's own title is used instead. And it prints no credential of
+     * any kind: the CONTENT of the tasks, events, reports and exceptions is the report, and a
+     * capability or a token that happens to live in a session profile is not content.
+     */
+    async exportReport(id, workspaceId) {
+        const p = workspaceId === undefined ? this.store.project(id) : this.raw(id, workspaceId);
+        if (!p)
+            throw new Error("项目不存在或不属于当前工作区");
+        const store = this.store;
+        /** THE TITLE A PERSON CALLS A SESSION BY. The handle stays out of the report. */
+        const session = (conversationId) => {
+            if (!conversationId)
+                return "系统";
+            return store.conversation(conversationId)?.title ?? "未知会话";
+        };
+        /** THE ROLE A TASK PLAYS, in the words the report uses. */
+        const role = (t) => t.role === "leader" ? "负责人" : t.parentTaskId ? "执行者" : "负责人直属";
+        /** THE ACCEPTANCE OF A TASK, told the truth about what is behind it. */
+        const acceptance = (t) => {
+            if (t.review?.lightweight === true)
+                return "自评交付（轻量项目，无独立复核）";
+            if (!t.review)
+                return "未验收";
+            return oneLine(t.review.summary);
+        };
+        /** THE TIMES A DELIVERY WAS SENT BACK. The current review only holds the last word, so the
+         *  earlier rejections are read back out of the timeline - the event summary carries the exact
+         *  text the reviewer wrote that day. */
+        const reworkNotes = (t) => {
+            const prefix = `退回返工：${t.title}；`;
+            return (p.events ?? []).filter((e) => e.kind === "reviewed" && e.taskId === t.id && e.summary.startsWith(prefix))
+                .map((e) => e.summary.slice(prefix.length).trim());
+        };
+        const lines = [];
+        lines.push(`# ${oneLine(p.title)}`, "", `> ${oneLine(p.objective)}`);
+        if (p.deliverables.length)
+            lines.push(`> 交付物：${p.deliverables.map(oneLine).join("；")}`);
+        if (p.acceptanceCriteria.length)
+            lines.push(`> 验收标准：${p.acceptanceCriteria.map(oneLine).join("；")}`);
+        lines.push("", "## 概览", "");
+        lines.push(`- 状态：${PROJECT_STATUS_TEXT[p.status] ?? p.status}`);
+        lines.push(`- 模式：${lightweight(p) ? "轻量" : "标准"}`);
+        lines.push(`- 风险：${SEVERITY_TEXT[p.risk] ?? p.risk}`);
+        lines.push(`- 创建时间：${moment(p.createdAt)}`);
+        lines.push(`- 最后更新时间：${moment(p.updatedAt)}`);
+        if (p.closedAt)
+            lines.push(`- 完成时间：${moment(p.closedAt)}`);
+        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}，取整）`);
+        lines.push(`- 任务：共 ${p.tasks.length} 个，已完成 ${p.tasks.filter((t) => t.status === "completed").length} 个`);
+        lines.push("", "## 交付与验收", "");
+        if (!p.tasks.length)
+            lines.push("无");
+        p.tasks.forEach((t, index) => {
+            lines.push(`### ${index + 1}. ${oneLine(t.title)}`, "");
+            lines.push(`- 角色：${role(t)}`);
+            lines.push(`- 状态：${TASK_STATUS_TEXT[t.status] ?? t.status}`);
+            lines.push(`- 负责人：${t.ownerConversationId ? session(t.ownerConversationId) : "未派发"}`);
+            lines.push(`- 复核者：${t.reviewerConversationId ? session(t.reviewerConversationId) : "无"}`);
+            lines.push(`- 交付内容：${t.output ? truncate(oneLine(t.output), 200) : "无"}`);
+            lines.push(`- 证据：${t.evidenceRefs?.length ? t.evidenceRefs.map(oneLine).join("、") : "无"}`);
+            lines.push(`- 验收结论：${acceptance(t)}`);
+            if (t.review?.evidenceRefs?.length)
+                lines.push(`- 复核证据：${t.review.evidenceRefs.map(oneLine).join("、")}`);
+            const notes = reworkNotes(t);
+            if (notes.length)
+                lines.push(`- 退回意见：${notes.join("；")}`);
+            lines.push("");
+        });
+        lines.push("## 例外与决定", "");
+        if (!p.escalations.length)
+            lines.push("无");
+        else {
+            lines.push("| 例外 | 严重程度 | 状态 | 决定 | 解决时间 |", "| --- | --- | --- | --- | --- |");
+            for (const e of p.escalations) {
+                lines.push(`| ${cell(e.reason)} | ${SEVERITY_TEXT[e.severity] ?? e.severity} | ${ESCALATION_STATUS_TEXT[e.status] ?? e.status} | ${cell(e.decision ?? "无")} | ${e.resolvedAt ? moment(e.resolvedAt) : "无"} |`);
+            }
+        }
+        lines.push("", "## 时间线", "");
+        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)}`);
+        lines.push("", "## 最近汇报", "");
+        if (!p.reports.length)
+            lines.push("无");
+        for (const r of p.reports) {
+            lines.push(`- ${REPORT_KIND_TEXT[r.kind] ?? r.kind}：${oneLine(r.progress)} ｜ 偏差：${r.variance ? oneLine(r.variance) : "无"} ｜ 下一步：${r.nextStep ? oneLine(r.nextStep) : "无"} ｜ 风险：${r.risks?.length ? r.risks.map(oneLine).join("、") : "无"}`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
     projectForSession(conversationId) {
         let c = this.store.conversation(conversationId);
         const seen = new Set();
@@ -265,6 +478,10 @@ export class ProjectService {
             throw new Error("项目负责人由启动操作创建独立会话");
         if (input.risk !== undefined && !["low", "medium", "high"].includes(input.risk))
             throw new Error("项目风险等级不合法");
+        // THE MODE IS CHOSEN ONCE, AT BIRTH, AND IT IS A CLOSED SET. A typo must not silently buy a
+        // project the standard shape, because the standard shape is the one with the reviewer.
+        if (input.mode !== undefined && input.mode !== "standard" && input.mode !== "lightweight")
+            throw new Error("项目模式不合法：只能是 standard 或 lightweight");
         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 ?? {})) {
@@ -280,7 +497,10 @@ export class ProjectService {
         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 },
+            risk: input.risk ?? "low", status: "planning", budget: { maxTokens: input.budget?.maxTokens ?? DEFAULT_MAX_TOKENS, maxConcurrent: input.budget?.maxConcurrent ?? 2 },
+            // A project without a mode is a standard project: the mode is written down only when it was
+            // asked for, so every project that existed before the mode existed reads as standard.
+            ...(input.mode ? { mode: input.mode } : {}),
             ...(defaultLeaderProfile ? { defaultLeaderProfile } : {}),
             ...(defaultExecutorProfile ? { defaultExecutorProfile } : {}),
             ...(defaultReviewerProfile ? { defaultReviewerProfile } : {}),
@@ -338,6 +558,12 @@ export class ProjectService {
                     // project, so it is where the project belongs in the tree. A project the Boss started from
                     // the panel has no initiator, and stays a root session exactly as before.
                     ...(p.initiatorConversationId ? { parentConversationId: p.initiatorConversationId } : {}),
+                    // A PROJECT IS ITS OWN WORKING CONTEXT. The leader hangs under the conversation that
+                    // asked for the project, but it must NOT share that conversation's memory tree: a tree
+                    // is what makes the memories of a chat visible to the sessions below it, and the
+                    // project's workers are not part of the user's chat. The tree edge is for the SIDEBAR
+                    // and the memory tree is for the WORK - they are two different things.
+                    separateMemoryTree: true,
                     title: `项目负责人 · ${p.title}`,
                     task: p.objective,
                     initialPrompt: "",
@@ -351,7 +577,7 @@ export class ProjectService {
             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 登记任务（明确目标、交付物、验收标准、依赖）；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 提交带证据的最终交付总结。上下文有限，明确假设，主动寻找反证。只在本次触发范围内工作。`, { wait: false });
+            await this.orchestrator.dispatch(p.ownerConversationId, `${this.context(p)}\n${lightweight(p) ? LIGHTWEIGHT_LEADER_PROMPT : STANDARD_LEADER_PROMPT}`, { wait: false });
             return p;
         });
     }
@@ -359,6 +585,15 @@ export class ProjectService {
         return this.change(id, workspaceId, (p) => {
             this.live(p);
             const parentTaskId = optional(input.parentTaskId, "父任务 id");
+            // A LIGHTWEIGHT PROJECT HAS ONE SESSION, SO IT HAS NO TREE OF TASKS. Decomposing the work
+            // would mean spawning the worker sessions the mode exists to avoid, and a branch leader
+            // would mean a second one. Both are refused here, in words the caller can act on.
+            if (lightweight(p)) {
+                if (parentTaskId)
+                    throw new Error("轻量项目不再拆子任务：整个项目由负责人会话自己完成");
+                if (input.role === "leader")
+                    throw new Error("轻量项目没有分支 Leader：请登记为执行任务，由负责人亲自完成");
+            }
             // A top-level task is accountable to whoever owns the project: the leader once it runs, and
             // before that the initiator who registered it - a task nobody answers for cannot be closed.
             let manager = p.ownerConversationId ?? p.initiatorConversationId;
@@ -429,16 +664,31 @@ export class ProjectService {
                 throw new Error("父任务未处于执行中");
             const effective = mergeProfile(t.executorProfile, p.defaultExecutorProfile);
             if (!t.ownerConversationId) {
-                t.ownerConversationId = (await this.orchestrator.spawn({
-                    workspaceId, parentConversationId: manager, title: `${t.role === "leader" ? "Leader" : "执行"} · ${t.title}`, task: t.objective, initialPrompt: "",
-                    ...(effective?.agentId ? { agentId: effective.agentId } : {}),
-                    ...(effective?.cwd !== undefined ? { cwd: effective.cwd } : {}),
-                    ...(effective?.model ? { model: effective.model } : {}),
-                    ...(effective?.thinkingLevel ? { thinkingLevel: effective.thinkingLevel } : {}),
-                    ...(effective?.watchdogTimeoutSeconds ? { watchdogTimeoutSeconds: effective.watchdogTimeoutSeconds } : {}),
-                })).conversationId;
+                if (lightweight(p)) {
+                    // THE LEADER IS THE WORKER. A lightweight project spawns no worker session, so the task's
+                    // executor IS the project leader session - the very session that is asking for this
+                    // dispatch. There is nothing to hand the work to otherwise.
+                    if (!p.ownerConversationId)
+                        throw new Error("轻量项目还没有负责人会话：请先启动项目负责人");
+                    t.ownerConversationId = p.ownerConversationId;
+                }
+                else {
+                    t.ownerConversationId = (await this.orchestrator.spawn({
+                        workspaceId, parentConversationId: manager, title: `${t.role === "leader" ? "Leader" : "执行"} · ${t.title}`, task: t.objective, initialPrompt: "",
+                        ...(effective?.agentId ? { agentId: effective.agentId } : {}),
+                        ...(effective?.cwd !== undefined ? { cwd: effective.cwd } : {}),
+                        ...(effective?.model ? { model: effective.model } : {}),
+                        ...(effective?.thinkingLevel ? { thinkingLevel: effective.thinkingLevel } : {}),
+                        ...(effective?.watchdogTimeoutSeconds ? { watchdogTimeoutSeconds: effective.watchdogTimeoutSeconds } : {}),
+                    })).conversationId;
+                }
             }
-            if (busy(this.store.conversation(t.ownerConversationId)?.status))
+            // THE BUSY CHECK IS ABOUT A SECOND WORKER SESSION, AND THERE IS NONE HERE. It stops a
+            // worker from being handed a second task while it is still running the first one. In a
+            // lightweight project the executor is the leader, which is busy by definition - it is the
+            // session that asked for this dispatch - and the leader's own queue serializes the tasks
+            // it has taken on.
+            if (!lightweight(p) && busy(this.store.conversation(t.ownerConversationId)?.status))
                 throw new Error("执行会话尚未结束，请等待完成回报后派发");
             t.status = "in_progress";
             t.updatedAt = stamp();
@@ -447,7 +697,11 @@ export class ProjectService {
             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；小任务不要继续拆层。` : "你是执行者，不得自行拆解子任务。";
-            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 });
+            /* 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 });
             return ProjectService.taskView(t, p);
         });
     }
@@ -462,9 +716,26 @@ export class ProjectService {
             if (t.role === "leader" && !this.requiredComplete(p, t.id))
                 throw new Error("Leader 的必需子任务尚未全部独立验收");
             t.output = text(input.output, "交付结果");
-            t.evidenceRefs = strings(input.evidenceRefs, "交付证据");
+            const evidenceRefs = strings(input.evidenceRefs, "交付证据");
+            t.evidenceRefs = evidenceRefs;
+            // THE EVIDENCE IS REQUIRED IN BOTH SHAPES. The reviewer is gone in a lightweight project,
+            // and the evidence is exactly what the reviewer would have checked - so it is the one thing
+            // that does not get lighter.
             if (!t.evidenceRefs.length)
                 throw new Error("交付必须附上产物或验证证据");
+            if (lightweight(p)) {
+                /* THE DELIVERY IS ACCEPTED ON THE EXECUTOR'S OWN EVIDENCE. There is no reviewer session to
+                   send it to, so the acceptance is written down here - with the flag that says there was
+                   no independent review, and with the session that made the call, so the record is not a
+                   claim that somebody else checked it. */
+                t.status = "completed";
+                t.updatedAt = stamp();
+                t.review = { verdict: "accepted", summary: "轻量项目：执行者自评交付，未做独立复核", evidenceRefs,
+                    reviewerConversationId: t.ownerConversationId, createdAt: stamp(), lightweight: true };
+                this.event(p, "submitted", `轻量交付完成：${t.title}`, t.id, actor);
+                this.reconcile(p);
+                return ProjectService.taskView(t, p);
+            }
             t.status = "awaiting_review";
             t.updatedAt = stamp();
             delete t.review;
@@ -475,6 +746,10 @@ export class ProjectService {
     }
     async requestReview(id, taskId, workspaceId, actor) {
         return this.change(id, workspaceId, async (p) => {
+            /* THERE IS NO REVIEWER TO ASK FOR. A lightweight project's delivery is accepted when it is
+               submitted, so asking for a review is asking for a session that will never exist. */
+            if (lightweight(p))
+                throw new Error("轻量项目不做独立复核：提交即完成");
             this.admission(p);
             const t = this.task(p, taskId);
             const manager = this.manager(p, t, actor);
@@ -639,6 +914,48 @@ export class ProjectService {
             await this.orchestrator?.stopSubtree?.(result.ownerConversationId);
         return result;
     }
+    /**
+     * THE SESSION THAT OPENED THE PROJECT MAY CANCEL IT.
+     *
+     * There is no delete here, and that is deliberate. The project record, its tasks, its events and
+     * its evidence references are the trail of what was tried; a project that went nowhere is
+     * evidence too. Cancelling stops the work and marks the project cancelled - the record stays,
+     * readable, with the reason attached.
+     *
+     * Only the session that opened the project may do this. A worker or a reviewer that could
+     * cancel the project it belongs to would have a way to make its own budget and concurrency
+     * guards disappear, and those guards are the only thing between a runaway agent and an
+     * unbounded bill. The human path - the panel's stop button - is unchanged and stays the Boss's.
+     *
+     * A reason is required: "we changed our minds" and "the customer shipped it last night" are
+     * different decisions, and the timeline is where that difference has to show up.
+     */
+    async cancel(id, body, workspaceId, actor) {
+        const reason = typeof body.reason === "string" ? body.reason.trim() : "";
+        if (!reason)
+            throw new Error("取消项目必须说明理由：理由会进入项目的事件时间线。");
+        const found = this.get(id, workspaceId);
+        if (!found.initiatorConversationId || found.initiatorConversationId !== actor)
+            throw new Error("只有项目的发起人可以取消它。");
+        const result = await this.change(id, workspaceId, (p) => {
+            this.live(p);
+            p.status = "cancelled";
+            if (closed(p))
+                p.closedAt = stamp();
+            for (const t of p.tasks) {
+                if (["completed", "cancelled", "failed"].includes(t.status))
+                    continue;
+                t.status = "cancelled";
+                t.updatedAt = stamp();
+            }
+            this.event(p, "status", `项目发起人取消项目：${reason}`, undefined, actor);
+            return p;
+        });
+        // Stop after releasing the write lock: an interrupted tool may itself be waiting for it.
+        if (result.ownerConversationId)
+            await this.orchestrator?.stopSubtree?.(result.ownerConversationId);
+        return result;
+    }
     async updateBudget(id, input, workspaceId) {
         return this.change(id, workspaceId, (p) => {
             this.live(p);
@@ -652,6 +969,56 @@ export class ProjectService {
             return p;
         });
     }
+    /**
+     * ONE CLICK: RAISE THE BUDGET AND LET THE WORK CONTINUE.
+     *
+     * Three things happen here, and they happen together: the cap goes up to a number the SERVER
+     * computed, the budget exception that is waiting for a decision is closed, and the work that
+     * was blocked is woken up again. Doing them apart is what made the old path painful - a Boss
+     * had to open a form, type a number, press save, and then wake the leader by hand, and every
+     * one of those steps was a chance to stop halfway.
+     *
+     * IT IS A BOSS OPERATION. A session may not raise the budget of its own project: the budget is
+     * the Boss's stop, and an agent that could lift its own limit would not have one. The HTTP
+     * layer refuses a request that carries a capability for the same reason.
+     *
+     * The manual `updateBudget` stays a SEPARATE intent: adjusting a number is not the same as
+     * asking for the work to continue, so the manual path does not continue anything.
+     */
+    async raiseBudgetAndContinue(id, workspaceId, callerConversationId) {
+        if (callerConversationId)
+            throw new Error("管理操作仅由 Boss 发起：Agent 不能提高预算，也不能替 Boss 让项目继续");
+        const raised = await this.change(id, workspaceId, (p) => {
+            this.live(p);
+            const previousMaxTokens = p.budget?.maxTokens ?? DEFAULT_MAX_TOKENS;
+            const usedTokens = this.resources(p).tokens;
+            const suggestedMaxTokens = Math.max(previousMaxTokens + 1, usedTokens * 2);
+            (p.budget ??= {}).maxTokens = suggestedMaxTokens;
+            const decision = `Boss 提高预算到 ${suggestedMaxTokens} Token 并继续`;
+            let resolvedEscalations = 0;
+            for (const e of p.escalations) {
+                if (e.status !== "open")
+                    continue;
+                // ONLY THE BUDGET ONES. An exception about scope or permissions is not the Boss's to
+                // close with a budget decision, and closing it here would hide a question nobody answered.
+                if (!e.reason.includes("预算"))
+                    continue;
+                e.status = "resolved";
+                e.decision = decision;
+                e.resolvedAt = stamp();
+                resolvedEscalations += 1;
+            }
+            this.event(p, "budget", `Boss 提高派发预算：${previousMaxTokens} → ${suggestedMaxTokens} Token，并继续执行（已处理 ${resolvedEscalations} 条预算例外）`);
+            this.reconcile(p);
+            return { previousMaxTokens, suggestedMaxTokens, resolvedEscalations };
+        });
+        // AND NOW LET IT MOVE. `start` is the existing way to wake the leader: it dispatches the
+        // leader session when the project has one, and creates one when it has not. Its refusal -
+        // "项目负责人正在执行，请勿重复启动" - is passed through unchanged: a busy leader is a fact
+        // the Boss has to see, not an error to swallow.
+        const project = await this.start(id, workspaceId);
+        return { ...raised, project };
+    }
     async addReport(id, input, workspaceId, actor) {
         return this.change(id, workspaceId, (p) => {
             this.live(p);
@@ -735,8 +1102,9 @@ export class ProjectService {
             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 (!required.length || required.some((t) => !this.taskAccepted(t))) {
+                throw new Error(lightweight(p) ? "所有任务必须完成交付后才能完成项目" : "所有任务必须经独立复核验收后才能完成项目");
+            }
             if (p.escalations.some((e) => e.status === "open"))
                 throw new Error("尚有未处理例外");
             const evidence = strings(evidenceRefs, "最终交付证据");
@@ -856,6 +1224,7 @@ export class ProjectService {
         this.member(p, actor);
         switch (body.action) {
             case "get": return p;
+            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);
             case "dispatch": return this.dispatchTask(id, text(body.taskId, "taskId"), workspaceId, actor);
@@ -866,6 +1235,7 @@ export class ProjectService {
             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);
+            case "cancel": return this.cancel(id, body, workspaceId, actor);
             default: throw new Error("未知的项目工具操作");
         }
     }

package/dist/server/application/session-orchestrator-service.d.ts

@@ -45,6 +45,15 @@ export interface SpawnSessionOptions {
     wait?: boolean;
     /** Optional silence watchdog timeout in seconds. If set, parent is reminded if child goes quiet for this duration. */
     watchdogTimeoutSeconds?: number;
+    /**
+     * Whether the new session opens its OWN memory tree instead of inheriting the parent's.
+     *
+     * A memory tree is what makes one conversation's tree-scoped memories visible to the sessions
+     * under it. A project wants the opposite: the project hangs under the conversation that asked
+     * for it in the SIDEBAR, and it shares nothing of that conversation's memories. The session tree
+     * edge and the memory tree are two different things, and this flag touches only the second.
+     */
+    separateMemoryTree?: boolean;
 }
 export interface ReportSessionOptions {
     /** The report content (milestone, findings, roadblock, or final output). */

package/dist/server/application/session-orchestrator-service.js

@@ -130,6 +130,7 @@ export class SessionOrchestratorService {
         const conversationId = await this.conversationService.createConversation(workspaceId, {
             parentConversationId: options.parentConversationId,
             origin: options.parentConversationId ? "orchestrator" : "user",
+            ...(options.separateMemoryTree ? { separateMemoryTree: true } : {}),
         }, cwd);
         // Set title if requested or derive from task
         if (options.title) {

package/dist/server/http-server.js

@@ -1551,6 +1551,15 @@ export function createHttpServer(options) {
                             json(200, { escalations: project.escalations });
                             return;
                         }
+                        // THE REPORT IS MARKDOWN, NOT JSON. It exists so a person can open the URL in a browser
+                        // and read the project, or paste it into a weekly note - a JSON body would need a reader
+                        // to have one, and the whole point is that the reader does not.
+                        if (subresource === "report") {
+                            const markdown = await service.exportReport(projectId, requestedWorkspaceId);
+                            response.writeHead(200, { "content-type": "text/markdown; charset=utf-8", "cache-control": "no-store" });
+                            response.end(markdown);
+                            return;
+                        }
                         json(404, { error: "未知的项目资源" });
                         return;
                     }
@@ -1585,6 +1594,14 @@ export function createHttpServer(options) {
                         json(200, { project });
                         return;
                     }
+                    // ONE CLICK: RAISE THE BUDGET AND CONTINUE. The server computes the new cap, closes the
+                    // budget exception and wakes the leader - the client sends no number of its own.
+                    if (request.method === "POST" && subresource === "budget" && parts[2] === "continue") {
+                        const result = await service.raiseBudgetAndContinue(projectId, workspaceId, callerConversationId);
+                        broadcaster.broadcastState();
+                        json(200, result);
+                        return;
+                    }
                     if (request.method === "POST" && subresource === "tasks" && parts[2] && parts[3] === "dispatch") {
                         const task = await service.dispatchTask(projectId, parts[2], workspaceId);
                         broadcaster.broadcastState();

package/dist/server/store.d.ts

@@ -281,6 +281,7 @@ export declare class Store {
         cwd?: string;
         parentConversationId?: string;
         origin?: "user" | "orchestrator";
+        separateMemoryTree?: boolean;
     }): Promise<Conversation>;
     /**
      * Records (or clears) one conversation as collapsed in the sidebar's session tree. The list is a