@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/application.js

@@ -1,15 +1,15 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { GitRequestController, requestMainRunIds, startGitGoalRequest, startGitRequest } from "./git-request.js";
 import { mediaHistory } from "./media-history.js";
-import { applicationServices, defineAgent, withDefaultCompactionThreshold, } from "@sortedyuan/application";
-import { createToolChangePreview, decodeToolChangePreviewPresentation, TOOL_CHANGE_PREVIEW_PRESENTATION_KIND, TOOL_CHANGE_PREVIEW_PRESENTATION_VERSION, } from "@sortedyuan/coding-tools";
-import { PruneOldToolResultsStrategy, } from "@sortedyuan/context";
-import { AsyncEventQueue, RunCancelledError, isStreamingMayEvent, ToolRegistry, } from "@sortedyuan/core";
-import { loadMaybeCodeInstructions, MaybeCodeInstructionState, } from "./instructions.js";
-import { historyMemoryService } from "@sortedyuan/plugin-history-memory";
-import { goalsService } from "@sortedyuan/plugin-goals";
-import { delegationService } from "@sortedyuan/plugin-delegation";
-import { mcpService } from "@sortedyuan/plugin-mcp";
+import { applicationServices, defineAgent, withDefaultCompactionThreshold } from "@sortedyuan/may";
+import { createToolChangePreview, decodeToolChangePreviewPresentation, TOOL_CHANGE_PREVIEW_PRESENTATION_KIND, TOOL_CHANGE_PREVIEW_PRESENTATION_VERSION, openCodingExecutionEnvironment, } from "@sortedyuan/coding-tools";
+import { PruneOldToolResultsStrategy, } from "@sortedyuan/may/context";
+import { AsyncEventQueue, RunCancelledError, isStreamingMayEvent, omitUndefined, ToolRegistry, } from "@sortedyuan/may/core";
+import { loadMaybeCodeInstructions, MaybeCodeInstructionState } from "./instructions.js";
+import { historyMemoryService } from "@sortedyuan/may/history-memory";
+import { goalsService } from "@sortedyuan/may/goals/plugin";
+import { delegationService } from "@sortedyuan/coordination/delegation";
+import { mcpService } from "@sortedyuan/mcp/plugin";
 import { createMaybeCodePlugins, requestRecord } from "./plugins/application.js";
 import { createMaybeCodeInstructionsPlugin } from "./plugins/instructions.js";
 export { DEFAULT_MAYBE_CODE_INSTRUCTIONS } from "./instructions.js";
@@ -21,15 +21,16 @@ const MAYBECODE_MAX_STEPS = 32;
  *
  * Coding tools, prompts, permission defaults, preview presentation and named
  * compaction choices remain product policy. Session/run/approval persistence and
- * cancellation are delegated to `@sortedyuan/application`.
+ * cancellation are delegated to `@sortedyuan/may`.
  */
 export class MaybeCodeApplication {
     createModelPlugins;
+    execution;
     events;
     sessionId;
     workspace;
     instructionState;
-    application;
+    agent;
     serviceReferences;
     updatingModel = false;
     modelUpdate;
@@ -51,44 +52,69 @@ export class MaybeCodeApplication {
     inputEpoch = 0;
     steeringCancellation = Promise.resolve();
     removeGoalListener;
-    constructor(workspace, application, instructions, createModelPlugins) {
+    backgroundTasks = new Set();
+    backgroundErrors = [];
+    constructor(workspace, application, instructions, createModelPlugins, execution) {
         this.createModelPlugins = createModelPlugins;
+        this.execution = execution;
         this.workspace = workspace;
-        this.application = application;
+        this.agent = application;
         this.sessionId = application.sessionId;
         this.instructionState = instructions;
         this.serviceReferences = this.readServices();
-        this.events = this.eventQueue;
+        this.events = this.readEvents();
         this.eventRelay = this.relayEvents(application.events);
+        this.trackBackground(this.eventRelay);
         this.connectServiceEvents();
     }
     static async open(options) {
+        const execution = await openCodingExecutionEnvironment({
+            workspace: options.workspace,
+            isolation: options.execution ?? { mode: "host" },
+        });
+        let opened = false;
+        try {
+            const product = await MaybeCodeApplication.openWithExecution(options, execution);
+            opened = true;
+            return product;
+        }
+        finally {
+            if (!opened)
+                await execution.close();
+        }
+    }
+    static async openWithExecution(options, execution) {
         const workspace = resolve(options.workspace);
         const configuredTools = ToolRegistry.compose(options.tools ?? [], options.additionalTools ?? []);
-        const created = options.resume && options.sessionId && options.store.inspect ? (await options.store.inspect(options.sessionId))[0] : undefined;
+        const created = options.resume && options.sessionId && options.store.inspect
+            ? (await options.store.inspect(options.sessionId))[0]
+            : undefined;
         const sessionMetadata = options.sessionMetadata ?? (created?.type === "session.created" ? created.metadata : undefined);
         const fork = sessionMetadata?.workspaceFork;
         const forkOrigin = options.fork ?? (created?.type === "session.created" ? created.fork : undefined);
         const instructions = await loadMaybeCodeInstructions({
             workspace,
-            ...(options.instructions === undefined
-                ? {}
-                : { instructions: options.instructions }),
-            ...(options.instructionsDirectory === undefined
-                ? {}
-                : { instructionsDirectory: options.instructionsDirectory }),
+            ...(options.instructions === undefined ? {} : { instructions: options.instructions }),
+            ...(options.instructionsDirectory === undefined ? {} : { instructionsDirectory: options.instructionsDirectory }),
         });
         const instructionState = new MaybeCodeInstructionState(workspace, instructions);
-        const initialModelInfo = options.plugins?.some(plugin => plugin.provides?.some(service => service.id === applicationServices.model.id && service.scope === applicationServices.model.scope))
-            ? undefined : options.modelInfo;
+        const initialModelInfo = options.plugins?.some((plugin) => plugin.provides?.some((service) => service.id === applicationServices.model.id && service.scope === applicationServices.model.scope))
+            ? undefined
+            : options.modelInfo;
         let product;
         const gitRequest = new GitRequestController(options.gitWorkspace);
-        const createPlugins = (current) => createMaybeCodePlugins({ ...current,
-            plugins: [createMaybeCodeInstructionsPlugin(instructionState, {
-                    workspace, options: current, historicalBranch: forkOrigin !== undefined || fork !== undefined,
-                    ...(forkOrigin === undefined ? {} : { historicalSource: forkOrigin.sessionId }),
-                }), ...(current.plugins ?? [])],
-            onGitCheckpoint: checkpoint => {
+        const createPlugins = (current) => createMaybeCodePlugins({
+            ...current,
+            plugins: [
+                createMaybeCodeInstructionsPlugin(instructionState, {
+                    workspace,
+                    options: current,
+                    historicalBranch: forkOrigin !== undefined || fork !== undefined,
+                    ...omitUndefined({ historicalSource: forkOrigin?.sessionId }),
+                }),
+                ...(current.plugins ?? []),
+            ],
+            onGitCheckpoint: (checkpoint) => {
                 options.onGitCheckpoint?.(checkpoint);
                 if (!product)
                     throw new Error("Git checkpoint completed before the MaybeCode application was ready");
@@ -96,15 +122,20 @@ export class MaybeCodeApplication {
             },
         }, {
             workspace,
+            execution,
             gitRequest,
             instructions: instructions.system.content,
             instructionsSource: () => instructionState.current.system.content,
             projectInstructionsSource: () => instructionState.projectInstructions(),
             prepareInstructions: () => instructionState.refreshProject(),
-            ...(current.contextBudget === undefined ? {} : { contextBudget: withDefaultCompactionThreshold(current.contextBudget) }),
+            ...(current.contextBudget === undefined
+                ? {}
+                : { contextBudget: withDefaultCompactionThreshold(current.contextBudget) }),
         });
         const composition = createPlugins(options);
         const definition = defineAgent({
+            requestRecording: options.requestRecording ?? "required",
+            providerBodyRecording: options.providerBodyRecording,
             plugins: composition.plugins,
             forkStateKeys: ["maybecode.context-notes", "maybecode.model"],
             forkPluginIds: ["may.history-memory"],
@@ -112,27 +143,23 @@ export class MaybeCodeApplication {
             tools: configuredTools,
             toolScope: { workspaceId: resolve(options.workspace) },
             beforeToolExecute: gitRequest.beforeToolExecute,
-            ...(options.permissionRuleStore === undefined ? {} : { permissionRuleStore: options.permissionRuleStore }),
             instructions: instructions.system.content,
-            ...(options.tracer === undefined ? {} : { tracer: options.tracer }),
+            ...omitUndefined({
+                permissionRuleStore: options.permissionRuleStore,
+                tracer: options.tracer,
+                runBudget: options.runBudget,
+            }),
             traceAttributes: {
                 ...(options.traceAttributes ?? {}),
                 "may.agent.name": "maybecode",
-                ...(initialModelInfo?.profile === undefined
-                    ? {}
-                    : { "may.model.profile": initialModelInfo.profile }),
-                ...(initialModelInfo?.provider === undefined
-                    ? {}
-                    : { "may.model.provider": initialModelInfo.provider }),
-                ...(initialModelInfo?.adapter === undefined
-                    ? {}
-                    : { "may.model.adapter": initialModelInfo.adapter }),
-                ...(initialModelInfo?.model === undefined
-                    ? {}
-                    : { "may.model.name": initialModelInfo.model }),
+                ...omitUndefined({
+                    "may.model.profile": initialModelInfo?.profile,
+                    "may.model.provider": initialModelInfo?.provider,
+                    "may.model.adapter": initialModelInfo?.adapter,
+                    "may.model.name": initialModelInfo?.model,
+                }),
             },
             maxSteps: options.maxSteps ?? MAYBECODE_MAX_STEPS,
-            ...(options.runBudget === undefined ? {} : { runBudget: options.runBudget }),
             sessionHistory: { retrieval: true },
             createToolPresentation: async (check) => {
                 const preview = await createToolChangePreview(workspace, check.tool.name, check.input);
@@ -151,22 +178,20 @@ export class MaybeCodeApplication {
             store: options.store,
             metadata: { ...options.sessionMetadata, workspace },
             contextMetadata: { workspace },
-            ...(options.sessionId === undefined
-                ? {}
-                : { sessionId: options.sessionId }),
-            ...(options.resume === undefined ? {} : { resume: options.resume }),
-            ...(options.fork === undefined ? {} : { fork: options.fork }),
+            ...omitUndefined({ sessionId: options.sessionId, resume: options.resume, fork: options.fork }),
         });
-        product = new MaybeCodeApplication(workspace, application, instructionState, update => {
-            if (options.plugins?.some(plugin => plugin.provides?.some(service => service.id === applicationServices.model.id && service.scope === applicationServices.model.scope))) {
+        product = new MaybeCodeApplication(workspace, application, instructionState, (update) => {
+            if (options.plugins?.some((plugin) => plugin.provides?.some((service) => service.id === applicationServices.model.id && service.scope === applicationServices.model.scope))) {
                 throw new Error("The configured Model plugin owns model selection");
             }
             const { model: _model, modelInfo: _modelInfo, modelRuntimeOptions: _modelRuntimeOptions, contextBudget: _contextBudget, ...base } = options;
             return createPlugins({ ...base, ...update });
-        });
+        }, execution);
         product.gitRequest = gitRequest;
-        product.permissionScopeId = options.permissionRuleStore === undefined ? undefined
-            : options.permissionScopeId ?? `maybecode:${workspace}:main`;
+        product.permissionScopeId =
+            options.permissionRuleStore === undefined
+                ? undefined
+                : (options.permissionScopeId ?? `maybecode:${workspace}:main`);
         try {
             await product.recordModel(options.modelRuntimeOptions);
         }
@@ -178,38 +203,51 @@ export class MaybeCodeApplication {
     }
     readServices() {
         return {
-            history: this.application.getService(historyMemoryService),
-            modelInfo: this.application.getOptionalService(applicationServices.modelInfo),
-            goals: this.application.getOptionalService(goalsService),
-            subagents: this.application.getOptionalService(delegationService)?.get(),
-            mcp: this.application.getOptionalService(mcpService),
+            history: this.agent.getService(historyMemoryService),
+            modelInfo: this.agent.getOptionalService(applicationServices.modelInfo),
+            goals: this.agent.getOptionalService(goalsService),
+            subagents: this.agent.getOptionalService(delegationService)?.get(),
+            mcp: this.agent.getOptionalService(mcpService),
         };
     }
-    get modelInfo() { return this.serviceReferences.modelInfo; }
-    get goals() { return this.serviceReferences.goals; }
-    get subagents() { return this.serviceReferences.subagents; }
-    get mcp() { return this.serviceReferences.mcp; }
-    get modelUpdateFailed() { return this.modelUpdateFailure !== undefined; }
-    get historyMemory() { return this.serviceReferences.history.memory; }
+    get modelInfo() {
+        return this.serviceReferences.modelInfo;
+    }
+    get goals() {
+        return this.serviceReferences.goals;
+    }
+    get subagents() {
+        return this.serviceReferences.subagents;
+    }
+    get mcp() {
+        return this.serviceReferences.mcp;
+    }
+    get modelUpdateFailed() {
+        return this.modelUpdateFailure !== undefined;
+    }
+    get historyMemory() {
+        return this.serviceReferences.history.memory;
+    }
     connectServiceEvents() {
         const { goals, subagents } = this.serviceReferences;
-        this.removeGoalListener = goals?.subscribe(event => {
+        this.removeGoalListener = goals?.subscribe((event) => {
             this.eventQueue.push(event);
             if (!this.updatingModel && !goals.isRunning)
-                void this.resumeSteering();
+                this.trackBackground(this.resumeSteering());
         });
         this.subagentRelay = subagents === undefined ? undefined : this.relaySubagentEvents(subagents.events);
+        if (this.subagentRelay)
+            this.trackBackground(this.subagentRelay);
     }
     async recordModel(runtimeOptions) {
         const info = this.modelInfo;
         if (info === undefined)
             return;
-        await this.application.recordState("maybecode.model", {
-            provider: info.provider, model: info.model,
-            ...(info.adapter === undefined ? {} : { adapter: info.adapter }),
-            ...(info.profile === undefined ? {} : { profile: info.profile }),
-            runtimeOptions: typeof runtimeOptions?.reasoningEffort === "string"
-                ? { reasoningEffort: runtimeOptions.reasoningEffort } : {},
+        await this.agent.recordState("maybecode.model", {
+            provider: info.provider,
+            model: info.model,
+            ...omitUndefined({ adapter: info.adapter, profile: info.profile }),
+            runtimeOptions: typeof runtimeOptions?.reasoningEffort === "string" ? { reasoningEffort: runtimeOptions.reasoningEffort } : {},
         });
     }
     async updateModel(update) {
@@ -218,7 +256,7 @@ export class MaybeCodeApplication {
         if (this.isRunning || this.compaction || this.getGoal()?.status === "active") {
             throw new Error("Finish the active operation before changing the model");
         }
-        if ([this.sessionId, ...this.ownedDelegatedSessions()].some(sessionId => this.mcp?.interactions?.list({ workspaceId: this.workspace, sessionId }).length)) {
+        if ([this.sessionId, ...this.ownedDelegatedSessions()].some((sessionId) => this.mcp?.interactions?.list({ workspaceId: this.workspace, sessionId }).length)) {
             throw new Error("Finish the MCP interaction before changing the model");
         }
         const composition = this.createModelPlugins(update);
@@ -235,7 +273,7 @@ export class MaybeCodeApplication {
     }
     async replaceModelPlugins(composition, update) {
         try {
-            await this.application.updatePlugins(composition.plugins);
+            await this.agent.updatePlugins(composition.plugins);
             this.removeGoalListener?.();
             await this.subagentRelay;
             this.serviceReferences = this.readServices();
@@ -249,12 +287,18 @@ export class MaybeCodeApplication {
         }
     }
     get isRunning() {
-        return this.updatingModel || this.inputOperations > 0 || this.currentRun !== undefined || this.application.isRunning ||
-            this.goals?.isRunning === true || this.subagents?.isRunning === true;
+        return (this.updatingModel ||
+            this.inputOperations > 0 ||
+            this.currentRun !== undefined ||
+            this.agent.isRunning ||
+            this.goals?.isRunning === true ||
+            this.subagents?.isRunning === true);
     }
     get instructions() {
-        return { ...this.instructionState.current,
-            effective: this.application.getService(applicationServices.instructionSources).snapshot() };
+        return {
+            ...this.instructionState.current,
+            effective: this.agent.getService(applicationServices.instructionSources).snapshot(),
+        };
     }
     submit(options) {
         const epoch = this.inputEpoch;
@@ -266,24 +310,24 @@ export class MaybeCodeApplication {
             const goalPause = this.goals?.isRunning ? this.goals.pause("Paused for a new user message") : undefined;
             if (run || compaction) {
                 this.historyMemory.cancelRequest();
-                this.application.cancel("Interrupted by a new user message");
+                this.agent.cancel("Interrupted by a new user message");
                 await this.subagents?.cancel("Interrupted by a new user message");
             }
-            await this.application.cancelSteeringInputs("Replaced by a new user message");
+            await this.agent.cancelSteeringInputs("Replaced by a new user message");
             await goalPause;
             await Promise.allSettled([...(run ? [run.result] : []), ...(compaction ? [compaction] : [])]);
             if (epoch !== this.inputEpoch)
                 throw new RunCancelledError("Input cancelled before execution");
             options.signal?.throwIfAborted();
-            const next = this.track(await this.startRequest({
+            const next = this.track(await this.startRequest(omitUndefined({
                 mode: "submit",
                 input: options.input,
                 record: requestRecord(options.input),
-                ...(options.runBudget === undefined ? {} : { runBudget: options.runBudget }),
-                ...(options.shouldYield === undefined ? {} : { shouldYield: options.shouldYield }),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                ...(options.traceAttributes === undefined ? {} : { traceAttributes: options.traceAttributes }),
-            }, options));
+                runBudget: options.runBudget,
+                shouldYield: options.shouldYield,
+                signal: options.signal,
+                traceAttributes: options.traceAttributes,
+            }), options));
             if (epoch !== this.inputEpoch) {
                 next.cancel("Input cancelled during startup");
                 await next.result.catch(() => undefined);
@@ -297,10 +341,10 @@ export class MaybeCodeApplication {
             if (epoch !== this.inputEpoch)
                 throw new RunCancelledError("Input cancelled before acceptance");
             await this.steeringCancellation;
-            const input = await this.application.steer(options);
+            const input = await this.agent.steer(options);
             if (epoch !== this.inputEpoch) {
                 await this.steeringCancellation;
-                return this.application.listSteeringInputs().find(item => item.inputId === input.inputId);
+                return this.agent.listSteeringInputs().find((item) => item.inputId === input.inputId);
             }
             if (input.status === "idle" && !this.goals?.isRunning && this.subagents?.isRunning !== true) {
                 const run = this.track(await this.startRequest({
@@ -312,10 +356,9 @@ export class MaybeCodeApplication {
                 if (epoch !== this.inputEpoch)
                     run.cancel("Input cancelled during startup");
             }
-            return this.application.listSteeringInputs().find(item => item.inputId === input.inputId);
+            return this.agent.listSteeringInputs().find((item) => item.inputId === input.inputId);
         });
     }
-    listSteeringInputs() { return this.application.listSteeringInputs(); }
     serializeInput(operation, allowClosed = false) {
         this.inputOperations++;
         const result = this.inputTail.then(() => {
@@ -324,10 +367,16 @@ export class MaybeCodeApplication {
             if (this.updatingModel)
                 throw new Error("Finish the model update before submitting input");
             if (this.modelUpdateFailure !== undefined)
-                throw new Error("Model update failed; retry the model update before continuing", { cause: this.modelUpdateFailure });
+                throw new Error("Model update failed; retry the model update before continuing", {
+                    cause: this.modelUpdateFailure,
+                });
             return operation();
         });
-        this.inputTail = result.then(() => { this.inputOperations--; }, () => { this.inputOperations--; });
+        this.inputTail = result.then(() => {
+            this.inputOperations--;
+        }, () => {
+            this.inputOperations--;
+        });
         return result;
     }
     track(run) {
@@ -335,23 +384,29 @@ export class MaybeCodeApplication {
         const settled = () => {
             if (this.currentRun === run)
                 this.currentRun = undefined;
-            void this.resumeSteering();
+            return this.resumeSteering();
         };
-        void run.result.then(settled, settled);
+        this.trackBackground(run.result.then(settled, settled));
         return run;
     }
     async resumeSteering() {
-        if (this.closed || this.updatingModel || this.modelUpdateFailure !== undefined || !this.application.listSteeringInputs().some(input => input.status === "idle"))
+        if (this.closed ||
+            this.updatingModel ||
+            this.modelUpdateFailure !== undefined ||
+            !this.agent.listSteeringInputs().some((input) => input.status === "idle"))
             return;
         const epoch = this.inputEpoch;
         await this.serializeInput(async () => {
-            if (this.closed || epoch !== this.inputEpoch || this.application.isRunning ||
-                this.goals?.isRunning || this.subagents?.isRunning)
+            if (this.closed ||
+                epoch !== this.inputEpoch ||
+                this.agent.isRunning ||
+                this.goals?.isRunning ||
+                this.subagents?.isRunning)
                 return;
             await this.steeringCancellation;
             if (this.closed || epoch !== this.inputEpoch)
                 return;
-            const input = this.application.listSteeringInputs().find(item => item.status === "idle");
+            const input = this.agent.listSteeringInputs().find((item) => item.status === "idle");
             if (input) {
                 this.track(await this.startRequest({
                     mode: "steer",
@@ -362,18 +417,28 @@ export class MaybeCodeApplication {
             }
         }, true);
     }
-    getGoal() { return this.goals?.getGoal(); }
-    getService(service) { return this.application.getService(service); }
-    getOptionalService(service) { return this.application.getOptionalService(service); }
-    startGoal(objective, budget) { return this.requireGoals().start(objective, budget); }
-    resumeGoal() { return this.requireGoals().resume(); }
-    pauseGoal() { return this.requireGoals().pause(); }
-    cancelGoal() { return this.requireGoals().cancel(); }
+    getGoal() {
+        return this.goals?.getGoal();
+    }
+    startGoal(objective, budget) {
+        return this.requireGoals().start(objective, budget);
+    }
+    resumeGoal() {
+        return this.requireGoals().resume();
+    }
+    pauseGoal() {
+        return this.requireGoals().pause();
+    }
+    cancelGoal() {
+        return this.requireGoals().cancel();
+    }
     requireGoals() {
         if (this.updatingModel)
             throw new Error("Finish the model update before changing the goal");
         if (this.modelUpdateFailure !== undefined)
-            throw new Error("Model update failed; retry the model update before continuing", { cause: this.modelUpdateFailure });
+            throw new Error("Model update failed; retry the model update before continuing", {
+                cause: this.modelUpdateFailure,
+            });
         if (!this.goals)
             throw new Error("Goals are disabled in this application");
         return this.goals;
@@ -392,26 +457,26 @@ export class MaybeCodeApplication {
     }
     /** 启动一次用户请求；未启用委派时启动一个普通 Run。 */
     async startRequest(plan, options, inputId) {
-        return startGitRequest(this.gitRequest, this.sessionId, () => this.startRequestRun(plan, options, inputId), checkpoint => this.eventQueue.push({ type: "workspace.git.changed", checkpoint }), async (runId) => (await this.application.branchPositions()).find(position => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await this.application.history(), firstRunId));
+        return startGitRequest(this.gitRequest, this.sessionId, () => this.startRequestRun(plan, options, inputId), (checkpoint) => this.eventQueue.push({ type: "workspace.git.changed", checkpoint }), async (runId) => (await this.agent.branchPositions()).find((position) => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await this.agent.history(), firstRunId));
     }
     async startRequestRun(plan, options, inputId) {
         if (this.subagents !== undefined) {
-            return this.subagents.start({
+            return this.subagents.start(omitUndefined({
                 input: plan.input,
                 record: plan.record,
-                ...(inputId === undefined ? {} : { inputId }),
-                ...(plan.runBudget === undefined ? {} : { runBudget: plan.runBudget }),
-                ...(plan.shouldYield === undefined ? {} : { shouldYield: plan.shouldYield }),
-                ...(plan.signal === undefined ? {} : { signal: plan.signal }),
-                ...(plan.traceAttributes === undefined ? {} : { traceAttributes: plan.traceAttributes }),
-            }, plan.mode === "continue" ? "continue" : "submit");
+                inputId,
+                runBudget: plan.runBudget,
+                shouldYield: plan.shouldYield,
+                signal: plan.signal,
+                traceAttributes: plan.traceAttributes,
+            }), plan.mode === "continue" ? "continue" : "submit");
         }
         if (plan.mode === "continue")
-            return this.plainRun(await this.application.retry());
+            return this.plainRun(await this.agent.retry());
         if (plan.mode === "steer") {
-            return this.plainRun(await this.application.startSteeringInput(inputId));
+            return this.plainRun(await this.agent.startSteeringInput(inputId));
         }
-        return this.plainRun(await this.application.submit(options));
+        return this.plainRun(await this.agent.submit(options));
     }
     /** 没有委派的单个 Run 同样以一次请求的身份报告。 */
     plainRun(run) {
@@ -420,7 +485,7 @@ export class MaybeCodeApplication {
             id: run.id,
             requestId: `run-${run.id}`,
             result: run.result,
-            ...(run.traceContext === undefined ? {} : { traceContext: run.traceContext }),
+            ...omitUndefined({ traceContext: run.traceContext }),
             cancel: (reason) => run.cancel(reason),
             runs: async () => [{ runId: run.id, sessionId, turn: 0, result: await run.result }],
         };
@@ -436,24 +501,26 @@ export class MaybeCodeApplication {
         return {
             sessionId: this.sessionId,
             get isRunning() {
-                return owner.application.isRunning || owner.subagents?.isRunning === true;
+                return owner.agent.isRunning || owner.subagents?.isRunning === true;
             },
-            submit: (options) => startGitGoalRequest(owner.gitRequest, owner.sessionId, () => owner.startRequestRun({
+            submit: (options) => startGitGoalRequest(owner.gitRequest, owner.sessionId, () => owner.startRequestRun(omitUndefined({
                 mode: "submit",
                 input: options.input,
                 record: requestRecord(options.input),
-                ...(options.runBudget === undefined ? {} : { runBudget: options.runBudget }),
-                ...(options.shouldYield === undefined ? {} : { shouldYield: options.shouldYield }),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-            }, { ...options, input: options.input }), checkpoint => owner.eventQueue.push({ type: "workspace.git.changed", checkpoint }), runId => owner.application.saveBranchPosition(runId, { allowYielded: true }), async (runId) => (await owner.application.branchPositions()).find(position => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await owner.application.history(), firstRunId)),
-            continue: (options) => startGitGoalRequest(owner.gitRequest, owner.sessionId, () => owner.subagents ? owner.startRequestRun({
-                mode: "continue",
-                input: "",
-                record: "Continue the active goal",
-                ...(options.runBudget === undefined ? {} : { runBudget: options.runBudget }),
-                ...(options.shouldYield === undefined ? {} : { shouldYield: options.shouldYield }),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-            }) : owner.application.continue(options), checkpoint => owner.eventQueue.push({ type: "workspace.git.changed", checkpoint }), runId => owner.application.saveBranchPosition(runId, { allowYielded: true }), async (runId) => (await owner.application.branchPositions()).find(position => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await owner.application.history(), firstRunId)),
+                runBudget: options.runBudget,
+                shouldYield: options.shouldYield,
+                signal: options.signal,
+            }), { ...options, input: options.input }), (checkpoint) => owner.eventQueue.push({ type: "workspace.git.changed", checkpoint }), (runId) => owner.agent.saveBranchPosition(runId, { allowYielded: true }), async (runId) => (await owner.agent.branchPositions()).find((position) => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await owner.agent.history(), firstRunId)),
+            continue: (options) => startGitGoalRequest(owner.gitRequest, owner.sessionId, () => owner.subagents
+                ? owner.startRequestRun(omitUndefined({
+                    mode: "continue",
+                    input: "",
+                    record: "Continue the active goal",
+                    runBudget: options.runBudget,
+                    shouldYield: options.shouldYield,
+                    signal: options.signal,
+                }))
+                : owner.agent.continue(options), (checkpoint) => owner.eventQueue.push({ type: "workspace.git.changed", checkpoint }), (runId) => owner.agent.saveBranchPosition(runId, { allowYielded: true }), async (runId) => (await owner.agent.branchPositions()).find((position) => position.runId === runId)?.positionSeq, async (firstRunId) => requestMainRunIds(await owner.agent.history(), firstRunId)),
         };
     }
     listDelegationRequests() {
@@ -484,97 +551,151 @@ export class MaybeCodeApplication {
         this.inputEpoch++;
         const request = this.subagents?.isRunning === true;
         if (request)
-            void this.subagents?.cancel(reason ?? "Cancelled by user");
-        const pending = this.inputOperations > 0 || this.application.listSteeringInputs().some(input => input.status === "pending" || input.status === "idle");
-        this.steeringCancellation = this.application.cancelSteeringInputs(reason);
+            this.trackBackground(this.subagents.cancel(reason ?? "Cancelled by user"));
+        const pending = this.inputOperations > 0 ||
+            this.agent.listSteeringInputs().some((input) => input.status === "pending" || input.status === "idle");
+        this.steeringCancellation = this.agent.cancelSteeringInputs(reason);
+        this.trackBackground(this.steeringCancellation);
         this.historyMemory.cancelRequest();
         if (this.goals?.interrupt(reason))
             return true;
-        return this.application.cancel(reason) || pending || request;
+        return this.agent.cancel(reason) || pending || request;
     }
     resolveApproval(requestId, decision, options) {
         const subagent = this.subagents?.resolveApproval(requestId, decision);
         return subagent === undefined
-            ? this.application.resolveApproval(requestId, decision, options)
-            : subagent.then(resolved => resolved || this.application.resolveApproval(requestId, decision, options));
+            ? this.agent.resolveApproval(requestId, decision, options)
+            : subagent.then((resolved) => resolved || this.agent.resolveApproval(requestId, decision, options));
+    }
+    get persistentRulesEnabled() {
+        return this.permissionScopeId !== undefined;
     }
-    get persistentRulesEnabled() { return this.permissionScopeId !== undefined; }
     async listPermissionRules(scopeId) {
         if (this.permissionScopeId === undefined)
             throw new Error("持久权限规则没有启用。");
         if (scopeId !== undefined && scopeId !== this.permissionScopeId)
             throw new Error("权限规则范围不属于当前宿主。");
-        return this.application.listPermissionRules(this.permissionScopeId);
+        return this.agent.listPermissionRules(this.permissionScopeId);
+    }
+    createPermissionRule(check, options) {
+        return this.agent.createPermissionRule(check, options);
     }
-    createPermissionRule(check, options) { return this.application.createPermissionRule(check, options); }
     async createPermissionRuleFrom(id, options) {
-        if (!(await this.listPermissionRules()).some(rule => rule.id === id))
+        if (!(await this.listPermissionRules()).some((rule) => rule.id === id))
             throw new Error("规则不属于当前宿主。");
-        return this.application.createPermissionRuleFrom(id, options);
+        return this.agent.createPermissionRuleFrom(id, options);
     }
     async revokePermissionRule(id) {
-        if (!(await this.listPermissionRules()).some(rule => rule.id === id))
+        if (!(await this.listPermissionRules()).some((rule) => rule.id === id))
             return false;
-        return this.application.revokePermissionRule(id);
+        return this.agent.revokePermissionRule(id);
     }
     async history() {
-        return mediaHistory(await this.application.history());
+        return mediaHistory(await this.agent.history());
+    }
+    listRecoveries() {
+        return this.agent.listRecoveries();
+    }
+    listSkills() {
+        const skills = this.agent.skills;
+        const active = new Map(skills?.listActive().map((item) => [item.name, item]));
+        const all = new Map(skills?.registry.list().map((item) => [item.name, item]));
+        for (const [name, item] of active)
+            all.set(name, item);
+        return [...all.values()].map((item) => ({ ...item, active: active.has(item.name) }));
     }
-    listRecoveries() { return this.application.listRecoveries(); }
-    get skills() { return this.application.skills; }
     activateSkill(name) {
         if (this.isRunning)
             throw new Error("Cannot activate a skill while an operation is active");
-        return this.application.activateSkill(name);
+        return this.agent.activateSkill(name);
     }
     resolveRecovery(id, finding) {
         if (this.isRunning)
             throw new Error("Cannot resolve recovery while an operation is active");
-        return this.application.resolveRecovery(id, finding);
+        return this.agent.resolveRecovery(id, finding);
     }
     queryHistory(query) {
-        return this.application.queryHistory(query);
+        return this.agent.queryHistory(query);
     }
     branchPositions() {
-        return this.application.branchPositions();
+        return this.agent.branchPositions();
     }
     inspectContext() {
         if (this.modelUpdateFailure !== undefined)
-            throw new Error("Model update failed; retry the model update before continuing", { cause: this.modelUpdateFailure });
-        return this.application.inspectContext();
+            throw new Error("Model update failed; retry the model update before continuing", {
+                cause: this.modelUpdateFailure,
+            });
+        return this.agent.inspectContext();
     }
     compactContext(selection) {
         if (this.updatingModel || this.subagents?.isRunning === true || this.goals?.isRunning === true) {
             throw new Error("Cannot compact context while a request or goal is active");
         }
         if (this.modelUpdateFailure !== undefined)
-            throw new Error("Model update failed; retry the model update before continuing", { cause: this.modelUpdateFailure });
-        const result = this.application.compactContext(this.resolveCompactionStrategy(selection));
+            throw new Error("Model update failed; retry the model update before continuing", {
+                cause: this.modelUpdateFailure,
+            });
+        const result = this.agent.compactContext(this.resolveCompactionStrategy(selection));
         this.compaction = result;
-        const finished = () => { if (this.compaction === result)
-            this.compaction = undefined; };
+        const finished = () => {
+            if (this.compaction === result)
+                this.compaction = undefined;
+        };
         void result.then(finished, finished);
         return result;
     }
     close() {
-        return this.closing ??= this.closeOnce();
+        return (this.closing ??= this.closeOnce());
     }
     async closeOnce() {
         this.closed = true;
+        this.removeGoalListener?.();
         try {
             if (this.modelUpdate)
                 await Promise.allSettled([this.modelUpdate]);
-            await this.steeringCancellation;
-            await this.application.close();
-            await this.inputTail;
-            await this.eventRelay;
-            await this.subagentRelay;
+            const results = await Promise.allSettled([
+                this.steeringCancellation,
+                this.agent.close(),
+                this.inputTail,
+                this.eventRelay,
+                ...(this.subagentRelay ? [this.subagentRelay] : []),
+            ]);
+            while (this.backgroundTasks.size)
+                await Promise.all(this.backgroundTasks);
+            const failures = [
+                ...new Set([
+                    ...this.backgroundErrors,
+                    ...results.flatMap((result) => (result.status === "rejected" ? [result.reason] : [])),
+                ]),
+            ];
+            if (failures.length)
+                throw new AggregateError(failures, "MaybeCode background operations failed");
         }
         finally {
-            this.removeGoalListener?.();
-            this.eventQueue.close();
+            try {
+                await this.execution.close();
+            }
+            finally {
+                this.eventQueue.close();
+            }
         }
     }
+    trackBackground(operation) {
+        const task = operation.then(() => {
+            this.backgroundTasks.delete(task);
+        }, (error) => {
+            this.backgroundTasks.delete(task);
+            this.backgroundErrors.push(error);
+            this.eventQueue.close();
+        });
+        this.backgroundTasks.add(task);
+    }
+    async *readEvents() {
+        for await (const event of this.eventQueue)
+            yield event;
+        if (this.backgroundErrors.length)
+            throw new AggregateError(this.backgroundErrors, "MaybeCode background operations failed");
+    }
     async relaySubagentEvents(events) {
         for await (const event of events)
             this.eventQueue.push(event);
@@ -623,8 +744,7 @@ function requireNativeCompaction(strategy) {
 }
 function assertWorkspace(metadata, workspace) {
     const stored = metadata?.workspace;
-    if (typeof stored === "string" &&
-        normalizePath(stored) !== normalizePath(workspace)) {
+    if (typeof stored === "string" && normalizePath(stored) !== normalizePath(workspace)) {
         throw new Error(`Session belongs to another workspace: ${stored}`);
     }
 }