pi-jarvis 1.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marc Mironescu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# pi-jarvis
+
+`pi-jarvis` adds a polished `/jarvis` side-conversation overlay to Pi so you can ask for help without derailing the main session.
+
+## Why use it
+
+`/jarvis` gives you a second lane for quick questions, triage, and local investigation while the main session keeps moving. Instead of interrupting the primary flow, it opens a separate persistent side thread with explicit controls for tool access and main-session handoff.
+
+## What you get
+
+- A floating `/jarvis` overlay inside the current Pi session
+- A separate side-session history that survives reopening the overlay
+- Automatic follow-main model behavior, with optional `/jarvis-model` pinning
+- Permission-gated local `read`, `bash`, `edit`, and `write` access, plus `mcp` when available
+- Optional non-interrupting notes or confirmed redirects back to the main session
+- A focused regression suite covering the risky runtime and overlay paths
+
+## Quick start
+
+### 1. Install the package
+
+```bash
+npm install pi-jarvis
+```
+
+### 2. Register the extension entrypoint in Pi
+
+Use the published entrypoint:
+
+```text
+./dist/index.js
+```
+
+This package is intended to run inside a Pi installation that provides the required peer dependencies.
+
+### 3. Open `/jarvis`
+
+```bash
+/jarvis
+```
+
+You can also send the first message immediately:
+
+```bash
+/jarvis check this file for obvious regressions
+```
+
+Or use it as a background helper while continuing the main flow:
+
+```bash
+/jarvis summarize last 20 lines of build output and suggest next action
+```
+
+## Commands
+
+### `/jarvis`
+Opens the side overlay. If you pass text after the command, that text becomes the first side-session prompt.
+
+### `/jarvis-model <provider/model>`
+Pins `/jarvis` to a specific model without changing the main session model.
+
+### `/jarvis-model follow-main`
+Returns `/jarvis` to the default mode where it follows the current main model.
+
+## Overlay behavior
+
+The overlay is designed to stay explicit about what `/jarvis` can do right now. It surfaces:
+
+- the current main-session state
+- the active `/jarvis` model and mode
+- what changed since the last `/jarvis` turn
+- whether local tools are off, enabled, or enabled without MCP
+
+The main header controls are:
+
+- `Repo tools`
+- `Note main`
+- `Redirect`
+
+All three are off by default.
+
+## Permission model
+
+### Repo tools
+When enabled, `/jarvis` may use local:
+
+- `read`
+- `bash`
+- `edit`
+- `write`
+- `mcp` when the MCP adapter is available in the current Pi environment
+
+When disabled, `/jarvis` works from injected session context and the bridge controls only.
+
+### Note main
+Allows `/jarvis` to send a concise, non-interrupting note back to the main session.
+
+### Redirect
+Allows `/jarvis` to send a redirecting instruction to the main session, but every actual redirect still requires explicit confirmation.
+
+## Session model
+
+- `/jarvis` keeps its own isolated conversation state
+- prior side-session history is restored from a session file under `jarvis-sessions/`
+- `/jarvis` follows the main model by default
+- thinking-step streaming is collapsed to a cleaner animated fallback for readability
+
+## Development
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Type-check:
+
+```bash
+npm run check
+```
+
+Run tests:
+
+```bash
+npm test
+```
+
+Build the published package contents:
+
+```bash
+npm run build
+```
+
+## Published package contents
+
+The npm package publishes:
+
+- `dist/`
+- `README.md`
+- `LICENSE`
+- `package.json`
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { type ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export default function jarvisExtension(pi: ExtensionAPI): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EAGN,KAAK,YAAY,EAGjB,MAAM,+BAA+B,CAAC;AA+BvC,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAyP9D"}

package/dist/index.js

@@ -0,0 +1,508 @@
+import { existsSync } from "node:fs";
+import { ModelSelectorComponent, SettingsManager, } from "@mariozechner/pi-coding-agent";
+import { buildMainSessionContext } from "./main-context.js";
+import { MainSessionTracker } from "./main-session-state.js";
+import { attachOverlayBridge, JarvisOverlayBridge, JarvisOverlayComponent } from "./overlay.js";
+import { createJarvisSessionRef, readJarvisSessionRef, JARVIS_SESSION_REF_CUSTOM_TYPE } from "./session-ref.js";
+import { JarvisSideSessionRuntime, createSideSessionFile } from "./side-session.js";
+export default function jarvisExtension(pi) {
+    const mainSession = new MainSessionTracker();
+    const state = {
+        bridge: new JarvisOverlayBridge(),
+        mainSession,
+        mainContext: buildMainSessionContext(mainSession.snapshot()),
+        lastJarvisSeenMainContext: undefined,
+        queuedMessages: [],
+        jarvisModelSelection: { mode: "follow-main" },
+        systemPrompt: "",
+        themeProvider: () => {
+            throw new Error("/jarvis theme requested before UI was available.");
+        },
+        allowSideTools: false,
+        allowFollowUpToMain: false,
+        allowSteerToMain: false,
+    };
+    pi.registerCommand("jarvis", {
+        description: "Open the /jarvis side conversation overlay",
+        handler: async (args, ctx) => {
+            updateContextState(pi, state, ctx);
+            void ensureRuntime(pi, state, ctx).catch((error) => {
+                state.bridge.notify(error instanceof Error ? error.message : String(error), "error");
+            });
+            const initialMessage = normalizeInitialMessage(args);
+            if (initialMessage) {
+                queueMessage(state, initialMessage);
+                void flushQueuedMessages(pi, state, ctx);
+            }
+            const overlayView = createOverlayView(pi, state, ctx);
+            await ctx.ui.custom((tui, theme, _keybindings, done) => {
+                state.themeProvider = () => theme;
+                const closeOverlay = () => {
+                    done(undefined);
+                    queueMicrotask(() => tui.requestRender());
+                };
+                return attachOverlayBridge(new JarvisOverlayComponent(tui, theme, state.bridge, overlayView, closeOverlay), state.bridge, tui);
+            }, {
+                overlay: true,
+                overlayOptions: {
+                    width: "68%",
+                    minWidth: 68,
+                    maxHeight: "82%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
+    pi.registerCommand("jarvis-model", {
+        description: "Set the model used by /jarvis without changing the main agent model",
+        handler: async (args, ctx) => {
+            updateContextState(pi, state, ctx);
+            const request = args.trim();
+            const selectModelFromMenu = async (initialSearchInput) => {
+                const selectorSettingsManager = SettingsManager.inMemory();
+                return ctx.ui.custom((tui, _theme, _keybindings, done) => new ModelSelectorComponent(tui, getDesiredJarvisModel(state), selectorSettingsManager, ctx.modelRegistry, [], (model) => done(model), () => done(undefined), initialSearchInput));
+            };
+            const pinSelectedModel = async (model) => {
+                try {
+                    await applyJarvisModelSelection(state, { mode: "pinned", model });
+                }
+                catch (error) {
+                    ctx.ui.notify(`Failed to pin /jarvis to ${formatModelLabel(model)}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    return;
+                }
+                ctx.ui.notify(`Pinned /jarvis to ${formatModelLabel(model)}. The main model is still ${formatModelLabel(state.model)}.`, "info");
+            };
+            if (request.toLowerCase() === "follow-main") {
+                try {
+                    await applyJarvisModelSelection(state, { mode: "follow-main" });
+                }
+                catch (error) {
+                    ctx.ui.notify(`Failed to switch /jarvis back to follow-main: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    return;
+                }
+                ctx.ui.notify(`Set /jarvis to follow the main model (${formatModelLabel(state.model)}).`, "info");
+                return;
+            }
+            if (!request) {
+                if (!ctx.hasUI) {
+                    ctx.ui.notify(`/jarvis is ${describeJarvisModelSelection(state)}. Use /jarvis-model follow-main or /jarvis-model <provider/model>.`, "info");
+                    return;
+                }
+                const selectedModel = await selectModelFromMenu();
+                if (!selectedModel) {
+                    return;
+                }
+                await pinSelectedModel(selectedModel);
+                return;
+            }
+            const availableModels = getAvailableJarvisModels(ctx.modelRegistry);
+            const exactModel = findExactAvailableModelMatch(request, availableModels);
+            if (exactModel) {
+                await pinSelectedModel(exactModel);
+                return;
+            }
+            if (!ctx.hasUI) {
+                const errorMessage = availableModels.length === 0
+                    ? "No /jarvis models are currently available from the main model registry."
+                    : `Unknown /jarvis model "${request}". Use /jarvis-model follow-main or an exact provider/model from the current model registry.`;
+                ctx.ui.notify(errorMessage, "error");
+                return;
+            }
+            const selectedModel = await selectModelFromMenu(request);
+            if (!selectedModel) {
+                return;
+            }
+            await pinSelectedModel(selectedModel);
+        },
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        state.runtime?.dispose();
+        state.runtime = undefined;
+        state.bootPromise = undefined;
+        state.flushPromise = undefined;
+        state.queuedMessages = [];
+        state.lastJarvisSeenMainContext = undefined;
+        state.jarvisModelSelection = { mode: "follow-main" };
+        state.allowSideTools = false;
+        state.allowFollowUpToMain = false;
+        state.allowSteerToMain = false;
+        state.mainSession.reset(formatModelLabel(ctx.model));
+        updateContextState(pi, state, ctx);
+        enforceCompatibilityGuard(state);
+        state.sessionRef = readJarvisSessionRef(ctx.sessionManager.getBranch());
+        state.bridge.reset();
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleAgentStart();
+        refreshMainContext(state);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleAgentEnd();
+        refreshMainContext(state);
+    });
+    pi.on("message_start", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleMessageStart(event);
+        refreshMainContext(state);
+    });
+    pi.on("message_update", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleMessageUpdate(event);
+        refreshMainContext(state);
+    });
+    pi.on("message_end", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleMessageEnd(event);
+        refreshMainContext(state);
+    });
+    pi.on("tool_execution_start", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleToolExecutionStart(event);
+        refreshMainContext(state);
+    });
+    pi.on("tool_execution_end", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.mainSession.handleToolExecutionEnd(event);
+        refreshMainContext(state);
+    });
+    pi.on("model_select", async (event, ctx) => {
+        updateContextState(pi, state, ctx);
+        state.model = event.model;
+        state.mainSession.handleModelSelect(formatModelLabel(event.model));
+        refreshMainContext(state);
+        enforceCompatibilityGuard(state);
+        if (!state.runtime || state.jarvisModelSelection.mode !== "follow-main") {
+            return;
+        }
+        try {
+            await syncRuntimeModelSelection(state);
+        }
+        catch (error) {
+            state.bridge.notify(`Failed to sync /jarvis model: ${error instanceof Error ? error.message : String(error)}`, "error");
+        }
+    });
+    pi.on("session_shutdown", async () => {
+        state.runtime?.dispose();
+        state.runtime = undefined;
+        state.bootPromise = undefined;
+        state.flushPromise = undefined;
+        state.queuedMessages = [];
+        state.lastJarvisSeenMainContext = undefined;
+        state.jarvisModelSelection = { mode: "follow-main" };
+        state.allowSideTools = false;
+        state.allowFollowUpToMain = false;
+        state.allowSteerToMain = false;
+        state.mainSession.reset(formatModelLabel(state.model));
+        refreshMainContext(state);
+        // Cancel any pending confirmation and clear transient overlay state so a
+        // side-session tool execute still waiting on confirmSteerToMain does not
+        // hang while the session is torn down.
+        state.bridge.reset();
+    });
+}
+function updateContextState(pi, state, ctx) {
+    state.model = ctx.model;
+    state.thinkingLevel = pi.getThinkingLevel();
+    state.systemPrompt = ctx.getSystemPrompt();
+    state.themeProvider = () => ctx.ui.theme;
+    state.mainSession.refreshFromContext(ctx, formatModelLabel(state.model));
+    refreshMainContext(state);
+}
+function refreshMainContext(state) {
+    state.mainContext = buildMainSessionContext(state.mainSession.snapshot());
+}
+function getDesiredJarvisModel(state) {
+    return state.jarvisModelSelection.mode === "pinned" ? state.jarvisModelSelection.model : state.model;
+}
+function getDesiredJarvisThinkingLevel(state) {
+    const desiredModel = getDesiredJarvisModel(state);
+    if (desiredModel?.provider === "xai") {
+        return "off";
+    }
+    return state.jarvisModelSelection.mode === "follow-main" ? state.thinkingLevel : "off";
+}
+function isModelBridgeCompatible(model) {
+    if (!model) {
+        return true;
+    }
+    if (model.provider === "xai" && model.id.includes("multi-agent")) {
+        return false;
+    }
+    return true;
+}
+function enforceCompatibilityGuard(state) {
+    const desired = getDesiredJarvisModel(state);
+    if (!isModelBridgeCompatible(desired)) {
+        state.allowFollowUpToMain = false;
+        state.allowSteerToMain = false;
+        state.bridge.notify(`Disabled Follow-up/Steer: ${formatModelLabel(desired)} does not support bridge tools.`, "warning");
+    }
+}
+function getJarvisModelModeLabel(selection) {
+    return selection.mode === "follow-main" ? "follow main" : "pinned";
+}
+function describeJarvisModelSelection(state) {
+    const activeModelLabel = formatModelLabel(getDesiredJarvisModel(state));
+    return state.jarvisModelSelection.mode === "follow-main"
+        ? `following the main model (${activeModelLabel})`
+        : `pinned to ${activeModelLabel}`;
+}
+function getAvailableJarvisModels(modelRegistry) {
+    modelRegistry.refresh();
+    try {
+        return modelRegistry.getAvailable();
+    }
+    catch {
+        return [];
+    }
+}
+function findExactAvailableModelMatch(modelReference, availableModels) {
+    const trimmedReference = modelReference.trim();
+    if (!trimmedReference) {
+        return undefined;
+    }
+    const normalizedReference = trimmedReference.toLowerCase();
+    const canonicalMatches = availableModels.filter((model) => `${model.provider}/${model.id}`.toLowerCase() === normalizedReference);
+    if (canonicalMatches.length === 1) {
+        return canonicalMatches[0];
+    }
+    if (canonicalMatches.length > 1) {
+        return undefined;
+    }
+    const slashIndex = trimmedReference.indexOf("/");
+    if (slashIndex !== -1) {
+        const provider = trimmedReference.substring(0, slashIndex).trim();
+        const modelId = trimmedReference.substring(slashIndex + 1).trim();
+        if (provider && modelId) {
+            const providerMatches = availableModels.filter((model) => model.provider.toLowerCase() === provider.toLowerCase() &&
+                model.id.toLowerCase() === modelId.toLowerCase());
+            if (providerMatches.length === 1) {
+                return providerMatches[0];
+            }
+            if (providerMatches.length > 1) {
+                return undefined;
+            }
+        }
+    }
+    const idMatches = availableModels.filter((model) => model.id.toLowerCase() === normalizedReference);
+    return idMatches.length === 1 ? idMatches[0] : undefined;
+}
+async function syncRuntimeModelSelection(state) {
+    if (!state.runtime) {
+        return;
+    }
+    await state.runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
+}
+async function applyJarvisModelSelection(state, selection) {
+    const previousSelection = state.jarvisModelSelection;
+    state.jarvisModelSelection = selection;
+    try {
+        await syncRuntimeModelSelection(state);
+        enforceCompatibilityGuard(state);
+    }
+    catch (error) {
+        state.jarvisModelSelection = previousSelection;
+        throw error;
+    }
+}
+function normalizeInitialMessage(args) {
+    const message = args.trim();
+    return message.length > 0 ? message : undefined;
+}
+function queueMessage(state, message) {
+    state.queuedMessages.push(message);
+}
+function createOverlayView(pi, state, ctx) {
+    const syncToolAccess = () => {
+        state.runtime?.setToolAccessEnabled(state.allowSideTools);
+    };
+    return {
+        isReady: () => state.runtime?.isReady() ?? false,
+        isStreaming: () => state.runtime?.isStreaming() ?? false,
+        getModelLabel: () => state.runtime?.getModelLabel() ?? formatModelLabel(getDesiredJarvisModel(state)),
+        getModelModeLabel: () => getJarvisModelModeLabel(state.jarvisModelSelection),
+        getMainStatusLabel: () => state.mainContext.summary.mainStatus,
+        getMainModelLabel: () => state.mainContext.summary.mainModelLabel,
+        getMainFocusLabel: () => state.mainContext.summary.workState.currentAction,
+        getMainDeltaLabel: () => formatMainContextDeltaLabel(state.lastJarvisSeenMainContext, state.mainContext),
+        getRepoToolsDetailLabel: () => state.runtime?.getRepoToolsDetailLabel() ?? (state.allowSideTools ? "local tools only" : "repo tools off"),
+        isToolAccessEnabled: () => state.allowSideTools,
+        isFollowUpToMainEnabled: () => state.allowFollowUpToMain,
+        isSteerToMainEnabled: () => state.allowSteerToMain,
+        toggleToolAccess: () => {
+            state.allowSideTools = !state.allowSideTools;
+            syncToolAccess();
+        },
+        toggleFollowUpToMain: () => {
+            if (!isModelBridgeCompatible(getDesiredJarvisModel(state))) {
+                state.bridge.notify("Follow-up is not supported by the current /jarvis model.", "warning");
+                return;
+            }
+            state.allowFollowUpToMain = !state.allowFollowUpToMain;
+            syncToolAccess();
+        },
+        toggleSteerToMain: () => {
+            if (!isModelBridgeCompatible(getDesiredJarvisModel(state))) {
+                state.bridge.notify("Steer is not supported by the current /jarvis model.", "warning");
+                return;
+            }
+            state.allowSteerToMain = !state.allowSteerToMain;
+            syncToolAccess();
+        },
+        getDisplayEntries: () => getOverlayEntries(state),
+        sendMessage: async (text) => {
+            queueMessage(state, text);
+            await flushQueuedMessages(pi, state, ctx);
+        },
+    };
+}
+function getOverlayEntries(state) {
+    let entries;
+    if (state.runtime) {
+        entries = state.runtime.getDisplayEntries();
+    }
+    else {
+        const hasRestorableSessionRef = Boolean(state.sessionRef?.file && existsSync(state.sessionRef.file));
+        entries = [
+            {
+                kind: "system",
+                text: hasRestorableSessionRef
+                    ? "Connecting to your prior /jarvis conversation…"
+                    : "Starting /jarvis side conversation…",
+            },
+        ];
+        if (state.queuedMessages.length > 0) {
+            entries.push({ kind: "status", text: `Queued ${state.queuedMessages.length} message${state.queuedMessages.length === 1 ? "" : "s"}…` });
+        }
+    }
+    entries.push({ kind: "status", text: `Since last /jarvis turn: ${formatMainContextDeltaLabel(state.lastJarvisSeenMainContext, state.mainContext)}` });
+    entries.push({ kind: "status", text: `Repo tools: ${state.runtime?.getRepoToolsDetailLabel() ?? (state.allowSideTools ? "local tools only" : "repo tools off")}` });
+    if (!isModelBridgeCompatible(getDesiredJarvisModel(state))) {
+        entries.push({ kind: "status", text: "Relay disabled: current /jarvis model is incompatible with bridge tools" });
+    }
+    return entries;
+}
+function formatMainContextDeltaLabel(previousContext, currentContext) {
+    if (!previousContext) {
+        return "first /jarvis turn";
+    }
+    if (currentContext.summary.workState.currentAction !== previousContext.summary.workState.currentAction) {
+        return `focus → ${currentContext.summary.workState.currentAction}`;
+    }
+    if (currentContext.summary.validation.summary !== previousContext.summary.validation.summary) {
+        return `validation → ${currentContext.summary.validation.summary}`;
+    }
+    if (currentContext.summary.mainStatus !== previousContext.summary.mainStatus) {
+        return `main status → ${currentContext.summary.mainStatus}`;
+    }
+    if (currentContext.summary.mainModelLabel !== previousContext.summary.mainModelLabel) {
+        return `model → ${currentContext.summary.mainModelLabel}`;
+    }
+    const previousFiles = new Set(previousContext.summary.workState.recentFiles);
+    const newFiles = currentContext.summary.workState.recentFiles.filter((file) => !previousFiles.has(file));
+    if (newFiles.length > 0) {
+        return `new files → ${newFiles.join(", ")}`;
+    }
+    if (currentContext.summary.latestUserRequest && currentContext.summary.latestUserRequest !== previousContext.summary.latestUserRequest) {
+        return `request → ${currentContext.summary.latestUserRequest}`;
+    }
+    return "no significant change";
+}
+async function flushQueuedMessages(pi, state, ctx) {
+    updateContextState(pi, state, ctx);
+    if (state.flushPromise) {
+        return state.flushPromise;
+    }
+    // flushQueuedMessages is awaited in fire-and-forget paths (the /jarvis command
+    // handler's initial message flush and the overlay input submit). Any error
+    // that propagates out of here becomes an unhandled promise rejection, so the
+    // IIFE must catch and surface every failure via bridge.notify rather than
+    // rethrowing.
+    state.flushPromise = (async () => {
+        try {
+            const runtime = await ensureRuntime(pi, state, ctx);
+            await runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
+            while (state.queuedMessages.length > 0) {
+                const message = state.queuedMessages.shift();
+                try {
+                    await runtime.sendMessage(message);
+                    state.lastJarvisSeenMainContext = state.mainContext;
+                }
+                catch (error) {
+                    state.bridge.notify(`Failed to send /jarvis message: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            state.bridge.notify(`/jarvis startup failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+        }
+    })().finally(() => {
+        state.flushPromise = undefined;
+    });
+    return state.flushPromise;
+}
+async function ensureRuntime(pi, state, ctx) {
+    if (state.runtime) {
+        return state.runtime;
+    }
+    if (state.bootPromise) {
+        return state.bootPromise;
+    }
+    state.bridge.setWorkingMessage("Starting /jarvis…");
+    state.bootPromise = (async () => {
+        let sessionFile = state.sessionRef?.file;
+        if (!sessionFile || !existsSync(sessionFile)) {
+            sessionFile = await createSideSessionFile(ctx.cwd);
+            state.sessionRef = createJarvisSessionRef(sessionFile);
+            pi.appendEntry(JARVIS_SESSION_REF_CUSTOM_TYPE, state.sessionRef);
+        }
+        const runtime = await JarvisSideSessionRuntime.create({
+            bridge: state.bridge,
+            cwd: ctx.cwd,
+            modelRegistry: ctx.modelRegistry,
+            model: getDesiredJarvisModel(state),
+            jarvisModelModeProvider: () => state.jarvisModelSelection.mode,
+            thinkingLevel: getDesiredJarvisThinkingLevel(state),
+            sessionFile,
+            systemPromptProvider: () => state.systemPrompt,
+            mainContextProvider: () => state.mainContext,
+            toolAccessProvider: () => state.allowSideTools,
+            communicationPermissionsProvider: () => ({
+                allowFollowUpToMain: state.allowFollowUpToMain,
+                allowSteerToMain: state.allowSteerToMain,
+            }),
+            sendFollowUpToMain: (message) => {
+                pi.sendUserMessage(message, { deliverAs: "followUp" });
+            },
+            // Route the confirmation through the /jarvis overlay itself via the
+            // bridge. The main session's UI confirm would otherwise render inside
+            // the base layer (the pi editor container) and sit hidden behind the
+            // /jarvis overlay, leaving the side-session tool execute hung on a
+            // promise the user could never answer.
+            confirmSteerToMain: (message) => state.bridge.requestConfirmation("Send /jarvis steer to main?", `This will steer the main agent with:\n\n${message}`),
+            sendSteerToMain: (message) => {
+                pi.sendUserMessage(message, { deliverAs: "steer" });
+            },
+            themeProvider: state.themeProvider,
+        });
+        state.runtime = runtime;
+        state.bridge.setWorkingMessage(undefined);
+        return runtime;
+    })().catch((error) => {
+        state.bridge.setWorkingMessage(undefined);
+        throw error;
+    }).finally(() => {
+        state.bootPromise = undefined;
+    });
+    return state.bootPromise;
+}
+function formatModelLabel(model) {
+    if (!model) {
+        return "model unavailable";
+    }
+    return `${model.provider}/${model.id}`;
+}
+//# sourceMappingURL=index.js.map