@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/workspace.js

@@ -1,14 +1,14 @@
-import { isAbsolute, relative, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { mediaHistory } from "./media-history.js";
-import { MaybeCodeUsageError } from "./errors.js";
 import { parsePermissionMode } from "./policy.js";
-import { AgentWorkspace } from "@sortedyuan/application";
-import { observabilityService } from "@sortedyuan/plugin-observability";
-import { GitCheckpointError, GitWorkspaceConflictError, ProjectGitWorkspace } from "@sortedyuan/application/git-workspace";
-import { AsyncEventQueue, RunCancelledError, isStreamingMayEvent, } from "@sortedyuan/core";
+import { observabilityService } from "@sortedyuan/observability/plugin";
+import { GitCheckpointError, GitWorkspaceConflictError, } from "@sortedyuan/may/application/git-workspace";
+import { AsyncEventQueue, RunCancelledError, isStreamingMayEvent, omitUndefined, } from "@sortedyuan/may/core";
 import { mcpResourceToUserMessage, mcpPromptToUserMessage, mcpTaskToUserMessage, } from "@sortedyuan/mcp";
-import { MaybeCodeApplication, } from "./application.js";
+import { GOAL_STATE_KEY } from "@sortedyuan/may/goals";
+import { openWorkspaceConfiguration } from "./workspace-configuration.js";
+import { unknownReasoningEffort, withModelConfiguration } from "./model-transition.js";
+import { workspaceForkPoints } from "./session-navigation.js";
 /** MaybeCode model policy around the reusable multi-session workspace. */
 export class MaybeCodeWorkspace {
     events;
@@ -16,7 +16,7 @@ export class MaybeCodeWorkspace {
     state;
     eventQueue = new AsyncEventQueue({
         maxBufferedValues: 1024,
-        isDroppable: (event) => event.type === "mcp.resource.updated" || event.type === "run.event" && isStreamingMayEvent(event.event),
+        isDroppable: (event) => event.type === "mcp.resource.updated" || (event.type === "run.event" && isStreamingMayEvent(event.event)),
     });
     managerEventRelay;
     mcpEventRelays = new Set();
@@ -43,79 +43,7 @@ export class MaybeCodeWorkspace {
         this.connectMcpEvents();
     }
     static async open(options) {
-        if (options.delegationNotifications !== undefined && typeof options.delegationNotifications !== "boolean") {
-            throw new TypeError("delegationNotifications must be boolean");
-        }
-        const state = {
-            rootWorkspace: resolve(options.workspace),
-            git: new Map(),
-            createdSessions: new Map(),
-            options: withoutSelection({
-                ...options,
-                permissionMode: parsePermissionMode(options.permissionMode ?? "default"),
-                workspace: resolve(options.workspace),
-            }),
-        };
-        if (state.options.git !== false)
-            state.git.set(state.rootWorkspace, await ProjectGitWorkspace.open({
-                ...state.options.git, workspace: state.rootWorkspace, deferInitialization: true,
-                excludedPaths: [...(state.options.git?.excludedPaths ?? []), ...workspaceStoragePaths(state.options, state.rootWorkspace)],
-            }));
-        const manager = await AgentWorkspace.open({
-            workspace: state.options.workspace,
-            store: state.options.store,
-            catalog: state.options.catalog,
-            workspacePaths: async () => [state.rootWorkspace, ...((await state.git.get(state.rootWorkspace)?.listWorktrees()) ?? [])
-                    .filter(tree => tree.status !== "deleted").map(tree => tree.workspace)],
-            openApplication: async (selection) => {
-                const workspace = selection.workspace ?? state.options.workspace;
-                if (workspace !== state.options.workspace && (state.options.tools || state.options.additionalTools || state.options.toolSource) && !state.options.configureWorkspace) {
-                    throw new Error("Custom workspace tools require configureWorkspace before creating or opening a worktree");
-                }
-                const configured = await state.options.configureWorkspace?.(workspace);
-                let gitWorkspace = state.git.get(workspace);
-                if (state.options.git !== false && !gitWorkspace) {
-                    gitWorkspace = await ProjectGitWorkspace.open({ ...state.options.git, workspace, deferInitialization: true,
-                        excludedPaths: [...(state.options.git?.excludedPaths ?? []), ...workspaceStoragePaths(state.options, workspace)] });
-                    state.git.set(workspace, gitWorkspace);
-                }
-                let nextOptions = { ...state.options, ...configured, workspace,
-                    modelRuntimeOptions: state.options.modelRuntimeOptions ?? configuredModelOptions(state.options, state.options.modelInfo?.profile) };
-                if (selection.fork) {
-                    if (!state.options.store.inspect)
-                        throw new Error("Historical model selection requires read-only Session inspection");
-                    const history = await state.options.store.inspect(selection.fork.sessionId);
-                    const event = [...history].reverse().find(item => item.seq <= selection.fork.positionSeq && item.type === "state.updated" && item.key === "maybecode.model");
-                    if (event?.type === "state.updated") {
-                        const saved = readHistoricalModel(event.value);
-                        if (saved.profile && nextOptions.createModelConfiguration) {
-                            const configuration = await nextOptions.createModelConfiguration(saved.profile, saved.runtimeOptions);
-                            assertHistoricalModel(saved, configuration.modelInfo);
-                            nextOptions = withModelConfiguration(nextOptions, configuration, saved.runtimeOptions);
-                        }
-                        else {
-                            assertHistoricalModel(saved, nextOptions.modelInfo);
-                            nextOptions = { ...nextOptions, modelRuntimeOptions: saved.runtimeOptions };
-                        }
-                    }
-                }
-                const app = await MaybeCodeApplication.open({ ...applicationOptions(nextOptions, state),
-                    ...(gitWorkspace ? { gitWorkspace } : {}),
-                    ...(selection.fork ? { fork: selection.fork } : {}),
-                    ...(selection.metadata ? { sessionMetadata: selection.metadata } : {}),
-                    ...(selection.sessionId ? { sessionId: selection.sessionId } : {}), resume: selection.resume });
-                state.options = nextOptions;
-                if (!selection.resume && !selection.fork)
-                    state.createdSessions.set(app.sessionId, workspace);
-                return app;
-            },
-            ...(options.sessionId === undefined
-                ? {}
-                : { sessionId: options.sessionId }),
-            ...(options.autoResume === undefined
-                ? {}
-                : { autoResume: options.autoResume }),
-        });
+        const { state, manager } = await openWorkspaceConfiguration(options);
         const product = new MaybeCodeWorkspace(state, manager);
         await product.syncWorktreeProcess();
         return product;
@@ -123,86 +51,85 @@ export class MaybeCodeWorkspace {
     get sessionId() {
         return this.manager.sessionId;
     }
-    get workspace() { return this.manager.workspace; }
-    get git() { return this.state.git.get(this.workspace); }
+    get workspace() {
+        return this.manager.workspace;
+    }
+    /** Application of the active Session; a Session change replaces it. */
+    get application() {
+        return this.manager.activeApplication;
+    }
+    /** Run a state change on the Session queue of the active application. */
+    transition(action, options) {
+        return this.manager.runStateTransition(action, options);
+    }
+    get git() {
+        return this.state.git.get(this.workspace);
+    }
     async getWorkspaceGit() {
         if (!this.git)
             return { path: this.workspace, status: "disabled", autoCommit: false };
         try {
             const status = await this.git.summary();
-            return { path: this.workspace, status: status.state === "unborn" || status.state === "unmanaged" && status.autoCommit && !status.readOnly ? "initializing" : status.state === "unmanaged" ? "disabled" : "ready",
-                autoCommit: status.autoCommit && !status.readOnly, detached: status.detached,
-                ...(status.branch ? { branch: status.branch } : {}), ...(status.commit ? { commit: status.commit } : {}) };
+            return {
+                path: this.workspace,
+                status: status.state === "unborn" || (status.state === "unmanaged" && status.autoCommit && !status.readOnly)
+                    ? "initializing"
+                    : status.state === "unmanaged"
+                        ? "disabled"
+                        : "ready",
+                autoCommit: status.autoCommit && !status.readOnly,
+                detached: status.detached,
+                ...(status.branch ? { branch: status.branch } : {}),
+                ...(status.commit ? { commit: status.commit } : {}),
+            };
         }
         catch (error) {
-            return { path: this.workspace, status: "error", autoCommit: this.git.autoCommit, error: error instanceof Error ? error.message : String(error) };
+            return {
+                path: this.workspace,
+                status: "error",
+                autoCommit: this.git.autoCommit,
+                error: error instanceof Error ? error.message : String(error),
+            };
         }
     }
     async getForkPoints(sessionId) {
-        const nodes = await this.manager.readSessionBranchTree();
-        const checkpoints = await this.git?.checkpoints() ?? [];
-        const sessions = await this.listSessions();
-        const worktrees = await this.git?.listWorktrees() ?? [];
-        const checkpointFor = (sourceId, runId) => {
-            const seen = new Set();
-            while (!seen.has(sourceId)) {
-                seen.add(sourceId);
-                const checkpoint = [...checkpoints].reverse().find(item => item.sessionId === sourceId && (item.runId === runId || item.runIds?.includes(runId)));
-                if (checkpoint)
-                    return checkpoint;
-                const source = nodes.find(node => node.sessionId === sourceId)?.fork;
-                if (!source)
-                    return undefined;
-                sourceId = source.sessionId;
-            }
-            throw new Error("Session branch lineage contains a cycle");
-        };
-        return nodes.flatMap(node => {
-            if (sessionId && node.sessionId !== sessionId)
-                return [];
-            const workspace = sessions.find(session => session.id === node.sessionId)?.workspace;
-            const worktree = worktrees.find(tree => tree.workspace === workspace);
-            const workspaceReady = worktree === undefined || worktree.status === "ready";
-            return node.positions.map((position, index) => {
-                const checkpoint = checkpointFor(node.sessionId, position.runId);
-                const completeRequest = checkpoint?.runIds?.length ? checkpoint.runId === position.runId : true;
-                const parent = index ? node.positions[index - 1] : undefined;
-                return { id: `${node.sessionId}:${position.positionSeq}`, sessionId: node.sessionId, runId: position.runId,
-                    createdAt: position.timestamp, userPreview: position.request, assistantPreview: position.response,
-                    available: position.available && completeRequest && workspaceReady,
-                    ...(!workspaceReady ? { reason: "The managed worktree did not finish initialization; inspect its diagnostic" } :
-                        !completeRequest ? { reason: "The selected Run belongs to an unfinished part of this request" } : position.reason ? { reason: position.reason } : {}),
-                    ...(parent ? { parentPointId: `${node.sessionId}:${parent.positionSeq}` } : node.fork ? { parentPointId: `${node.fork.sessionId}:${node.fork.positionSeq}` } : {}),
-                    ...(checkpoint?.commit ? { commit: checkpoint.commit } : {}), ...(checkpoint?.branch ? { branch: checkpoint.branch } : {}),
-                    worktreeAvailable: position.available && completeRequest && workspaceReady && this.git?.readOnly !== true && checkpoint?.commit !== undefined && ["committed", "unchanged"].includes(checkpoint.status) };
-            });
-        });
+        return workspaceForkPoints(this.manager, () => this.git, () => this.listSessions(), sessionId);
     }
     async forkSession(pointId, mode) {
         return this.runWorkspaceOperation(() => this.forkWorkspaceSession(pointId, mode));
     }
     async forkWorkspaceSession(pointId, mode) {
-        const point = (await this.getForkPoints()).find(item => item.id === pointId);
+        const point = (await this.getForkPoints()).find((item) => item.id === pointId);
         if (!point?.available)
             throw new Error(point?.reason ?? "Session history position is unavailable");
         const positionSeq = Number(point.id.slice(point.sessionId.length + 1));
         const git = this.git;
         const checkpoint = await this.checkpointForRun(point.sessionId, point.runId);
-        const sourceWorkspace = (await this.listSessions()).find(session => session.id === point.sessionId)?.workspace;
+        const sourceWorkspace = (await this.listSessions()).find((session) => session.id === point.sessionId)?.workspace;
         if (!sourceWorkspace)
             throw new Error("Source Session workspace is unavailable");
         let tree;
         if (mode === "worktree") {
             if (!git || !checkpoint?.commit || !point.worktreeAvailable)
                 throw new Error("Selected reply has no complete Git checkpoint");
-            tree = await git.createWorktree({ sessionId: point.sessionId, historyPosition: positionSeq, checkpointId: checkpoint.id });
+            tree = await git.createWorktree({
+                sessionId: point.sessionId,
+                historyPosition: positionSeq,
+                checkpointId: checkpoint.id,
+            });
         }
         let sessionId;
         try {
             sessionId = await this.manager.forkSession(point.sessionId, positionSeq, {
                 ...(tree ? { workspace: tree.workspace } : {}),
-                metadata: { workspaceFork: { mode, sourceWorkspace, sourceCommit: point.commit ?? null,
-                        ...(tree ? { worktreeId: tree.id } : { currentFiles: true }) } },
+                metadata: {
+                    workspaceFork: {
+                        mode,
+                        sourceWorkspace,
+                        sourceCommit: point.commit ?? null,
+                        ...(tree ? { worktreeId: tree.id } : { currentFiles: true }),
+                    },
+                },
             });
             if (tree)
                 await git.attachWorktreeSession(tree.id, sessionId);
@@ -218,7 +145,7 @@ export class MaybeCodeWorkspace {
     }
     async getCheckpoints(sessionId = this.sessionId) {
         const points = await this.getForkPoints(sessionId);
-        const checkpoints = await this.git?.checkpoints() ?? [];
+        const checkpoints = (await this.git?.checkpoints()) ?? [];
         const sourceIds = [sessionId];
         while (true) {
             const created = (await this.manager.readSessionHistory(sourceIds[sourceIds.length - 1]))[0];
@@ -227,21 +154,31 @@ export class MaybeCodeWorkspace {
             if (sourceIds.includes(created.fork.sessionId))
                 throw new Error("Session branch lineage contains a cycle");
             sourceIds.push(created.fork.sessionId);
-            if (!(await this.listSessions()).some(session => session.id === created.fork.sessionId))
+            if (!(await this.listSessions()).some((session) => session.id === created.fork.sessionId))
                 break;
         }
-        return points.map(point => {
+        return points.map((point) => {
             let checkpoint;
             for (const sourceId of sourceIds) {
-                checkpoint = [...checkpoints].reverse().find(item => item.sessionId === sourceId && (item.runId === point.runId || item.runIds?.includes(point.runId)));
+                checkpoint = [...checkpoints]
+                    .reverse()
+                    .find((item) => item.sessionId === sourceId && (item.runId === point.runId || item.runIds?.includes(point.runId)));
                 if (checkpoint)
                     break;
             }
-            return { runId: point.runId, pointId: point.id,
-                ...(checkpoint?.fromCommit ? { startCommit: checkpoint.fromCommit } : {}), ...(checkpoint?.commit ? { endCommit: checkpoint.commit } : {}),
+            return {
+                runId: point.runId,
+                pointId: point.id,
+                ...(checkpoint?.fromCommit ? { startCommit: checkpoint.fromCommit } : {}),
+                ...(checkpoint?.commit ? { endCommit: checkpoint.commit } : {}),
                 ...(checkpoint?.branch ? { branch: checkpoint.branch } : {}),
-                status: checkpoint?.status === "failed" ? "failed" : !checkpoint || checkpoint.status === "uncommitted" ? "unavailable" : "saved",
-                ...(checkpoint?.error ? { error: checkpoint.error } : {}), };
+                status: checkpoint?.status === "failed"
+                    ? "failed"
+                    : !checkpoint || checkpoint.status === "uncommitted"
+                        ? "unavailable"
+                        : "saved",
+                ...(checkpoint?.error ? { error: checkpoint.error } : {}),
+            };
         });
     }
     async checkpointForRun(sessionId, runId) {
@@ -261,20 +198,28 @@ export class MaybeCodeWorkspace {
         throw new Error("Session branch lineage contains a cycle");
     }
     async getWorktrees() {
-        return ((await this.git?.listWorktrees()) ?? []).filter(tree => tree.status !== "deleted").map(tree => ({
-            id: tree.id, path: tree.workspace, branch: tree.branch, sourceSessionId: tree.sourceSessionId,
-            pointId: `${tree.sourceSessionId}:${tree.historyPosition}`, commit: tree.commit, sessionIds: tree.sessions,
-            status: tree.status === "failed" ? "error" : tree.status === "creating" ? "creating" : "ready", ...(tree.error ? { error: tree.error } : {}),
+        return ((await this.git?.listWorktrees()) ?? [])
+            .filter((tree) => tree.status !== "deleted")
+            .map((tree) => ({
+            id: tree.id,
+            path: tree.workspace,
+            branch: tree.branch,
+            sourceSessionId: tree.sourceSessionId,
+            pointId: `${tree.sourceSessionId}:${tree.historyPosition}`,
+            commit: tree.commit,
+            sessionIds: tree.sessions,
+            status: tree.status === "failed" ? "error" : tree.status === "creating" ? "creating" : "ready",
+            ...(tree.error ? { error: tree.error } : {}),
         }));
     }
     async openWorktree(id) {
         return this.runWorkspaceOperation(() => this.openWorkspaceWorktree(id));
     }
     async openWorkspaceWorktree(id) {
-        const tree = (await this.getWorktrees()).find(item => item.id === id);
+        const tree = (await this.getWorktrees()).find((item) => item.id === id);
         if (!tree || tree.status !== "ready")
             throw new Error("Managed worktree is unavailable");
-        const session = (await this.listSessions()).find(item => tree.sessionIds.includes(item.id));
+        const session = (await this.listSessions()).find((item) => tree.sessionIds.includes(item.id));
         if (!session)
             throw new Error("Worktree has no available Session");
         await this.resumeWorkspaceSession(session.id);
@@ -284,13 +229,13 @@ export class MaybeCodeWorkspace {
     }
     async deleteWorkspaceWorktree(id) {
         const git = this.requireGit();
-        const tree = (await git.listWorktrees()).find(item => item.id === id);
+        const tree = (await git.listWorktrees()).find((item) => item.id === id);
         if (!tree)
             throw new Error("Managed worktree is unavailable");
         if (tree.workspace === this.workspace)
             throw new Error("Switch to another workspace before deleting this worktree");
         for (const sessionId of tree.sessions) {
-            if ((await this.listSessions()).some(session => session.id === sessionId))
+            if ((await this.listSessions()).some((session) => session.id === sessionId))
                 throw new Error("Delete or move associated Sessions before deleting this worktree");
             await git.attachWorktreeSession(id, sessionId, false);
         }
@@ -318,11 +263,24 @@ export class MaybeCodeWorkspace {
         if (!from)
             throw new Error("Git comparison has no available initial version");
         const diff = await git.diff({ from, ...(to ? { to } : {}) });
-        const files = diff.files.map(file => ({ path: file.path, ...(file.previousPath ? { previousPath: file.previousPath } : {}),
+        const files = diff.files.map((file) => ({
+            path: file.path,
+            ...(file.previousPath ? { previousPath: file.previousPath } : {}),
             status: file.status === "typechanged" || file.status === "unknown" ? "modified" : file.status,
-            binary: file.binary, additions: file.insertions, deletions: file.deletions, patch: file.patch }));
-        return { scope: query.scope, title: query.scope === "run" ? "本轮文件变化" : query.scope === "session" ? "Session 文件变化" : "当前工作区文件变化",
-            from: diff.from, ...(diff.to ? { to: diff.to } : {}), ...(query.runId ? { runId: query.runId } : {}), uncommitted: !diff.to, files };
+            binary: file.binary,
+            additions: file.insertions,
+            deletions: file.deletions,
+            patch: file.patch,
+        }));
+        return {
+            scope: query.scope,
+            title: query.scope === "run" ? "本轮文件变化" : query.scope === "session" ? "Session 文件变化" : "当前工作区文件变化",
+            from: diff.from,
+            ...(diff.to ? { to: diff.to } : {}),
+            ...(query.runId ? { runId: query.runId } : {}),
+            uncommitted: !diff.to,
+            files,
+        };
     }
     async previewRestore(runId, paths) {
         return this.runWorkspaceOperation(() => this.previewWorkspaceRestore(runId, paths));
@@ -338,21 +296,38 @@ export class MaybeCodeWorkspace {
         const previewId = randomUUID();
         this.restorePreviews.clear();
         this.restorePreviews.set(previewId, { sessionId: this.sessionId, preview });
-        return { previewId, diff: { scope: "run", runId, title: "文件恢复预览", to: preview.commit,
-                uncommitted: true, restorePreviewId: previewId, files: preview.files.map(file => ({
-                    path: file.path, status: file.targetMode === undefined ? "deleted" : file.beforeFingerprint === undefined ? "added" : "modified",
-                    binary: file.binary, additions: 0, deletions: 0, patch: file.patch,
-                })) } };
+        return {
+            previewId,
+            diff: {
+                scope: "run",
+                runId,
+                title: "文件恢复预览",
+                to: preview.commit,
+                uncommitted: true,
+                restorePreviewId: previewId,
+                files: preview.files.map((file) => ({
+                    path: file.path,
+                    status: file.targetMode === undefined ? "deleted" : file.beforeFingerprint === undefined ? "added" : "modified",
+                    binary: file.binary,
+                    additions: 0,
+                    deletions: 0,
+                    patch: file.patch,
+                })),
+            },
+        };
     }
     async restoreFiles(previewId) {
-        return this.runWorkspaceOperation(() => this.manager.runStateTransition(() => this.restoreWorkspaceFiles(previewId)));
+        return this.runWorkspaceOperation(() => this.transition(() => this.restoreWorkspaceFiles(previewId)));
     }
     async restoreWorkspaceFiles(previewId) {
         const saved = this.restorePreviews.get(previewId);
         if (!saved || saved.sessionId !== this.sessionId || saved.preview.workspace !== this.workspace)
             throw new Error("File restore preview is no longer available");
         try {
-            const checkpoint = await this.requireGit().restore(saved.preview, { sessionId: this.sessionId, commitMessage: "Restore selected files from a session checkpoint" });
+            const checkpoint = await this.requireGit().restore(saved.preview, {
+                sessionId: this.sessionId,
+                commitMessage: "Restore selected files from a session checkpoint",
+            });
             this.restorePreviews.delete(previewId);
             this.eventQueue.push({ type: "workspace.git.changed", checkpoint });
         }
@@ -369,7 +344,7 @@ export class MaybeCodeWorkspace {
     }
     assertWorkspaceIdle() {
         this.throwIfClosed();
-        if (this.isRunning || this.getGoal()?.status === "active" || this.getMcpInteractions().length)
+        if (this.isRunning || this.application.getGoal()?.status === "active" || this.getMcpInteractions().length)
             throw new Error("Finish the active operation before changing the workspace");
     }
     assertNoWorkspaceOperation() {
@@ -382,24 +357,28 @@ export class MaybeCodeWorkspace {
             this.assertWorkspaceIdle();
         else
             this.assertNoWorkspaceOperation();
-        if (this.getGoal()?.status === "active")
+        if (this.application.getGoal()?.status === "active")
             throw new GitWorkspaceConflictError("Pause or finish the active Goal before changing the workspace");
         const previousSessionId = this.sessionId;
         const previousOptions = this.state.options;
-        const operation = Promise.resolve().then(work).catch(error => {
+        const operation = Promise.resolve()
+            .then(work)
+            .catch((error) => {
             if (this.sessionId === previousSessionId)
                 this.state.options = previousOptions;
             throw error;
         });
         this.workspaceOperation = operation;
-        return operation.finally(() => { if (this.workspaceOperation === operation)
-            this.workspaceOperation = undefined; });
+        return operation.finally(() => {
+            if (this.workspaceOperation === operation)
+                this.workspaceOperation = undefined;
+        });
     }
     async syncWorktreeProcess() {
         const git = this.state.git.get(this.state.rootWorkspace);
         if (!git || git.readOnly)
             return;
-        const tree = (await git.listWorktrees()).find(item => item.workspace === this.workspace && item.status === "ready");
+        const tree = (await git.listWorktrees()).find((item) => item.workspace === this.workspace && item.status === "ready");
         if (this.worktreeProcessId && this.worktreeProcessId !== tree?.id)
             await git.trackWorktreeProcess(this.worktreeProcessId, process.pid, false);
         this.worktreeProcessId = tree?.id;
@@ -424,10 +403,10 @@ export class MaybeCodeWorkspace {
         this.assertNoWorkspaceOperation();
         this.throwIfClosed();
         parsePermissionMode(mode);
-        await this.manager.runStateTransition(() => {
+        await this.transition(() => {
             if (mode === this.permissionMode)
                 return;
-            if (this.isRunning || this.getGoal()?.status === "active" || this.getMcpInteractions().length > 0) {
+            if (this.isRunning || this.application.getGoal()?.status === "active" || this.getMcpInteractions().length > 0) {
                 throw new Error("Pause or cancel the current operation before changing permission mode");
             }
             this.state.options = { ...this.state.options, permissionMode: mode };
@@ -435,48 +414,37 @@ export class MaybeCodeWorkspace {
         }, { activeOperationMessage: "Pause or cancel the current operation before changing permission mode" });
     }
     get isRunning() {
-        return this.workspaceOperation !== undefined || this.manager.isRunning || this.mcpOperationController !== undefined || this.pendingInputs.size > 0 || this.pendingSteering > 0;
+        return (this.workspaceOperation !== undefined ||
+            this.manager.isRunning ||
+            this.mcpOperationController !== undefined ||
+            this.pendingInputs.size > 0 ||
+            this.pendingSteering > 0);
     }
-    get instructions() {
-        return this.manager.activeApplication.instructions;
-    }
-    listSkills() {
-        const skills = this.manager.activeApplication.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) }));
-    }
-    getSkillDiagnostics() { return this.manager.activeApplication.skills?.registry.diagnostics ?? []; }
     readSkill(name) {
         this.assertNoWorkspaceOperation();
-        return this.manager.runStateTransition(async (app) => {
-            if (!app.skills)
+        return this.transition(async ({ agent }) => {
+            if (!agent.skills)
                 throw new Error("Skills are disabled");
-            return app.skills.listActive().find((item) => item.name === name) ?? app.skills.registry.load(name);
+            return agent.skills.listActive().find((item) => item.name === name) ?? agent.skills.registry.load(name);
         }, { requireIdle: false });
     }
     activateSkill(name) {
         this.assertNoWorkspaceOperation();
-        return this.manager.runStateTransition((app) => app.activateSkill(name));
+        return this.transition((app) => app.activateSkill(name));
     }
     submitSkill(name, input) {
         this.assertNoWorkspaceOperation();
         return this.manager.submitPrepared(async () => {
-            await this.manager.activeApplication.activateSkill(name);
+            await this.application.activateSkill(name);
             return { input: `Use the ${name} skill for this task:\n${input}` };
         });
     }
-    get modelInfo() {
-        return this.manager.activeApplication.modelInfo;
-    }
     async getMcpStatus() {
         this.throwIfClosed();
         return this.mcp?.status() ?? [];
     }
     get mcp() {
-        return this.manager.activeApplication.mcp ?? this.state.options.mcp;
+        return this.application.mcp ?? this.state.options.mcp;
     }
     getMcpInteractions() {
         const interactions = this.mcp?.interactions;
@@ -495,13 +463,15 @@ export class MaybeCodeWorkspace {
         const request = this.getMcpInteractions().find((entry) => entry.id === id);
         return request === undefined ? false : this.mcp.interactions.respond(id, request.owner, response);
     }
-    mcpOwner() { return { workspaceId: this.workspace, sessionId: this.sessionId }; }
+    mcpOwner() {
+        return { workspaceId: this.workspace, sessionId: this.sessionId };
+    }
     /** 活动请求的子 Session 保留自己的 MCP 身份与授权记录。 */
     delegatedSessions() {
-        return this.manager.activeApplication.ownedDelegatedSessions();
+        return this.application.ownedDelegatedSessions();
     }
     ownsSession(sessionId) {
-        return sessionId === this.sessionId || this.manager.activeApplication.ownsSession(sessionId);
+        return sessionId === this.sessionId || this.application.ownsSession(sessionId);
     }
     async refreshMcp(serverId) {
         this.assertNoWorkspaceOperation();
@@ -528,45 +498,52 @@ export class MaybeCodeWorkspace {
         return this.mcp?.listTasks?.(this.mcpOwner()) ?? Promise.resolve([]);
     }
     getMcpTask(serverId, id, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("getTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("getTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     updateMcpTask(serverId, id, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("updateTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("updateTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     waitMcpTask(serverId, id, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("waitTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("waitTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     cancelMcpTask(serverId, id, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("cancelTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("cancelTask")(serverId, id, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     forgetMcpTask(serverId, id) {
-        return this.mcpOperation(() => this.manager.runStateTransition(() => this.mcpMethod("forgetTask")(serverId, id, this.mcpOwner())));
+        return this.mcpOperation(() => this.transition(() => this.mcpMethod("forgetTask")(serverId, id, this.mcpOwner())));
     }
     submitMcpTask(serverId, id, instruction) {
         return this.mcpOperation((signal) => this.manager.submitPrepared(async () => ({
-            input: mcpTaskToUserMessage(await this.mcpMethod("getTask")(serverId, id, { signal, owner: this.mcpOwner() }), instruction), signal,
+            input: mcpTaskToUserMessage(await this.mcpMethod("getTask")(serverId, id, { signal, owner: this.mcpOwner() }), instruction),
+            signal,
         })));
     }
     readMcpResource(serverId, uri, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("readResource")(serverId, uri, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("readResource")(serverId, uri, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     readMcpResourceTemplate(serverId, template, variables, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("readResourceTemplate")(serverId, template, variables, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("readResourceTemplate")(serverId, template, variables, {
+            ...options,
+            signal,
+            owner: this.mcpOwner(),
+        })), options.signal);
     }
     getMcpPrompt(serverId, name, args, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("getPrompt")(serverId, name, args, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("getPrompt")(serverId, name, args, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     completeMcp(serverId, params, options = {}) {
-        return this.mcpOperation((signal) => this.manager.runStateTransition(() => this.mcpMethod("complete")(serverId, params, { ...options, signal, owner: this.mcpOwner() })), options.signal);
+        return this.mcpOperation((signal) => this.transition(() => this.mcpMethod("complete")(serverId, params, { ...options, signal, owner: this.mcpOwner() })), options.signal);
     }
     submitMcpResource(serverId, uri, instruction) {
         return this.mcpOperation((signal) => this.manager.submitPrepared(async () => ({
-            input: mcpResourceToUserMessage(await this.mcpMethod("readResource")(serverId, uri, { signal, owner: this.mcpOwner() }), instruction), signal,
+            input: mcpResourceToUserMessage(await this.mcpMethod("readResource")(serverId, uri, { signal, owner: this.mcpOwner() }), instruction),
+            signal,
         })));
     }
     submitMcpPrompt(serverId, name, args) {
         return this.mcpOperation((signal) => this.manager.submitPrepared(async () => ({
-            input: mcpPromptToUserMessage(await this.mcpMethod("getPrompt")(serverId, name, args, { signal, owner: this.mcpOwner() })), signal,
+            input: mcpPromptToUserMessage(await this.mcpMethod("getPrompt")(serverId, name, args, { signal, owner: this.mcpOwner() })),
+            signal,
         })));
     }
     watchMcpResource(serverId, uri) {
@@ -577,7 +554,7 @@ export class MaybeCodeWorkspace {
                 return this.mcpWatches.get(key);
             const watch = await this.mcpMethod("subscribeResource")(serverId, uri, { signal, owner: this.mcpOwner() });
             this.mcpWatches.set(key, watch);
-            void (async () => {
+            this.trackMcpRelay((async () => {
                 for await (const event of watch.events) {
                     if (!this.closed && owner.workspaceId === this.workspace && owner.sessionId === this.sessionId)
                         this.eventQueue.push({ type: "mcp.resource.updated", serverId, uri: event.uri });
@@ -587,7 +564,7 @@ export class MaybeCodeWorkspace {
                     this.mcpWatches.delete(key);
                 if (!this.closed && owner.workspaceId === this.workspace && owner.sessionId === this.sessionId)
                     this.eventQueue.push({ type: "mcp.resource.watch-closed", serverId, uri, reason });
-            })();
+            })());
             return watch;
         });
     }
@@ -607,7 +584,11 @@ export class MaybeCodeWorkspace {
             throw new Error("Cannot start an MCP user operation while another operation is active");
         const controller = new AbortController();
         this.mcpOperationController = controller;
-        const signal = AbortSignal.any([controller.signal, this.mcpLifetime.signal, ...(external === undefined ? [] : [external])]);
+        const signal = AbortSignal.any([
+            controller.signal,
+            this.mcpLifetime.signal,
+            ...(external === undefined ? [] : [external]),
+        ]);
         try {
             signal.throwIfAborted();
             return await work(signal);
@@ -622,7 +603,10 @@ export class MaybeCodeWorkspace {
         const controller = new AbortController();
         this.pendingInputs.add(controller);
         try {
-            return await this.manager.submit({ ...options, signal: options.signal === undefined ? controller.signal : AbortSignal.any([controller.signal, options.signal]) });
+            return await this.manager.submit({
+                ...options,
+                signal: options.signal === undefined ? controller.signal : AbortSignal.any([controller.signal, options.signal]),
+            });
         }
         finally {
             this.pendingInputs.delete(controller);
@@ -633,7 +617,7 @@ export class MaybeCodeWorkspace {
         const epoch = this.inputEpoch;
         this.pendingSteering++;
         try {
-            return await this.manager.runStateTransition(app => {
+            return await this.transition((app) => {
                 if (epoch !== this.inputEpoch)
                     throw new RunCancelledError("Input cancelled before acceptance");
                 return app.steer(options);
@@ -643,15 +627,20 @@ export class MaybeCodeWorkspace {
             this.pendingSteering--;
         }
     }
-    listSteeringInputs() { return this.manager.activeApplication.listSteeringInputs(); }
-    getGoal() { return this.manager.activeApplication.getGoal(); }
     startGoal(objective, budget) {
         this.assertNoWorkspaceOperation();
-        return this.manager.runStateTransition(app => app.startGoal(objective, budget));
+        return this.transition((app) => app.startGoal(objective, budget));
+    }
+    resumeGoal() {
+        this.assertNoWorkspaceOperation();
+        return this.transition((app) => app.resumeGoal());
+    }
+    pauseGoal() {
+        return this.transition((app) => app.pauseGoal(), { requireIdle: false });
+    }
+    cancelGoal() {
+        return this.transition((app) => app.cancelGoal(), { requireIdle: false });
     }
-    resumeGoal() { this.assertNoWorkspaceOperation(); return this.manager.runStateTransition(app => app.resumeGoal()); }
-    pauseGoal() { return this.manager.runStateTransition(app => app.pauseGoal(), { requireIdle: false }); }
-    cancelGoal() { return this.manager.runStateTransition(app => app.cancelGoal(), { requireIdle: false }); }
     retry() {
         this.assertNoWorkspaceOperation();
         return this.manager.retry();
@@ -667,15 +656,24 @@ export class MaybeCodeWorkspace {
     resolveApproval(requestId, decision, options) {
         return this.manager.resolveApproval(requestId, decision, options);
     }
-    get persistentRulesEnabled() { return this.manager.activeApplication.persistentRulesEnabled; }
-    listPermissionRules(scopeId) { return this.manager.listPermissionRules(scopeId); }
-    createPermissionRule(check, options) { return this.manager.createPermissionRule(check, options); }
-    createPermissionRuleFrom(id, options) { return this.manager.runStateTransition(app => app.createPermissionRuleFrom(id, options)); }
-    revokePermissionRule(id) { return this.manager.revokePermissionRule(id); }
+    listPermissionRules(scopeId) {
+        return this.manager.listPermissionRules(scopeId);
+    }
+    createPermissionRule(check, options) {
+        return this.manager.createPermissionRule(check, options);
+    }
+    createPermissionRuleFrom(id, options) {
+        return this.transition((app) => app.createPermissionRuleFrom(id, options));
+    }
+    revokePermissionRule(id) {
+        return this.manager.revokePermissionRule(id);
+    }
     listSessions() {
         return this.manager.listSessions();
     }
-    async readSessionHistory(sessionId) { return mediaHistory(await this.manager.readSessionHistory(sessionId)); }
+    async readSessionHistory(sessionId) {
+        return mediaHistory(await this.manager.readSessionHistory(sessionId));
+    }
     async newSession() {
         return this.runWorkspaceOperation(() => this.newWorkspaceSession(), false);
     }
@@ -719,7 +717,7 @@ export class MaybeCodeWorkspace {
         const selected = (this.state.options.modelProfiles ?? []).find((candidate) => candidate.name === profile);
         if (selected === undefined)
             throw new Error(`Unknown model profile "${profile}"`);
-        const result = await this.manager.runStateTransition(async (current) => {
+        const result = await this.transition(async (current) => {
             if (current.modelInfo?.profile === profile && !current.modelUpdateFailed) {
                 this.manager.emit({ type: "model.changed", model: current.modelInfo });
                 return current.modelInfo;
@@ -738,7 +736,7 @@ export class MaybeCodeWorkspace {
             this.assertModelChangeAllowed();
             await current.updateModel({
                 ...configuration,
-                ...(nextOptions.modelRuntimeOptions === undefined ? {} : { modelRuntimeOptions: nextOptions.modelRuntimeOptions }),
+                ...omitUndefined({ modelRuntimeOptions: nextOptions.modelRuntimeOptions }),
             });
             this.state.options = nextOptions;
             this.manager.emit({ type: "model.changed", model: current.modelInfo });
@@ -757,7 +755,7 @@ export class MaybeCodeWorkspace {
     setDefaultModel(profile) {
         this.assertNoWorkspaceOperation();
         this.throwIfClosed();
-        return this.manager.runStateTransition(async () => {
+        return this.transition(async () => {
             const profiles = this.state.options.modelProfiles ?? [];
             if (!profiles.some((candidate) => candidate.name === profile)) {
                 throw new Error(`Unknown model profile "${profile}"`);
@@ -779,7 +777,7 @@ export class MaybeCodeWorkspace {
     }
     async getReasoningEffort() {
         this.throwIfClosed();
-        const profile = this.modelInfo?.profile;
+        const profile = this.application.modelInfo?.profile;
         if (profile === undefined)
             return unknownReasoningEffort();
         const resolveCapabilities = this.state.options.resolveModelCapabilities;
@@ -793,45 +791,42 @@ export class MaybeCodeWorkspace {
         const overridden = typeof override === "string" && (override !== configured || requested === override);
         const effectiveEffort = typeof override === "string"
             ? override
-            : configured ?? (capabilities.status === "known"
-                ? capabilities.defaultEffort
-                : undefined);
+            : (configured ?? (capabilities.status === "known" ? capabilities.defaultEffort : undefined));
         return {
             status: capabilities.status,
             source: capabilities.source,
-            efforts: capabilities.status === "known"
-                ? [...capabilities.efforts]
-                : [],
-            ...(capabilities.status === "known" &&
-                capabilities.defaultEffort !== undefined
-                ? { defaultEffort: capabilities.defaultEffort }
-                : {}),
-            ...(effectiveEffort === undefined ? {} : { effectiveEffort }),
+            efforts: capabilities.status === "known" ? [...capabilities.efforts] : [],
+            ...omitUndefined({
+                defaultEffort: capabilities.status === "known" ? capabilities.defaultEffort : undefined,
+                effectiveEffort,
+            }),
             overridden,
         };
     }
-    async getModelCapabilities(profile = this.modelInfo?.profile, refresh = false) {
+    async getModelCapabilities(profile = this.application.modelInfo?.profile, refresh = false) {
         if (profile === undefined || this.state.options.resolveModelCapabilities === undefined) {
             throw new Error("The active workspace does not provide model capability discovery");
         }
-        if (!(this.state.options.modelProfiles ?? []).some(model => model.name === profile)) {
+        if (!(this.state.options.modelProfiles ?? []).some((model) => model.name === profile)) {
             throw new Error(`Unknown model profile: ${profile}`);
         }
         return this.state.options.resolveModelCapabilities(profile, { refresh });
     }
     get modelCapabilitiesAvailable() {
-        return this.modelInfo?.profile !== undefined && this.state.options.resolveModelCapabilities !== undefined;
+        return (this.application.modelInfo?.profile !== undefined && this.state.options.resolveModelCapabilities !== undefined);
     }
     getTelemetry(query = {}) {
         const sessionId = query.sessionId ?? this.sessionId;
         if (!this.ownsSession(sessionId))
             throw new Error("Telemetry session does not belong to this workspace");
-        return this.manager.activeApplication.getOptionalService(observabilityService)?.diagnostics?.getDiagnostics({ ...query, sessionId });
+        return this.application.agent
+            .getOptionalService(observabilityService)
+            ?.diagnostics?.getDiagnostics({ ...query, sessionId });
     }
     async setReasoningEffort(effort) {
         this.assertNoWorkspaceOperation();
         this.throwIfClosed();
-        await this.manager.runStateTransition(async (current) => {
+        await this.transition(async (current) => {
             this.assertModelChangeAllowed();
             const profile = current.modelInfo?.profile;
             if (profile === undefined) {
@@ -859,7 +854,7 @@ export class MaybeCodeWorkspace {
             this.assertModelChangeAllowed();
             await current.updateModel({
                 ...configuration,
-                ...(nextOptions.modelRuntimeOptions === undefined ? {} : { modelRuntimeOptions: nextOptions.modelRuntimeOptions }),
+                ...omitUndefined({ modelRuntimeOptions: nextOptions.modelRuntimeOptions }),
             });
             this.state.options = nextOptions;
             if (effort === undefined)
@@ -874,20 +869,16 @@ export class MaybeCodeWorkspace {
     async history() {
         return mediaHistory(await this.manager.history());
     }
-    listRecoveries() { return this.manager.listRecoveries(); }
-    resolveRecovery(id, finding) { this.assertNoWorkspaceOperation(); return this.manager.resolveRecovery(id, finding); }
-    listDelegationRequests() {
-        return this.manager.activeApplication.listDelegationRequests();
+    listRecoveries() {
+        return this.manager.listRecoveries();
     }
-    getDelegationState() {
-        return this.manager.activeApplication.getDelegationState();
-    }
-    delegationToolRecords(taskId) {
-        return this.manager.activeApplication.delegationToolRecords(taskId);
+    resolveRecovery(id, finding) {
+        this.assertNoWorkspaceOperation();
+        return this.manager.resolveRecovery(id, finding);
     }
     resolveDelegationRecovery(requestId, taskId, finding, outcome) {
         this.assertNoWorkspaceOperation();
-        return this.manager.activeApplication.resolveDelegationRecovery(requestId, taskId, finding, outcome);
+        return this.application.resolveDelegationRecovery(requestId, taskId, finding, outcome);
     }
     queryHistory(query) {
         return this.manager.queryHistory(query);
@@ -900,7 +891,7 @@ export class MaybeCodeWorkspace {
         return this.manager.compactContext(strategy);
     }
     close() {
-        return this.closing ??= this.closeOnce();
+        return (this.closing ??= this.closeOnce());
     }
     async closeOnce() {
         this.closed = true;
@@ -918,7 +909,9 @@ export class MaybeCodeWorkspace {
         }
         if (this.worktreeProcessId) {
             try {
-                await this.state.git.get(this.state.rootWorkspace).trackWorktreeProcess(this.worktreeProcessId, process.pid, false);
+                await this.state.git
+                    .get(this.state.rootWorkspace)
+                    .trackWorktreeProcess(this.worktreeProcessId, process.pid, false);
             }
             catch (error) {
                 failures.push(error);
@@ -930,7 +923,7 @@ export class MaybeCodeWorkspace {
         catch (error) {
             failures.push(error);
         }
-        await watchesClosing;
+        failures.push(...(await watchesClosing).flatMap((result) => (result.status === "rejected" ? [result.reason] : [])));
         try {
             await this.disconnectMcpEvents();
             await Promise.all([this.managerEventRelay, ...this.mcpEventRelays]);
@@ -950,9 +943,12 @@ export class MaybeCodeWorkspace {
         const { store, catalog } = this.state.options;
         for (const [sessionId, workspace] of this.state.createdSessions) {
             const history = await store.read(sessionId);
-            if (history.some(event => event.type === "input.submitted" ||
-                event.type === "input.steering.queued" || event.type === "run.started" ||
-                event.type === "assistant.completed" || event.type === "session.created" && event.fork !== undefined))
+            if (history.some((event) => event.type === "input.submitted" ||
+                event.type === "input.steering.queued" ||
+                event.type === "run.started" ||
+                event.type === "assistant.completed" ||
+                (event.type === "session.created" && event.fork !== undefined) ||
+                (event.type === "state.updated" && event.key === GOAL_STATE_KEY)))
                 continue;
             if (!store.delete || !catalog.remove)
                 throw new Error("Empty Session cleanup requires store and catalog deletion support");
@@ -1006,85 +1002,27 @@ export class MaybeCodeWorkspace {
         const iterators = [...this.mcpEventIterators];
         this.mcpEventIterators.clear();
         this.observedMcp = undefined;
-        const results = await Promise.allSettled(iterators.map(async (iterator) => { await iterator.return?.(); }));
-        const errors = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+        const results = await Promise.allSettled(iterators.map(async (iterator) => {
+            await iterator.return?.();
+        }));
+        const errors = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
         if (errors.length)
             throw new AggregateError(errors, "MCP event streams failed to close");
     }
     trackMcpRelay(operation) {
-        this.mcpEventRelays.add(operation);
-        void operation.then(() => this.mcpEventRelays.delete(operation), error => {
-            this.mcpEventRelays.delete(operation);
+        const task = operation.then(() => {
+            this.mcpEventRelays.delete(task);
+        }, (error) => {
+            this.mcpEventRelays.delete(task);
             this.mcpRelayErrors.push(error);
             if (!this.closed)
                 this.cancel("MCP event forwarding failed");
         });
+        this.mcpEventRelays.add(task);
     }
     throwIfClosed() {
         if (this.closed)
             throw new Error("MaybeCode workspace is closed");
     }
 }
-function withoutSelection(options) {
-    const { sessionId: _sessionId, autoResume: _autoResume, ...base } = options;
-    return base;
-}
-function workspaceStoragePaths(options, workspace) {
-    const store = options.store;
-    const catalog = options.catalog;
-    return [store.directory, catalog.path, resolve(workspace, ".may", "permission-rules.json"),
-        resolve(workspace, ".may", "permission-rules.json.lock")].filter((value) => {
-        if (typeof value !== "string")
-            return false;
-        const path = relative(workspace, resolve(value));
-        return path !== "" && path !== ".." && !path.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(path);
-    });
-}
-function applicationOptions(options, state) {
-    const { permissionMode: _permissionMode, delegationNotifications: _delegationNotifications, catalog: _catalog, modelProfiles: _modelProfiles, createModelConfiguration: _createModelConfiguration, resolveModelCapabilities: _resolveModelCapabilities, persistDefaultModel: _persistDefaultModel, closeOwnedResources: _closeOwnedResources, mcp: _mcp, git: _git, configureWorkspace: _configureWorkspace, ...application } = options;
-    return { ...application, permissionModeSource: () => state.options.permissionMode ?? "default" };
-}
-function unknownReasoningEffort() {
-    return {
-        status: "unknown",
-        source: "unknown",
-        efforts: [],
-        overridden: false,
-    };
-}
-function withModelConfiguration(options, configuration, runtimeOptions) {
-    const { model: _model, modelInfo: _modelInfo, contextBudget: _contextBudget, ...unchanged } = options;
-    return {
-        ...unchanged,
-        model: configuration.model,
-        modelInfo: configuration.modelInfo,
-        modelRuntimeOptions: runtimeOptions ?? configuredModelOptions(options, configuration.modelInfo.profile),
-        ...(configuration.contextBudget === undefined
-            ? {}
-            : { contextBudget: configuration.contextBudget }),
-    };
-}
-function configuredModelOptions(options, profile) {
-    const effort = options.modelProfiles?.find(item => item.name === profile)?.reasoningEffort;
-    return effort === undefined ? {} : { reasoningEffort: effort };
-}
-function readHistoricalModel(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new MaybeCodeUsageError("Historical model identity is invalid");
-    const saved = value;
-    for (const key of ["provider", "model"])
-        if (typeof saved[key] !== "string" || !saved[key])
-            throw new MaybeCodeUsageError(`Historical model ${key} is invalid`);
-    for (const key of ["profile", "adapter"])
-        if (saved[key] !== undefined && typeof saved[key] !== "string")
-            throw new MaybeCodeUsageError(`Historical model ${key} is invalid`);
-    if (!saved.runtimeOptions || typeof saved.runtimeOptions !== "object" || Array.isArray(saved.runtimeOptions))
-        throw new MaybeCodeUsageError("Historical model options are invalid");
-    return saved;
-}
-function assertHistoricalModel(saved, current) {
-    if (!current || saved.provider !== current.provider || saved.model !== current.model || saved.adapter !== current.adapter) {
-        throw new MaybeCodeUsageError("The selected history position requires its original provider, model and adapter configuration");
-    }
-}
 //# sourceMappingURL=workspace.js.map