@evandu/super-pi 0.1.21 → 0.1.23

package/dist/server/runtime.js

@@ -553,6 +553,8 @@ export class PiRpcRuntime {
     sessionDir;
     agents;
     options;
+    memory;
+    setMemory(memory) { this.memory = memory; }
     runs = new Map();
     /**
      * `steer` commands written to a child and not yet answered by Pi, keyed by the command id.
@@ -698,7 +700,7 @@ export class PiRpcRuntime {
             [TASK_CAPABILITY_ENV]: mintCapability(conversationId),
         };
     }
-    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolEnd, images }) {
+    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolEnd, images, memoryReview, memorySourceConversationId }) {
         await mkdir(this.sessionDir, { recursive: true });
         // Normalize first: the picker can hand over forward slashes or a trailing separator, and `resolve`
         // turns both into one absolute native path. The directory must exist on disk before spawn - a
@@ -711,10 +713,11 @@ export class PiRpcRuntime {
         // them: its RPC command union (rpc-types.ts:20-74) has no prompt and no tools command, so there is
         // nothing to send after the process is already running. Fetched before the spawn so a definition
         // error fails the turn loudly instead of starting a Pi that silently ignores it.
-        const agent = await this.agentFor(conversation);
+        const agent = memoryReview ? undefined : await this.agentFor(conversation);
+        const validationId = memorySourceConversationId ?? conversation.id;
         if (agent?.model)
-            await this.modelValidator?.(conversation.id, { ...agent.model, label: agent.model.modelId });
-        await this.modelValidator?.(conversation.id, conversation.model);
+            await this.modelValidator?.(validationId, { ...agent.model, label: agent.model.modelId });
+        await this.modelValidator?.(validationId, conversation.model);
         // Whether the `task` tool EXISTS is decided first, because that is what decides whether it belongs
         // on the allowlist. Naming a tool Pi has not registered is meaningless, and doing it anyway would
         // change the spawn line of a runtime that has no task tool - which is what
@@ -727,20 +730,24 @@ export class PiRpcRuntime {
         // declared - broken with no error. An agent that says `task: false` still wins: `toolFlags` treats an
         // explicit false as outranking a host extra, which is what makes "this agent does not delegate" true
         // rather than advisory.
-        const extensionArgs = await this.taskExtensionArgs();
+        const extensionArgs = memoryReview ? [] : await this.taskExtensionArgs();
+        const memoryEnabled = this.memory ? (await this.memory.configuration()).enabled : false;
+        const memoryToken = memoryEnabled ? this.memory.issue(validationId, { review: memoryReview }) : undefined;
+        const memoryExtension = resolve(import.meta.dirname, "../../agents/super-pi-memory/index.ts");
+        const memoryArgs = memoryEnabled ? ["--extension", memoryExtension] : [];
         // BOTH extension tools, or neither. Naming one while the other goes unmentioned would be a lie in a
         // different direction: Pi filters its registry through `--tools`, so an agent that declares
         // `tools: {"*": false, read: true}` gets whichever of the two is on this line and silently not the
         // other. They also share the extension's existence - `extensionArgs` is non-empty exactly when
         // `index.ts` is on disk and an endpoint was configured - so there is no case where one is mounted and
         // the other is not.
-        const agentArgs = await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME] : [] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)
             throw new Error(this.pi.reason);
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
-        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...agentArgs], {
+        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...memoryArgs, ...agentArgs], {
             cwd: childCwd,
             stdio: ["pipe", "pipe", "pipe"],
             shell: process.platform === "win32",
@@ -748,7 +755,11 @@ export class PiRpcRuntime {
             // every turn would silently replace the child's environment with whatever THIS process has at
             // spawn time. Inheriting is what an omitted `env` already does, so the two paths differ in nothing
             // but the four documented additions.
-            ...(extensionArgs.length ? { env: { ...process.env, ...await this.taskExtensionEnv(conversation.id) } } : {}),
+            ...((extensionArgs.length || memoryEnabled) ? { env: { ...process.env, ...(extensionArgs.length ? await this.taskExtensionEnv(conversation.id) : {}), ...(memoryEnabled ? {
+                        SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT,
+                        SUPER_PI_MEMORY_TOKEN: memoryToken,
+                        SUPER_PI_MEMORY_REVIEW: memoryReview ? "1" : "0",
+                    } : {}) } } : {}),
         });
         const channel = new RpcChannel(child);
         this.runs.set(conversation.id, { child, channel });
@@ -794,7 +805,7 @@ export class PiRpcRuntime {
             if (this.modelValidator) {
                 const actual = await channel.request({ id: "policy_state", type: "get_state" }, SESSION_COMMAND_TIMEOUT_MS);
                 const model = actual.data?.model;
-                await this.modelValidator(conversation.id, model?.provider && model.id ? { provider: model.provider, modelId: model.id, label: model.name ?? model.id } : undefined);
+                await this.modelValidator(validationId, model?.provider && model.id ? { provider: model.provider, modelId: model.id, label: model.name ?? model.id } : undefined);
             }
             const imagePayloads = this.options.uploadsDir && images?.length
                 ? await loadConversationImages(this.options.uploadsDir, conversation.id, images)
@@ -957,12 +968,14 @@ export class PiRpcRuntime {
             // exit - a turn that answered, a turn that threw, and a turn whose child was killed - because a
             // credential whose turn has ended is a credential with no owner.
             releaseCapability(conversation.id);
+            if (memoryToken)
+                this.memory?.release(memoryToken);
             // A steer still unanswered when the turn ends is REJECTED, not left pending. The drain loop above
             // is the only reader of this child's stdout and it has stopped, so nothing would ever settle that
             // promise: the caller would wait for a timeout to learn something this process already knows. The
             // message itself is not lost - Pi drains steering before its loop can end, so anything unanswered
             // at this point was in practice not delivered, and the caller returns it to its queue.
-            if (this.pendingSteers.size) {
+            if (!memoryReview && this.pendingSteers.size) {
                 for (const [id, pending] of [...this.pendingSteers]) {
                     this.pendingSteers.delete(id);
                     pending.reject(new Error(`Pi never answered the steer: the turn ended first.`));

package/dist/server/server-context.d.ts

@@ -33,6 +33,7 @@ export interface EventBroadcaster {
  * Central server context containing infrastructure dependencies and application services.
  */
 export interface ServerContext {
+    memory?: import("./active-memory.js").ActiveMemory;
     paths: ServerPaths;
     store: Store;
     runtime: AgentRuntime;
@@ -44,4 +45,15 @@ export interface ServerContext {
     runService: RunService;
     extensionUiService: ExtensionUiService;
     catalogService: CatalogService;
+    /**
+     * Whether the right rail's terminal tab should exist, and why not when it should not.
+     *
+     * TWO PREDICATES AND NOT A `TerminalService` HANDLE, and that is the load-bearing part. `/api/terminal`
+     * only ever needs to answer "is it on"; handing the HTTP layer the service itself would put a
+     * `spawn` within reach of a GET request, and the terminal is the one part of this server that is not
+     * confined to a workspace. Keeping the handle on `CommandHandler` alone means the only route to a
+     * shell is a WebSocket message that `TerminalService.assertUsable` has already vetted.
+     */
+    terminalEnabled?: () => boolean;
+    terminalDisabledReason?: () => string;
 }

package/dist/server/store.d.ts

@@ -1,3 +1,5 @@
+import type { AppStateRepository } from "./persistence/app-state-repository.js";
+import { defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import type { WorkflowRun } from "./workflow.js";
 import type { AppState, Conversation, Message, MessageImage, ModelSelection, QueuedMessage, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallBlock, Workspace } from "./types.js";
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
@@ -69,10 +71,12 @@ export type RevertPlan = {
     doomedRunIds: string[];
 };
 export declare class Store {
-    private readonly filePath;
+    private readonly repository;
     private state;
     private constructor();
     static open(filePath: string): Promise<Store>;
+    /** Opens an injected repository, retaining domain reconciliation here. */
+    static openRepository(repository: AppStateRepository): Promise<Store>;
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
     snapshot(): AppState;
     createWorkspace(name: string, path?: string): Promise<Workspace>;
@@ -476,7 +480,12 @@ export declare class Store {
      *
      * A rejected write must not poison the queue, or one failure would reject every later persist as well.
      */
-    private persistQueue;
+    flush(): Promise<void>;
+    /** Releases persistence resources after all accepted writes settle. */
+    close(): Promise<void>;
+    private persistTransaction;
+    private persistCollections;
+    private persistMetadata;
     private persist;
 }
-export declare function defaultStorePath(dataDir: string): string;
+export declare const defaultStorePath: typeof defaultJsonStatePath;

package/dist/server/store.js

@@ -1,5 +1,4 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { JsonStateRepository, defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import { normalizeTodos } from "./task-tool.js";
 function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
@@ -427,15 +426,19 @@ function reconcileTodos(state) {
     return { changed: before !== fingerprint(state.todos) };
 }
 export class Store {
-    filePath;
+    repository;
     state;
-    constructor(filePath, state) {
-        this.filePath = filePath;
+    constructor(repository, state) {
+        this.repository = repository;
         this.state = state;
     }
     static async open(filePath) {
+        return this.openRepository(new JsonStateRepository(filePath));
+    }
+    /** Opens an injected repository, retaining domain reconciliation here. */
+    static async openRepository(repository) {
         try {
-            const state = JSON.parse(await readFile(filePath, "utf8"));
+            const state = await repository.load();
             if (!Array.isArray(state.backgroundTasks))
                 state.backgroundTasks = [];
             // Every sweep runs before the store is constructed, so a single persist below publishes them together.
@@ -446,7 +449,7 @@ export class Store {
             const interrupted = reconcileConversations(state);
             const requeued = reconcileQueuedMessages(state);
             const todos = reconcileTodos(state);
-            const store = new Store(filePath, normalizeMessageTimestamps(state));
+            const store = new Store(repository, normalizeMessageTimestamps(state));
             // Persisted here, in `open`, rather than left for the first unrelated write: a reconciled record that
             // is only rewritten by a later mutation would still read `running` to anything that opened the file
             // in the meantime, and would be reconciled a SECOND time on the next restart.
@@ -470,7 +473,7 @@ export class Store {
             if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
                 throw error;
             const createdAt = now();
-            return new Store(filePath, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], queuedMessages: [], backgroundTasks: [] });
+            return new Store(repository, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], queuedMessages: [], backgroundTasks: [] });
         }
     }
     async setModelFilterRules(rules) {
@@ -678,7 +681,7 @@ export class Store {
         if (conversation.status === "running")
             throw new Error("运行中的会话无法归档，请先停止运行");
         conversation.archivedAt = now();
-        await this.persist();
+        await this.persistMetadata(conversationId);
     }
     /** Restoring deletes the key rather than setting it to null, so a fully restored conversation serializes
      *  byte-identically to one that was never archived. `delete` is legal here because the field is optional. */
@@ -687,7 +690,7 @@ export class Store {
         if (!conversation.archivedAt)
             return;
         delete conversation.archivedAt;
-        await this.persist();
+        await this.persistMetadata(conversationId);
     }
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
@@ -709,7 +712,7 @@ export class Store {
             throw new Error("Conversation name must be 1-80 characters");
         const conversation = this.requireConversation(conversationId);
         conversation.title = cleanName;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     async addUserMessage(conversationId, content, images) {
@@ -767,7 +770,7 @@ export class Store {
         // which is the exact failure this whole note is about, one level up. scripts/session-picker.test.mjs
         // pins the real key set instead, and re-breaks whenever a field is added.
         conversation.model = { provider: model.provider, modelId: model.modelId, label: model.label };
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     /** Restoring Pi's own default deletes the key rather than storing Pi's default as this app's state. */
@@ -777,7 +780,7 @@ export class Store {
             delete conversation.thinkingLevel;
         else
             conversation.thinkingLevel = level;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     /**
@@ -792,7 +795,7 @@ export class Store {
             delete conversation.agentId;
         else
             conversation.agentId = agentId;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     async setConversationConfiguration(conversationId, settings) {
@@ -823,8 +826,15 @@ export class Store {
         return structuredClone(conversation);
     }
     async beginAssistantMessage(conversationId, agentIdentity) { const conversation = this.requireConversation(conversationId); const message = { id: id("message"), role: "assistant", content: "", createdAt: now(), ...(agentIdentity ? { agentIdentity: structuredClone(agentIdentity) } : {}) }; conversation.messages.push(message); await this.persist(); return structuredClone(message); }
-    async appendAssistantDelta(conversationId, messageId, delta) { const conversation = this.requireConversation(conversationId); const message = conversation.messages.find((item) => item.id === messageId); if (!message)
-        throw new Error("Assistant message not found"); message.content += delta; conversation.updatedAt = now(); await this.persist(); }
+    async appendAssistantDelta(conversationId, messageId, delta) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message)
+            throw new Error("Assistant message not found");
+        message.content += delta;
+        conversation.updatedAt = now();
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: conversation.updatedAt });
+    }
     /**
      * Appends one tool call to the message it belongs to, and returns the message's whole `toolCalls`
      * array so the caller can broadcast it as one snapshot.
@@ -894,7 +904,7 @@ export class Store {
         await this.persist();
         return structuredClone(calls);
     }
-    async setStatus(conversationId, status) { const conversation = this.requireConversation(conversationId); conversation.status = status; conversation.updatedAt = now(); await this.persist(); }
+    async setStatus(conversationId, status) { const conversation = this.requireConversation(conversationId); conversation.status = status; conversation.updatedAt = now(); await this.persistMetadata(conversationId); }
     /** The plan a revert would carry out, without carrying it out. The server reads this to stop children first. */
     planRevert(conversationId, messageId, withdraw = false) { return planRevert(this.state, conversationId, messageId, withdraw); }
     /**
@@ -977,7 +987,7 @@ export class Store {
         if (images && images.length > 0)
             message.images = structuredClone(images);
         this.state.queuedMessages.push(message);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(message);
     }
     /**
@@ -1001,7 +1011,7 @@ export class Store {
         if (this.state.queuedMessages[index].state === "sending")
             throw new Error("这条消息已经交给 Agent 了，取消不掉（Pi 没有撤回单条队列消息的能力）");
         const [removed] = this.state.queuedMessages.splice(index, 1);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(removed);
     }
     /**
@@ -1025,7 +1035,7 @@ export class Store {
         if (message.state === "sending")
             throw new Error(`排队消息已经交给 Agent 了：${queueId}`);
         message.state = "sending";
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(message);
     }
     /**
@@ -1044,7 +1054,7 @@ export class Store {
         if (!message || message.state !== "sending")
             return;
         message.state = "queued";
-        await this.persist();
+        await this.persistCollections("queuedMessages");
     }
     /**
      * Removes the OLDEST `count` messages this conversation has in `sending`, and returns them.
@@ -1067,7 +1077,7 @@ export class Store {
         if (!doomed.length)
             return [];
         this.state.queuedMessages = this.state.queuedMessages.filter((item) => !doomed.includes(item.id));
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(sending.slice(0, doomed.length));
     }
     /**
@@ -1085,7 +1095,7 @@ export class Store {
         if (index < 0)
             return undefined;
         const [taken] = this.state.queuedMessages.splice(index, 1);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(taken);
     }
     /**
@@ -1106,7 +1116,7 @@ export class Store {
             changed = true;
         }
         if (changed)
-            await this.persist();
+            await this.persistCollections("queuedMessages");
     }
     // ------------------------------------------------------------- Sub-agent runs
     // Records, not transcripts: what lands here is the dispatch, the last assistant message and the
@@ -1157,7 +1167,7 @@ export class Store {
             throw new Error(`Workflow already recorded: ${plan.id}`);
         this.state.workflows.unshift(plan);
         trimWorkflows(this.state.workflows);
-        await this.persist();
+        await this.persistCollections("workflows");
         return structuredClone(plan);
     }
     /**
@@ -1182,7 +1192,7 @@ export class Store {
             throw new Error(`Workflow not found: ${stored.id}`);
         this.state.workflows[index] = stored;
         trimWorkflows(this.state.workflows);
-        await this.persist();
+        await this.persistCollections("workflows");
         return structuredClone(stored);
     }
     async setBackgroundTask(summary) {
@@ -1191,11 +1201,11 @@ export class Store {
             Object.assign(existing, summary);
         else
             this.state.backgroundTasks.unshift(summary);
-        await this.persist();
+        await this.persistCollections("backgroundTasks");
     }
     async removeBackgroundTask(id) {
         this.state.backgroundTasks = this.state.backgroundTasks.filter((item) => item.id !== id);
-        await this.persist();
+        await this.persistCollections("backgroundTasks");
     }
     /**
      * Applies the fields a run's life can change, and nothing else.
@@ -1215,7 +1225,7 @@ export class Store {
         if (!run)
             throw new Error(`Sub-agent run not found: ${runId}`);
         Object.assign(run, changes);
-        await this.persist();
+        await this.persistTransaction({ kind: "subagent.replace", run: structuredClone(run) });
         return structuredClone(run);
     }
     /**
@@ -1276,59 +1286,22 @@ export class Store {
      *
      * A rejected write must not poison the queue, or one failure would reject every later persist as well.
      */
-    persistQueue = Promise.resolve();
-    async persist() {
-        const write = this.persistQueue.then(async () => {
-            await mkdir(dirname(this.filePath), { recursive: true });
-            const temporaryPath = `${this.filePath}.tmp`;
-            await writeFile(temporaryPath, `${JSON.stringify(this.state, null, 2)}\n`, "utf8");
-            await replaceFile(temporaryPath, this.filePath);
-        });
-        this.persistQueue = write.catch(() => { });
-        await write;
+    async flush() { await this.repository.flush(); }
+    /** Releases persistence resources after all accepted writes settle. */
+    async close() { await this.flush(); this.repository.close?.(); }
+    async persistTransaction(transaction) {
+        if (this.repository.commit)
+            await this.repository.commit(transaction);
+        else
+            await this.persist();
     }
-}
-/**
- * How long `replaceFile` keeps retrying a rename that lost a race with a reader. Two seconds is two
- * orders of magnitude past the measured sub-50ms release, so it exists to absorb a loaded machine and a
- * virus scanner mid-scan, not to wait out a lock that will never clear.
- */
-const RENAME_RETRY_MS = 2_000;
-const RENAME_RETRY_STEP_MS = 5;
-/**
- * Renames `from` over `to`, retrying the WINDOWS SHARING VIOLATION.
- *
- * WHY THIS EXISTS, because the failure it fixes was a real defect and not a test artefact. On Windows a
- * rename onto a file that ANY handle has open fails with EPERM/EACCES: the destination must be held with
- * FILE_SHARE_DELETE, and a plain reader does not do that. Node's own `readFile` is such a reader, and so
- * is every indexer, virus scanner and sync client on the machine. So `persist()` threw EPERM, the caller's
- * mutation stayed only in memory, and the save was LOST - the settings dialog had already closed on send,
- * so the person who pressed 保存 was told nothing and kept a default that had never been saved.
- * scripts/workspace-settings-browser.test.mjs reproduced it at roughly 1 save in 5, and every occurrence
- * read as "the save never arrived" because the refusal travelled to the browser as an error event the
- * suite did not read, so a refused write and a slow write were indistinguishable for a whole day.
- *
- * MEASURED, so the bound is honest rather than hopeful: renaming onto a held-open `state.json` fails on
- * the first attempt 40 times out of 40 and clears within one 5ms tick of the reader letting go (worst
- * case 11 attempts). The lock lasts exactly as long as somebody is READING, which is why a bounded
- * retry is the fix and not a longer sleep: the transient case is short, and a genuinely stuck file is
- * not a sharing violation. A file that stays contended past the bound still throws, which is the honest
- * outcome - the store reports a failed write instead of pretending it saved.
- */
-async function replaceFile(from, to) {
-    const deadline = Date.now() + RENAME_RETRY_MS;
-    for (;;) {
-        try {
-            await rename(from, to);
-            return;
-        }
-        catch (error) {
-            const code = error.code;
-            const contended = code === "EPERM" || code === "EACCES" || code === "EBUSY";
-            if (!contended || Date.now() >= deadline)
-                throw error;
-            await new Promise((resolve) => setTimeout(resolve, RENAME_RETRY_STEP_MS));
-        }
+    async persistCollections(key) {
+        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(this.state[key]) } });
+    }
+    async persistMetadata(conversationId) {
+        const { messages: _messages, ...metadata } = this.requireConversation(conversationId);
+        await this.persistTransaction({ kind: "conversation.metadata", conversationId, metadata: structuredClone(metadata) });
     }
+    async persist() { await this.repository.save(this.state); }
 }
-export function defaultStorePath(dataDir) { return join(dataDir, "state.json"); }
+export const defaultStorePath = defaultJsonStatePath;

package/dist/server/subagent-runs.d.ts

@@ -127,6 +127,8 @@ export declare class SubagentRunRecorder {
      * reconciliation cleans up the RECORD of such a run; this stops the PROCESS from being one.
      */
     abortAll(): void;
+    /** Waits for every child that was live at shutdown to settle and record its outcome. */
+    waitForIdle(): Promise<void>;
     /**
      * Runs one sub-agent, recording it from before the spawn to after the settle, and returns the record
      * as it ended.

package/dist/server/subagent-runs.js

@@ -99,6 +99,12 @@ export class SubagentRunRecorder {
         for (const entry of this.controllers.values())
             entry.controller.abort();
     }
+    /** Waits for every child that was live at shutdown to settle and record its outcome. */
+    async waitForIdle() {
+        while (this.controllers.size > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
     /**
      * Runs one sub-agent, recording it from before the spawn to after the settle, and returns the record
      * as it ended.

package/dist/server/subagents.d.ts

@@ -137,6 +137,8 @@ export declare class SubagentCancelled extends Error {
 export declare class SubagentSupervisor {
     private readonly sessionDir;
     private agents;
+    private memory?;
+    setMemory(memory: import("./active-memory.js").ActiveMemory): void;
     private readonly pi;
     /** Live children by run id, so a caller can name the process it means. Cleared in the run's `finally`. */
     private readonly children;

package/dist/server/subagents.js

@@ -168,6 +168,8 @@ const addUsage = (total, usage) => {
 export class SubagentSupervisor {
     sessionDir;
     agents;
+    memory;
+    setMemory(memory) { this.memory = memory; }
     pi;
     /** Live children by run id, so a caller can name the process it means. Cleared in the run's `finally`. */
     children = new Map();
@@ -244,10 +246,12 @@ export class SubagentSupervisor {
         const agent = await this.subagentDefinition(agentId);
         // The child's own `tools:` map, minus whatever the dispatching agent denied. Never the parent's
         // ALLOWLIST - see `SubagentRunInput.denyTools` for why that asymmetry is the reference's too.
-        const agentArgs = await agentSpawnArgs(this.agents.promptDir, agent, { denyTools: input.denyTools ?? [] });
+        const memoryEnabled = this.memory ? (await this.memory.configuration()).enabled : false;
+        const agentArgs = await agentSpawnArgs(this.agents.promptDir, agent, { denyTools: input.denyTools ?? [], extraAllowedTools: memoryEnabled ? ["memory", "skill_manage", "session_search"] : [] });
         const sessionDirectory = join(this.sessionDir, "subagents");
         await mkdir(sessionDirectory, { recursive: true });
-        const args = ["--mode", "rpc", "--session-dir", sessionDirectory, "--session-id", id, ...agentArgs];
+        const memoryToken = memoryEnabled ? this.memory.issue(conversationId, { readOnly: true }) : undefined;
+        const args = ["--mode", "rpc", "--session-dir", sessionDirectory, "--session-id", id, ...(memoryToken ? ["--extension", resolve(import.meta.dirname, "../../agents/super-pi-memory/index.ts")] : []), ...agentArgs];
         // Model inheritance: the definition wins, otherwise the parent's current model, otherwise Pi's own
         // default. "Omit the model and get what the parent is running on" is the default worth having, and it
         // is a spawn-time flag because there is no RPC command to change it later.
@@ -260,7 +264,9 @@ export class SubagentSupervisor {
         if (agent.thinkingLevel)
             args.push("--thinking", agent.thinkingLevel);
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
-        const child = spawn(shellQuote(this.pi.command), args, { cwd: childCwd, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32" });
+        const child = spawn(shellQuote(this.pi.command), args, { cwd: childCwd, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32", ...(memoryToken ? { env: { ...process.env, SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT, SUPER_PI_MEMORY_TOKEN: memoryToken, SUPER_PI_MEMORY_READ_ONLY: "1" } } : {}) });
+        if (memoryToken)
+            child.once("close", () => this.memory?.release(memoryToken));
         this.children.set(id, { conversationId, child });
         const channel = new RpcChannel(child);
         // Pi is asked to stop first and killed only if that is not enough, so a child that can unwind its own
@@ -508,6 +514,8 @@ export class SubagentSupervisor {
             return { id, sessionId: id, finalText: finalText || streamed, usage };
         }
         finally {
+            if (memoryToken)
+                this.memory?.release(memoryToken);
             signal?.removeEventListener("abort", abort);
             this.children.delete(id);
             // The run is not over until the child is actually gone: a process still tearing down still holds a