@evandu/super-pi 0.1.160 → 0.1.161

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-D3XEFVty.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CYvr3uNw.css">
+    <script type="module" crossorigin src="/assets/index-B9tN8KD3.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BK3ZIqJj.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -44,10 +44,16 @@ export declare class ConversationService {
      * tree's edge (`parentConversationId`) and its origin. Only the orchestrator passes it - the "+"
      * button and every other caller create a top-level conversation by omission, which is the same
      * "absence means top level" rule the pre-tree state.json files read under.
+     *
+     * `separateMemoryTree` says that this conversation is its own working context: it must not
+     * inherit the memory tree of the conversation it hangs under. A project leader is the case that
+     * needs it - it sits in the user's chat in the sidebar, and it shares nothing of that chat's
+     * tree-scoped memories with it.
      */
     createConversation(workspaceId: string, parentage?: {
         parentConversationId?: string;
         origin?: "user" | "orchestrator";
+        separateMemoryTree?: boolean;
     }, cwd?: string): Promise<string>;
     /**
      * Name a conversation from what was said in it. Returns the title; the CALLER applies it, because the

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

@@ -50,6 +50,11 @@ export class ConversationService {
      * tree's edge (`parentConversationId`) and its origin. Only the orchestrator passes it - the "+"
      * button and every other caller create a top-level conversation by omission, which is the same
      * "absence means top level" rule the pre-tree state.json files read under.
+     *
+     * `separateMemoryTree` says that this conversation is its own working context: it must not
+     * inherit the memory tree of the conversation it hangs under. A project leader is the case that
+     * needs it - it sits in the user's chat in the sidebar, and it shares nothing of that chat's
+     * tree-scoped memories with it.
      */
     async createConversation(workspaceId, parentage, cwd) {
         const workspace = this.store.workspace(workspaceId);
@@ -128,7 +133,7 @@ export class ConversationService {
         // `null` is intentional here: Store uses it to remove a workspace value that it
         // would otherwise have copied before applying the resolved configuration.
         const sessionCwd = await normalizeSessionCwd(workspace.path, cwd);
-        const defaults = { ...resolved, agentId: resolved.agentId ?? null, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(sessionCwd ? { cwd: sessionCwd } : {}), ...(modelNotice ? { modelNotice } : {}), ...(agentNotice ? { agentNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}) };
+        const defaults = { ...resolved, agentId: resolved.agentId ?? null, model: resolved.model ?? null, thinkingLevel: resolved.thinkingLevel ?? null, ...(sessionCwd ? { cwd: sessionCwd } : {}), ...(modelNotice ? { modelNotice } : {}), ...(agentNotice ? { agentNotice } : {}), ...(parentage ? { parentConversationId: parentage.parentConversationId, origin: parentage.origin } : {}), ...(parentage?.separateMemoryTree ? { separateMemoryTree: true } : {}) };
         const created = await this.store.createConversation(workspaceId, defaults);
         this.broadcaster.broadcastState();
         return created.id;

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

@@ -1,5 +1,5 @@
 import type { Store } from "../store.js";
-import type { Project, ProjectEscalation, ProjectReport, ProjectRisk, ProjectTask, SessionProfile } from "../types.js";
+import type { Project, ProjectEscalation, ProjectMode, ProjectReport, ProjectRisk, ProjectTask, SessionProfile } from "../types.js";
 import type { SessionOrchestratorService } from "./session-orchestrator-service.js";
 export declare const profile: (value: unknown, label: string) => SessionProfile | undefined;
 export declare const mergeProfile: (taskProfile?: SessionProfile, projectDefault?: SessionProfile) => SessionProfile | undefined;
@@ -20,6 +20,9 @@ export type CreateProjectInput = {
     defaultExecutorProfile?: unknown;
     defaultReviewerProfile?: unknown;
     initiatorConversationId?: string;
+    /** "standard" (the default) or "lightweight" - the small project's shape, where the project
+     *  leader session does the work itself and no independent reviewer session exists. */
+    mode?: ProjectMode;
 };
 export type AddTaskInput = Partial<ProjectTask> & {
     title: string;
@@ -36,6 +39,16 @@ export type TopLevelTaskPlan = {
     priority?: ProjectTask["priority"];
     dependencies: string[];
 };
+/** What one click on 「提到 N Token 并继续」 produced. */
+export type BudgetRaiseResult = {
+    project: Project;
+    /** The cap before the raise, so the panel can say what changed. */
+    previousMaxTokens: number;
+    /** The cap the server raised it to - the number the one-click button promised. */
+    suggestedMaxTokens: number;
+    /** How many budget exceptions were closed by the raise. */
+    resolvedEscalations: number;
+};
 /** Persist explicit domain fields only; transport credentials never enter project records. */
 export declare class ProjectService {
     private readonly store;
@@ -44,6 +57,16 @@ export declare class ProjectService {
     constructor(store: Store, orchestrator?: (Pick<SessionOrchestratorService, "spawn" | "dispatch"> & Partial<Pick<SessionOrchestratorService, "stopSubtree">>) | undefined);
     static taskView(task: ProjectTask, project: Pick<Project, "defaultExecutorProfile" | "defaultReviewerProfile">): ProjectTask;
     private projectView;
+    /**
+     * 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.
+     */
+    private suggestedMaxTokens;
     private raw;
     private workspace;
     private event;
@@ -52,6 +75,20 @@ export declare class ProjectService {
     private leader;
     private topLevelAuthor;
     private 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.
+     */
+    private taskAccepted;
     private requiredComplete;
     private task;
     private member;
@@ -80,10 +117,44 @@ export declare class ProjectService {
         workspaceId?: string;
     }, actor?: string): Promise<ProjectTask>;
     updateStatus(id: string, status: Project["status"], workspaceId?: string): Promise<Project>;
+    /**
+     * 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.
+     */
+    cancel(id: string, body: Record<string, any>, workspaceId: string, actor: string): Promise<Project>;
     updateBudget(id: string, input: {
         maxTokens?: number;
         maxConcurrent?: number;
     }, workspaceId: string): Promise<Project>;
+    /**
+     * 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.
+     */
+    raiseBudgetAndContinue(id: string, workspaceId: string, callerConversationId?: string): Promise<BudgetRaiseResult>;
     addReport(id: string, input: Omit<ProjectReport, "id" | "projectId" | "createdAt">, workspaceId?: string, actor?: string): Promise<ProjectReport>;
     addEscalation(id: string, input: Pick<ProjectEscalation, "reason" | "severity" | "taskId">, workspaceId?: string, actor?: string): Promise<ProjectEscalation>;
     resolveEscalation(id: string, escalationId: string, decision: string, status: "resolved" | "dismissed", workspaceId?: string): Promise<ProjectEscalation>;

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,31 @@ 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 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 +160,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 +242,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 +304,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);
@@ -265,6 +346,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 +365,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 +426,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 +445,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 +453,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 +532,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 +565,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 +584,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 +614,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 +782,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 +837,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 +970,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, "最终交付证据");
@@ -866,6 +1102,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

@@ -1585,6 +1585,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();