@evandu/super-pi 0.1.160 → 0.1.162

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-PN2dNRnQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-unAm6EaY.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;
@@ -59,6 +96,20 @@ export declare class ProjectService {
     private resources;
     list(workspaceId?: string): Project[];
     get(id: string, workspaceId?: string): Project;
+    /**
+     * 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.
+     */
+    exportReport(id: string, workspaceId?: string): Promise<string>;
     projectForSession(conversationId: string): Project | undefined;
     create(input: CreateProjectInput, initiatorConversationId?: string): Promise<Project>;
     private admission;
@@ -80,10 +131,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>;