visionclaw 0.1.219-beta.0 → 0.1.219-dev.codex-issue-2805-worker-runtime.1

package/dist/agent/session-manager.js

@@ -1,131 +1,24 @@
-import { isThreadTasksEnabled, isWorkspaceEnabled } from "../config/types.js";
 import { ClaudeAgentSession } from "./engines/claude/session.js";
 import { PiCodingAgentSession } from "./engines/pi-coding/session.js";
 import { getAgentEngine } from "./engines/engine-factory.js";
-import { loadOwnerConfig, rotateSessionId } from "../config/index.js";
-import { describeEffectiveBrowserSelection } from "./browser-selection.js";
-import { loadMailbox, setActiveSession, addMemo, consumeMemosFor, ackMemos, updateCodingSessionInfo, } from "./mailbox.js";
+import { rotateSessionId } from "../config/index.js";
 import { logger } from "../logger.js";
-import { getAgentState } from "./state.js";
-import { buildMemoryProtocolSection } from "./memory-protocol.js";
-import { resolveWorkspaceCwd, sameWorkspaceCwd } from "./workspace-cwd.js";
-export function buildGeneralSessionAddendum(config) {
-    const workspaceTasks = isWorkspaceEnabled(config)
-        ? "- Status checks, scheduling, calendar tasks, and email\n"
-        : "- Status checks and tasks using independently connected integrations when available\n";
-    const codingWorkspaceHint = getAgentEngine(config) === "pi-coding"
-        ? "When switching to the coding session for a task that involves a specific project or repository, pass the project's absolute path as the `cwd` parameter (e.g. `switch_session(target=\"coding\", cwd=\"/Users/jessica/myproject\", memo=\"...\")`). This sets the Pi SDK coding session's working directory so Bash commands default to the project root."
-        : "The optional `cwd` parameter is ignored by Claude coding sessions and when switching back to general.";
-    return `
-## Session-Specific Instructions (General Session)
-
-You are currently in the **general session**. This session handles:
-- Conversations and quick questions from the owner
-${workspaceTasks}- Simple one-off tasks (look something up, summarize information, etc.)
-- Monitoring and proactive behavior during heartbeats
-
-If the owner asks for a complex, multi-step coding task (refactoring, debugging, multi-file feature work), use \`switch_session(target="coding", memo="<task and known constraints>")\` to hand it off. Do NOT attempt sustained coding work in this session — it will pollute your context.
-
-${codingWorkspaceHint}
-
-When the coding session is active or paused, you can tell the owner its status. If they send a message related to that task (e.g. "actually use a different approach"), forward it via \`switch_session(target="coding", memo="<the new instruction>")\` and do not continue the coding work yourself.
-
-When you receive a memo marked \`[Coding task complete — owner notification required]\`, \`notify_user\` with \`purpose="completion"\` and a concise human-language summary, then \`finish\`. The memo is internal working text — never paste it into chat. If you do not notify, the runtime still sends a short generic ping so the completion is not silently dropped.`;
-}
-export function buildCodingSessionAddendum(config, runtimeSurface) {
-    const ownerConfig = loadOwnerConfig();
-    const agentLabel = config.displayName ?? config.agentName;
-    const workspaceIdentity = isWorkspaceEnabled(config)
-        ? `- **Your email**: ${config.gmail}`
-        : `- **Managed Workspace**: unavailable; independently connected MCP${runtimeSurface.browser.available ? "/browser" : ""} accounts may still be used, but they do not enable built-in Workspace tools or channels.`;
-    // Claude coding uses the claude_code preset, so this addendum is the only
-    // VisionClaw Memory Protocol that session sees. Pi already concatenates the
-    // full owner prompt — do not duplicate the section there.
-    const includeMemoryProtocol = getAgentEngine(config) === "claude";
-    const extraTools = [
-        runtimeSurface.browser.available ? "browser (Playwright MCP)" : null,
-        runtimeSurface.desktop.available ? "desktop (computer_use_* tools)" : null,
-    ].filter((part) => part !== null);
-    const extraToolsClause = extraTools.length > 0
-        ? ` ${extraTools[0][0].toUpperCase()}${extraTools.join(" and ").slice(1)} ${extraTools.length === 1 ? "is" : "are"} available if the task needs them — do not drift into unrelated desktop or browser work.`
-        : "";
-    const browserEngineLine = `- Browser engine: ${describeEffectiveBrowserSelection(runtimeSurface.browserSelection)}`;
-    const memorySection = includeMemoryProtocol
-        ? `\n\n${buildMemoryProtocolSection(isThreadTasksEnabled(config)).trimEnd()}`
-        : "";
-    return `
-## VisionClaw Context
-
-You are **${agentLabel}**, the **coding session** of a dual-session VisionClaw agent on ${runtimeSurface.hostCapabilities.platformLabel}.
-
-${workspaceIdentity}
-- **Owner**: ${ownerConfig.ownerName}${ownerConfig.ownerEmail ? ` <${ownerConfig.ownerEmail}>` : ""}
-${browserEngineLine}
-
-Prefer terminal and filesystem tools for this session.${extraToolsClause} Custom VisionClaw tools include \`notify_user\`, \`memory\`, \`manage_skills\`, and \`switch_session\`.
-
-## Communicating with the Owner (CRITICAL)
-
-Plain assistant text is process narration. Telegram and Fin-App put it on the progress card and do not post it as a chat bubble. TUI still shows it. It is not a substitute for \`notify_user\`.
-
-Use \`notify_user\` for:
-- Questions or blockers that need the owner (omit \`purpose\`)
-- Attachments / screenshots
-- The final result of this coding task: \`notify_user\` with \`purpose="completion"\`, then \`switch_session(target="general", reason="complete", memo="Task completed: <summary>")\`. The completion purpose prevents the general session from sending the same result again.
-
-## Session-Specific Instructions (Coding Session)
-
-This session is reserved for focused, multi-step coding. Stay on the current task. If an unrelated message arrives (chat, question, non-coding request), \`switch_session(target="general", reason="handoff")\` with enough memo for general to reply. Use provider-specific coding or delegation tools when they help; keep orchestration here.
-
-## Repository State (check before your first edit)
-
-This session resumes in whatever worktree and branch the previous task left behind. Before editing a git repository, run \`git status --short --branch\` (and \`git worktree list\` when there is more than one checkout).
-
-Decide which case you are in. Do not \`notify_user\` with git status unless you need the owner to decide:
-- **Continuing work that already has a branch** — stay on that branch.
-- **Starting a new task** — do not build on top of the previous task's branch. Begin from a freshly fetched main: \`git fetch origin\`, then \`git switch -c <branch> refs/remotes/origin/main\`. Skipping the fetch branches you off a stale main, which is the usual reason a diff fills up with changes that are not yours.
-- **Uncommitted changes you did not make** — ask the owner before committing, stashing, or discarding them.
-
-If your diff ends up carrying files or commits unrelated to the task, the base is wrong. Fix the base rather than explaining the noise in the PR.${memorySection}`;
-}
 /**
- * Manages two AgentSessions (general + coding) with cooperative switching.
+ * Owns the agent's single conversation session.
  *
- * Only one session is active at a time. The agent decides when to switch
- * by calling the switch_session tool. The manager handles suspending the
- * current session and resuming the target.
+ * Builds the engine-specific session object, exposes the runtime surface
+ * resolved at startup, and handles stop, reset, summary injection and MCP
+ * teardown for it.
  */
 export class SessionManager {
     config;
     buildBaseSystemPrompt;
     /** Resolved runtime tool and external MCP surface for this model/provider pair. */
     runtimeSurface;
-    _requestedDualSessionEnabled;
-    generalSession;
-    codingSession = null;
-    _activeMode = "general";
+    session;
     _managerStopRequested = false;
-    /** Set after a switch_session tool call is detected in the stream. */
-    _pendingSwitch = null;
-    /** Propagated to all sessions for auto-screenshot after Playwright tools. */
-    _screenshotInjector = null;
-    buildCodingSystemPrompt() {
-        if (getAgentEngine(this.config) !== "claude") {
-            return this.buildBaseSystemPrompt() + buildCodingSessionAddendum(this.config, this.runtimeSurface);
-        }
-        return {
-            type: "preset",
-            preset: "claude_code",
-            append: buildCodingSessionAddendum(this.config, this.runtimeSurface),
-            // The addendum is rebuilt for each wake so runtime/config changes are
-            // visible when the SDK resumes an existing transcript.
-            snapshot: false,
-        };
-    }
-    buildGeneralSystemPrompt() {
-        const prompt = this.dualSessionEnabled
-            ? this.buildBaseSystemPrompt() + buildGeneralSessionAddendum(this.config)
-            : this.buildBaseSystemPrompt();
+    buildSystemPrompt() {
+        const prompt = this.buildBaseSystemPrompt();
         return getAgentEngine(this.config) === "claude"
             ? {
                 type: "custom",
@@ -135,77 +28,32 @@ export class SessionManager {
             }
             : prompt;
     }
-    buildSessionContext(mode) {
-        return {
-            mode,
-            getDualSessionEnabled: () => this.dualSessionEnabled,
-        };
-    }
-    createSession(buildPrompt, mode, workspaceCwd) {
-        const engine = getAgentEngine(this.config);
-        const effectiveWorkspaceCwd = workspaceCwd && (this.runtimeSurface.labRuntimePolicy || (mode === "coding" && engine === "pi-coding")) ? workspaceCwd : undefined;
+    createSession(workspaceCwd) {
         const args = {
             config: this.config,
-            buildSystemPrompt: buildPrompt,
+            buildSystemPrompt: () => this.buildSystemPrompt(),
             runtimeSurface: this.runtimeSurface,
-            sessionContext: this.buildSessionContext(mode),
-            ...(effectiveWorkspaceCwd ? { workspaceCwd: effectiveWorkspaceCwd } : {}),
+            ...(workspaceCwd ? { workspaceCwd } : {}),
         };
-        return engine === "pi-coding"
+        return getAgentEngine(this.config) === "pi-coding"
             ? new PiCodingAgentSession(args)
             : new ClaudeAgentSession(args);
     }
-    codingWorkspaceCwd() {
-        const cwd = loadMailbox().codingSession.cwd;
-        if (!cwd)
-            return undefined;
-        try {
-            return resolveWorkspaceCwd(cwd);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            logger.system(`Persisted coding workspace is unavailable; pausing coding and returning to general: ${detail}`);
-            rotateSessionId("coding");
-            updateCodingSessionInfo({ status: "paused", cwd: undefined });
-            setActiveSession("general");
-            return undefined;
-        }
-    }
-    constructor(config, buildSystemPrompt, runtimeSurface, options) {
+    constructor(config, buildSystemPrompt, runtimeSurface, options = {}) {
         this.config = config;
         this.buildBaseSystemPrompt = buildSystemPrompt;
-        this._requestedDualSessionEnabled = options.dualSessionEnabled;
         this.runtimeSurface = runtimeSurface;
         const engine = getAgentEngine(config);
-        if (runtimeSurface.labRuntimePolicy && engine === "pi-coding" && !options.workspaceCwd) {
-            throw new Error("Pi policy-isolated Lab sessions require a workspace cwd");
+        if (runtimeSurface.workerRuntimePolicy && engine === "pi-coding" && !options.workspaceCwd) {
+            throw new Error("Pi policy-isolated worker sessions require a workspace cwd");
         }
-        if (runtimeSurface.labRuntimePolicy && engine !== "pi-coding" && options.workspaceCwd) {
-            throw new Error("Workspace cwd overrides are supported only for Pi Lab sessions");
+        if (runtimeSurface.workerRuntimePolicy && engine !== "pi-coding" && options.workspaceCwd) {
+            throw new Error("Workspace cwd overrides are supported only for Pi worker sessions");
         }
-        if (!runtimeSurface.labRuntimePolicy && options.workspaceCwd) {
-            throw new Error("Startup workspace cwd overrides are supported only for Pi Lab workers");
+        if (!runtimeSurface.workerRuntimePolicy && options.workspaceCwd) {
+            throw new Error("Startup workspace cwd overrides are supported only for Pi workers");
         }
-        this.generalSession = this.createSession(() => this.buildGeneralSystemPrompt(), "general", runtimeSurface.labRuntimePolicy ? options.workspaceCwd : undefined);
-        if (this.dualSessionEnabled) {
-            let mailbox = loadMailbox();
-            if (mailbox.codingSession.status === "in_progress" || mailbox.codingSession.status === "paused") {
-                const workspaceCwd = runtimeSurface.labRuntimePolicy
-                    ? options.workspaceCwd
-                    : engine === "pi-coding"
-                        ? this.codingWorkspaceCwd()
-                        : undefined;
-                // Reload because stale-cwd recovery updates the durable mailbox.
-                mailbox = loadMailbox();
-                this.codingSession = this.createSession(() => this.buildCodingSystemPrompt(), "coding", workspaceCwd);
-            }
-            this._activeMode = mailbox.activeSession;
-        }
-    }
-    get dualSessionEnabled() {
-        return !this.runtimeSurface.labRuntimePolicy
-            && this._requestedDualSessionEnabled
-            && this.runtimeSurface.visionClawToolTransport.supportsSwitchSessionTool;
+        this.session = this.createSession(options.workspaceCwd);
     }
     /** Browser backend resolved at startup (see {@link RuntimeSurface}). */
     get resolvedBrowserBackend() {
@@ -226,355 +74,83 @@ export class SessionManager {
     get hostCapabilities() {
         return this.runtimeSurface.hostCapabilities;
     }
-    /**
-     * Toggle dual-session mode at runtime. Takes effect on the next wake cycle
-     * because each query() call rebuilds its tool surface.
-     */
-    setDualSessionEnabled(enabled) {
-        this._requestedDualSessionEnabled = enabled;
-        if (!this.dualSessionEnabled && this._activeMode === "coding") {
-            this._activeMode = "general";
-            setActiveSession("general");
-            logger.system("Dual session disabled — forced switch to general");
-        }
-    }
     /**
      * Set the screenshot injector that auto-injects screenshots after
-     * Playwright tool calls. Propagated to all existing sessions.
+     * Playwright tool calls.
      */
     setScreenshotInjector(injector) {
-        this._screenshotInjector = injector;
-        this.generalSession.screenshotInjector = injector;
-        if (this.codingSession) {
-            this.codingSession.screenshotInjector = injector;
-        }
-    }
-    get activeMode() {
-        return this._activeMode;
+        this.session.screenshotInjector = injector;
     }
     get activeSession() {
-        if (this._activeMode === "coding" && this.codingSession) {
-            return this.codingSession;
-        }
-        return this.generalSession;
-    }
-    get pendingSwitch() {
-        return this._pendingSwitch;
-    }
-    getActiveCodingTaskStartedAt() {
-        return loadMailbox().codingSession.startedAt;
-    }
-    hasCompletionReceiptForActiveTask() {
-        try {
-            const taskStartedAt = this.getActiveCodingTaskStartedAt();
-            return Boolean(taskStartedAt && getAgentState().codingCompletionTaskStartedAt === taskStartedAt);
-        }
-        catch {
-            // Agent state is absent in isolated session-manager tests.
-            return false;
-        }
-    }
-    /**
-     * Record a switch request detected from the stream.
-     * The main loop should check this after each stream ends and act on it.
-     */
-    setSwitchRequest(req) {
-        const { cwd: requestedCwd, ...requestWithoutCwd } = req;
-        let cwd;
-        if (req.target === "coding" && requestedCwd && getAgentEngine(this.config) === "pi-coding") {
-            try {
-                cwd = resolveWorkspaceCwd(requestedCwd);
-            }
-            catch (error) {
-                logger.warn(`Ignoring unavailable coding workspace cwd and continuing with fallback: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        this._pendingSwitch = cwd
-            ? { ...requestWithoutCwd, cwd }
-            : requestWithoutCwd;
-    }
-    /**
-     * Execute a pending session switch.
-     * - Writes the memo to the mailbox
-     * - Creates the coding session if it doesn't exist
-     * - Updates the active mode
-     * Returns the forwarded message content to send to the new session.
-     */
-    executePendingSwitch() {
-        if (!this.dualSessionEnabled)
-            return null;
-        const req = this._pendingSwitch;
-        if (!req)
-            return null;
-        this._pendingSwitch = null;
-        const currentMode = this._activeMode;
-        let workspaceNotice;
-        const isCodingCompletion = currentMode === "coding" && req.target === "general" && req.reason === "complete";
-        // The stream handler captures completionDelivered when it sees the
-        // switch_session tool_use. If notify_user ran in the same assistant
-        // message, its send resolves after that capture, so re-check the receipt
-        // here (after the stream ended) before asking general to notify again.
-        const completionDelivered = isCodingCompletion
-            && (req.completionDelivered === true || this.hasCompletionReceiptForActiveTask());
-        // A delivered coding completion needs no cross-session memo. Required
-        // completions remain durable so general / runtime last-resort can still ping.
-        if (req.memo && !completionDelivered) {
-            const memo = isCodingCompletion
-                ? [
-                    "[Coding task complete — owner notification required]",
-                    req.memo,
-                    "",
-                    "`notify_user` with purpose=`completion` and a concise, human-language summary (outcome, files changed, validation, caveats). Never paste this memo into chat. If you do not notify, the runtime still sends a short generic ping so the completion is not silently dropped.",
-                ].join("\n")
-                : req.memo;
-            addMemo(currentMode, req.target, memo);
-        }
-        if (req.target === "coding") {
-            const supportsWorkspaceCwd = getAgentEngine(this.config) === "pi-coding";
-            const currentCwd = supportsWorkspaceCwd ? loadMailbox().codingSession.cwd : undefined;
-            const requestedCwd = supportsWorkspaceCwd ? req.cwd ?? currentCwd : undefined;
-            let workspaceCwd;
-            let workspaceFallback = false;
-            if (requestedCwd) {
-                try {
-                    workspaceCwd = resolveWorkspaceCwd(requestedCwd);
-                }
-                catch (error) {
-                    workspaceFallback = true;
-                    workspaceNotice = "The persisted coding workspace is unavailable; continuing in the profile workspace fallback. The original project directory may need to be restored before making project changes.";
-                    logger.system(`Coding workspace is unavailable; falling back to the profile workspace: ${error instanceof Error ? error.message : String(error)}`);
-                    updateCodingSessionInfo({ cwd: undefined });
-                    this.codingSession?.requestStop();
-                    this.discardCodingSession();
-                    rotateSessionId("coding");
-                }
-            }
-            if (!workspaceFallback && supportsWorkspaceCwd && req.cwd && (!currentCwd || !sameWorkspaceCwd(currentCwd, workspaceCwd ?? ""))) {
-                this.codingSession?.requestStop();
-                this.discardCodingSession();
-                rotateSessionId("coding");
-                logger.system(`Coding workspace changed: ${currentCwd ?? "(default)"} → ${workspaceCwd}; starting a fresh session`);
-            }
-            this.codingSession ??= this.createSession(() => this.buildCodingSystemPrompt(), "coding", workspaceCwd);
-            if (this._screenshotInjector) {
-                this.codingSession.screenshotInjector = this._screenshotInjector;
-            }
-            updateCodingSessionInfo({
-                status: "in_progress",
-                taskSummary: req.memo || "Coding task in progress",
-                startedAt: new Date().toISOString(),
-                ...(supportsWorkspaceCwd && workspaceCwd ? { cwd: workspaceCwd } : {}),
-            });
-        }
-        else if (currentMode === "coding") {
-            if (req.reason === "complete") {
-                updateCodingSessionInfo({ status: "completed" });
-            }
-            else {
-                updateCodingSessionInfo({ status: "paused" });
-            }
-        }
-        this._activeMode = req.target;
-        setActiveSession(req.target);
-        logger.system(`Session switch: ${currentMode} → ${req.target}`);
-        return {
-            target: req.target,
-            reason: req.reason,
-            forwardMessage: req.forwardMessage,
-            ...(workspaceNotice ? { workspaceNotice } : {}),
-            ...(isCodingCompletion
-                ? {
-                    completionMemo: req.memo,
-                    ownerNotificationRequired: !completionDelivered,
-                }
-                : {}),
-        };
-    }
-    /**
-     * Get any unread memos for the currently active session.
-     * Call this before sending a message to the active session so
-     * the memos can be prepended to the context.
-     */
-    consumeMemosForActive() {
-        if (!this.dualSessionEnabled)
-            return null;
-        const memos = consumeMemosFor(this._activeMode);
-        if (memos.length === 0)
-            return null;
-        const lines = ["## Messages from the other session"];
-        for (const m of memos) {
-            lines.push(`[${m.from} session at ${m.timestamp}]: ${m.content}`);
-        }
-        return lines.join("\n");
-    }
-    /**
-     * Acknowledge that consumed memos for the active session have been
-     * successfully injected. Removes them from the mailbox on disk.
-     */
-    ackMemosForActive() {
-        if (!this.dualSessionEnabled)
-            return;
-        ackMemos(this._activeMode);
-    }
-    /**
-     * End the coding session (task complete or abandoned).
-     * Switches back to general mode.
-     */
-    endCodingSession(summary) {
-        updateCodingSessionInfo({ status: "completed", taskSummary: summary });
-        if (this._activeMode === "coding") {
-            addMemo("coding", "general", `Coding task completed: ${summary}`);
-            this._activeMode = "general";
-            setActiveSession("general");
-            logger.system("Coding session ended, switched to general");
-        }
+        return this.session;
     }
     /**
-     * Finalize a coding task when the coding session used the generic `finish`
-     * lifecycle tool after already delivering its completion notification.
-     *
-     * `finish` normally ends only the current wake cycle. The wake runner calls
-     * this method only when it has an exact, task-bound completion receipt, so a
-     * progress notification followed by `finish` still leaves the task active.
-     */
-    finalizeCodingCompletionAfterFinish() {
-        if (!this.dualSessionEnabled || this._activeMode !== "coding")
-            return false;
-        const codingSession = loadMailbox().codingSession;
-        if (codingSession.status !== "in_progress" && codingSession.status !== "paused") {
-            return false;
-        }
-        updateCodingSessionInfo({ status: "completed" });
-        this._activeMode = "general";
-        setActiveSession("general");
-        logger.system("Coding completion delivered before finish — finalized task and switched to general");
-        return true;
-    }
-    /**
-     * Discard pre-warmed subprocesses on every session so the next turn
-     * rebuilds them from the current `config`. Use after mutating provider-
-     * bound state (e.g. client-side provider fallback) — without this, the
-     * Claude warm subprocess can silently keep using the previous provider
-     * for one more turn.
+     * Discard the pre-warmed subprocess so the next turn rebuilds it from the
+     * current `config`. Use after mutating provider-bound state (e.g.
+     * client-side provider fallback) — without this, the Claude warm
+     * subprocess can silently keep using the previous provider for one more
+     * turn.
      */
     discardAllWarmQueries() {
-        this.generalSession.discardWarmQuery();
-        this.codingSession?.discardWarmQuery();
+        this.session.discardWarmQuery();
     }
-    /** Releases still running for coding session objects this manager already discarded. */
-    pendingReleases = new Set();
-    /**
-     * Close MCP stdio children for every session: the live general and coding
-     * sessions plus any discarded coding session whose teardown is still in
-     * flight. Sessions are independent, so release them in parallel and never
-     * let one failure skip another.
-     */
+    /** Close the session's MCP stdio children. A failure is logged, never thrown. */
     async releaseMcpResources() {
-        const results = await Promise.allSettled([
-            this.generalSession.releaseMcpResources(),
-            ...(this.codingSession ? [this.codingSession.releaseMcpResources()] : []),
-            ...this.pendingReleases,
-        ]);
-        for (const result of results) {
-            if (result.status !== "rejected")
-                continue;
-            const reason = result.reason;
-            logger.warn(`Failed to release session MCP resources: ${reason instanceof Error ? reason.message : String(reason)}`);
+        try {
+            await this.session.releaseMcpResources();
+        }
+        catch (err) {
+            logger.warn(`Failed to release session MCP resources: ${err instanceof Error ? err.message : String(err)}`);
         }
-    }
-    discardCodingSession() {
-        const previous = this.codingSession;
-        this.codingSession = null;
-        if (!previous)
-            return;
-        // releaseMcpResources() subsumes discardWarmQuery() on every engine.
-        const release = previous.releaseMcpResources().catch((err) => {
-            logger.warn(`Failed to release coding session MCP resources: ${err instanceof Error ? err.message : String(err)}`);
-        });
-        this.pendingReleases.add(release);
-        void release.then(() => this.pendingReleases.delete(release));
     }
     requestStop() {
         this._managerStopRequested = true;
-        this.activeSession.requestStop();
+        this.session.requestStop();
     }
     clearStop() {
         this._managerStopRequested = false;
-        this.activeSession.clearStop();
+        this.session.clearStop();
     }
     isStopRequested() {
-        return this._managerStopRequested || this.activeSession.isStopRequested();
+        return this._managerStopRequested || this.session.isStopRequested();
     }
-    /** Machine-readable task state, separate from the owner-facing status text. */
-    getCodingSessionState() {
-        if (!this.dualSessionEnabled)
-            return null;
-        return loadMailbox().codingSession.status;
-    }
-    getCodingSessionStatus() {
-        if (!this.dualSessionEnabled)
-            return null;
-        const mailbox = loadMailbox();
-        const cs = mailbox.codingSession;
-        if (!cs.taskSummary)
-            return null;
-        if (cs.status === "in_progress")
-            return `Coding session is active: ${cs.taskSummary}`;
-        if (cs.status === "paused")
-            return `Coding session is paused: ${cs.taskSummary}`;
-        return null;
+    /**
+     * True only when the active engine has confirmed it will not continue.
+     * An engine that cannot prove this leaves the host entry unconfirmed.
+     */
+    executionBarrierConfirmed() {
+        return this.session.executionBarrierConfirmed?.() ?? false;
     }
     /**
-     * Reset the active session: rotates the current session ID to
+     * Reset the session: rotates the current session ID to
      * `previousSessionIds`, clears the active session ID, and passes the
      * summary to the session object for injection into the next turn.
      *
      * The next `sendAndStream` will create a brand-new SDK session.
      */
     resetActiveSession(summary) {
-        // Reset the session object returned by activeSession, even if mailbox
-        // state is temporarily inconsistent (for example coding is marked active
-        // before its lazy session has been constructed).
-        const effectiveMode = this._activeMode === "coding" && this.codingSession ? "coding" : "general";
-        this.resetSession(effectiveMode, summary);
+        this.resetSession(summary);
     }
     /**
-     * Mode-aware variant of {@link resetActiveSession}. Rotates the
-     * mode's persisted session id into `previousSessionIds`, then hands
-     * `summary` to the corresponding session object so it is prepended to
-     * the next turn as priority context.
-     *
-     * Used by `/refresh` (via {@link resetActiveSession}, which targets the
-     * currently-active mode).
-     *
-     * No-op when the target session has not been constructed (the coding
-     * session is lazy-created when the mailbox marks it active).
+     * Rotate the persisted session id into `previousSessionIds`, then hand
+     * `summary` to the session object so it is prepended to the next turn as
+     * priority context. Used by `/refresh` (via {@link resetActiveSession}).
      */
-    resetSession(mode, summary) {
-        const target = mode === "coding" ? this.codingSession : this.generalSession;
-        if (!target)
-            return;
-        rotateSessionId(mode);
-        target.resetForNewSession(summary);
-        logger.system(`Session reset (mode=${mode}), summary ${summary.length} chars`);
+    resetSession(summary) {
+        rotateSessionId();
+        this.session.resetForNewSession(summary);
+        logger.system(`Session reset, summary ${summary.length} chars`);
     }
     /**
-     * Inject a summary into a session WITHOUT rotating its session id.
-     *
-     * Used by the startup engine-switch boundary: rotation and mailbox
-     * clearing happen *before* `SessionManager` is constructed (so the
-     * manager sees the post-collapse world), and then this method just
-     * threads the combined summary into the freshly created session's
-     * first turn.
+     * Inject a summary into the session WITHOUT rotating its session id.
      *
-     * No-op when the target session has not been constructed.
+     * Used by the startup engine-switch boundary: rotation happens *before*
+     * `SessionManager` is constructed, and then this method just threads the
+     * combined summary into the freshly created session's first turn.
      */
-    injectSummary(mode, summary) {
-        const target = mode === "coding" ? this.codingSession : this.generalSession;
-        if (!target)
-            return;
-        target.injectSummary(summary);
-        logger.system(`[session-manager] Injected summary into ${mode} session (${summary.length} chars)`);
+    injectSummary(summary) {
+        this.session.injectSummary(summary);
+        logger.system(`[session-manager] Injected summary into session (${summary.length} chars)`);
     }
 }
 //# sourceMappingURL=session-manager.js.map