pi-jarvis 1.2.3 → 1.3.1

package/AGENTS.md

@@ -4,18 +4,24 @@
 - `pi-jarvis` is a Pi extension that opens a `/jarvis` side-conversation overlay.
 - Core runtime files: `index.ts`, `side-session.ts`, `overlay.ts`, `jarvis-config.ts`, `session-ref.ts`.
 
-## Current `/jarvis-model` Behavior
+## Current `/jarvis-model` and `/jarvis-thinking` Behavior
 - `/jarvis-model` with no request opens a model picker when Pi has a UI.
 - `/jarvis-model <provider/model>` writes a project-scoped override to `.pi/jarvis.json`.
 - `/jarvis-model --global <provider/model>` writes the default global override to the active Pi agent directory's `extensions/pi-jarvis.json` (by default `~/.pi/agent/extensions/pi-jarvis.json`).
 - `/jarvis-model [--project|--global] follow-main` stores a scoped `follow-main` override.
 - `/jarvis-model [--project|--global] clear` removes that scope's override so fallback applies.
-- Resolution order is: project config, then global config, then built-in `follow-main`.
+- `/jarvis-thinking [--project|--global] auto|follow-main|off|minimal|low|medium|high|xhigh` stores a scoped thinking override without changing the main session thinking level.
+- `/jarvis-thinking [--project|--global] clear` removes that scope's thinking override so fallback applies.
+- Resolution order is: project config, then global config, then built-in defaults (`follow-main` for model, `auto` for thinking).
+- `auto` thinking follows main only when `/jarvis` follows the main model; pinned `/jarvis` models default to thinking `off`.
+- `follow-main` thinking follows the main thinking level regardless of model selection, except xAI `/jarvis` models force thinking `off`.
+- `/compact`, `/tree`, and `/new` entered inside `/jarvis` operate on the isolated `/jarvis` side-session, not the main Pi session.
 - `Note main` and `Redirect` stay disabled when the active `/jarvis` model is incompatible with bridge tools.
 
 ## Validation
 - Run `npm test` for full validation.
 - Run `npm run build` before release packaging.
+- Run `npm run verify:release` to validate npm pack payload and release metadata expectations.
 
 ## Docs To Keep In Sync
 - `README.md`

package/README.md

@@ -13,6 +13,8 @@
 [![Pi extension](https://img.shields.io/badge/Pi-extension-06b6d4?style=for-the-badge)](https://github.com/fluxgear/pi-jarvis)
 [![TypeScript](https://img.shields.io/badge/TypeScript-powered-2563eb?style=for-the-badge)](./package.json)
 
+<p><strong>Current version:</strong> 1.3.1</p>
+
 <p>
   <strong>Persistent side session</strong> ·
   <strong>Live main-session awareness</strong> ·
@@ -79,15 +81,15 @@ flowchart LR
 
 ```mermaid
 flowchart TD
-    A[Main session keeps moving] --> B[/jarvis opens in overlay]
-    B --> C[Jarvis sees current main-session context]
-    C --> D{What do you need?}
-    D -->|Status / summary / analysis| E[Jarvis handles the side task]
-    D -->|Repo inspection| F[Enable Repo tools]
-    D -->|Influence the main lane| G[Enable Note main or Redirect]
-    G --> H{Redirect?}
-    H -->|Yes| I[Per-send confirmation]
-    H -->|No| J[Quiet follow-up note]
+    A["Main session keeps moving"] --> B["/jarvis opens in overlay"]
+    B --> C["Jarvis sees current main-session context"]
+    C --> D{"What do you need?"}
+    D -->|Status / summary / analysis| E["Jarvis handles the side task"]
+    D -->|Repo inspection| F["Enable Repo tools"]
+    D -->|Influence the main lane| G["Enable Note main or Redirect"]
+    G --> H{"Redirect?"}
+    H -->|Yes| I["Per-send confirmation"]
+    H -->|No| J["Quiet follow-up note"]
 ```
 
 ---
@@ -165,26 +167,49 @@ Restores the chosen scope to `follow-main`. A project-scoped `follow-main` overr
 ### `/jarvis-model [--project|--global] clear`
 Removes the selected scope so `/jarvis` falls back through the remaining config layers to the built-in default.
 
+### `/jarvis-thinking [--project|--global] auto|follow-main|off|minimal|low|medium|high|xhigh`
+Sets the thinking level used by `/jarvis` without changing the main session thinking level. A plain `/jarvis-thinking <level>` writes a **project-local** override to `.pi/jarvis.json`.
+
+- `auto` preserves the built-in behavior: follow the main thinking level only when `/jarvis` follows the main model; pinned `/jarvis` models use `off`.
+- `follow-main` follows the main thinking level even when `/jarvis` is pinned to a separate model.
+- Explicit levels pin `/jarvis` thinking to that level.
+- xAI `/jarvis` models still force thinking `off`.
+
+### `/jarvis-thinking [--project|--global] clear`
+Removes the selected scope so `/jarvis` thinking falls back through the remaining config layers to the built-in `auto` default.
+
+### Side-session commands inside `/jarvis`
+The `/jarvis` input handles a small set of built-in commands against the isolated side-session:
+
+- `/compact [instructions]` compacts the `/jarvis` conversation context.
+- `/tree` prints the `/jarvis` session tree with entry IDs.
+- `/tree <entry-id>` navigates the `/jarvis` session tree to that entry.
+- `/tree --summarize <entry-id> [instructions]` navigates and summarizes the branch being left.
+- `/new` starts a fresh `/jarvis` side-session without changing the main Pi session.
+
 ---
 
-## Model resolution
+## Model and thinking resolution
 
 ```mermaid
 flowchart TD
     A[Project config\n.pi/jarvis.json] -->|if present| B{valid?}
-    B -->|yes| P[Use project selection]
+    B -->|yes| P[Use project overrides]
     B -->|no or missing| C[Global config\n&lt;agentDir&gt;/extensions/pi-jarvis.json]
     C -->|if present| D{valid?}
-    D -->|yes| G[Use global selection]
-    D -->|no or missing| E[Built-in default]
-    E --> F[follow-main]
+    D -->|yes| G[Use global overrides]
+    D -->|no or missing| E[Built-in defaults]
+    E --> F[Model default: follow-main]
+    E --> H[Thinking default: auto]
 ```
 
 ### Resolution order
 
+Model and thinking settings resolve through the same config layers, then fall back to separate built-in defaults:
+
 1. project config: `.pi/jarvis.json`
 2. global config: `~/.pi/agent/extensions/pi-jarvis.json` or the equivalent path under a custom Pi agent dir
-3. built-in default: `follow-main`
+3. built-in defaults: model `follow-main`, thinking `auto`
 
 ---
 
@@ -246,7 +271,9 @@ sequenceDiagram
 - `/jarvis` keeps its own isolated conversation state
 - prior side-session history is restored from a session file under `jarvis-sessions/`
 - Jarvis sees current main-session state plus a compact delta since the last `/jarvis` turn
-- plain `/jarvis-model <provider/model>` writes the project override; use `--global` to change the global default
+- `/compact`, `/tree`, and `/new` entered inside `/jarvis` operate on the side-session, not the main session
+- plain `/jarvis-model <provider/model>` writes the project model override; use `--global` to change the global default
+- plain `/jarvis-thinking <level>` writes the project thinking override; use `--global` to change the global default
 - thinking-step streaming is intentionally collapsed to a cleaner animated fallback for readability
 
 ---
@@ -320,10 +347,10 @@ Build the published package contents:
 npm run build
 ```
 
-Preview the npm payload:
+Preview and verify the npm payload contract:
 
 ```bash
-npm pack --dry-run
+npm run verify:release
 ```
 
 ---

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -4,7 +4,7 @@ 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 { clearJarvisModelSelectionSetting, loadJarvisModelSelectionSetting, saveJarvisModelSelectionSetting } from "./jarvis-config.js";
+import { clearJarvisModelSelectionSetting, clearJarvisThinkingSelectionSetting, loadJarvisModelSelectionSetting, loadJarvisThinkingSelectionSetting, saveJarvisModelSelectionSetting, saveJarvisThinkingSelectionSetting, } from "./jarvis-config.js";
 import { JarvisSideSessionRuntime, createSideSessionFile } from "./side-session.js";
 class StaleJarvisBootError extends Error {
     constructor() {
@@ -25,6 +25,8 @@ export default function jarvisExtension(pi) {
         queuedMessages: [],
         jarvisModelSelection: { mode: "follow-main" },
         jarvisModelSelectionSource: "default",
+        jarvisThinkingSelection: { mode: "auto" },
+        jarvisThinkingSelectionSource: "default",
         systemPrompt: "",
         themeProvider: () => {
             throw new Error("/jarvis theme requested before UI was available.");
@@ -53,6 +55,7 @@ export default function jarvisExtension(pi) {
             await ctx.ui.custom((tui, theme, _keybindings, done) => {
                 state.themeProvider = () => theme;
                 const closeOverlay = () => {
+                    resetTransientAccessControls(state);
                     done(undefined);
                     queueMicrotask(() => tui.requestRender());
                 };
@@ -106,8 +109,8 @@ export default function jarvisExtension(pi) {
             const clearScopedSelection = async () => {
                 const previousSelection = state.jarvisModelSelection;
                 const previousSource = state.jarvisModelSelectionSource;
-                const projectSelection = scope === "project" ? undefined : loadJarvisModelSelectionSetting(ctx.cwd, "project");
-                const globalSelection = scope === "global" ? undefined : loadJarvisModelSelectionSetting(ctx.cwd, "global");
+                const projectSelection = scope === "project" ? undefined : loadJarvisModelSelectionForClear(ctx.cwd, "project", ctx);
+                const globalSelection = scope === "global" ? undefined : loadJarvisModelSelectionForClear(ctx.cwd, "global", ctx);
                 const resolvedSelection = resolveJarvisModelSelectionFromSettings(projectSelection, globalSelection, ctx.modelRegistry);
                 await applyJarvisModelSelection(state, resolvedSelection.selection);
                 try {
@@ -188,6 +191,90 @@ export default function jarvisExtension(pi) {
             await pinSelectedModel(selectedModel);
         },
     });
+    pi.registerCommand("jarvis-thinking", {
+        description: "Set the thinking level used by /jarvis without changing the main agent thinking level",
+        handler: async (args, ctx) => {
+            updateContextState(pi, state, ctx);
+            let parsedCommand;
+            try {
+                parsedCommand = parseJarvisThinkingCommand(args);
+            }
+            catch (error) {
+                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+                return;
+            }
+            const { request, scope, clearScope } = parsedCommand;
+            const scopeLabel = formatJarvisModelSelectionScope(scope);
+            const rollbackSelection = async (previousSelection, previousSource) => {
+                await applyJarvisThinkingSelection(state, previousSelection);
+                state.jarvisThinkingSelectionSource = previousSource;
+            };
+            const persistSelection = async (selection) => {
+                const previousSelection = state.jarvisThinkingSelection;
+                const previousSource = state.jarvisThinkingSelectionSource;
+                await applyJarvisThinkingSelection(state, selection);
+                try {
+                    saveJarvisThinkingSelectionSetting(ctx.cwd, scope, selection);
+                    state.jarvisThinkingSelectionSource = scope;
+                }
+                catch (error) {
+                    await rollbackSelection(previousSelection, previousSource);
+                    throw error;
+                }
+            };
+            const clearScopedSelection = async () => {
+                const previousSelection = state.jarvisThinkingSelection;
+                const previousSource = state.jarvisThinkingSelectionSource;
+                const projectSelection = scope === "project" ? undefined : loadJarvisThinkingSelectionForClear(ctx.cwd, "project", ctx);
+                const globalSelection = scope === "global" ? undefined : loadJarvisThinkingSelectionForClear(ctx.cwd, "global", ctx);
+                const resolvedSelection = resolveJarvisThinkingSelectionFromSettings(projectSelection, globalSelection);
+                await applyJarvisThinkingSelection(state, resolvedSelection.selection);
+                try {
+                    clearJarvisThinkingSelectionSetting(ctx.cwd, scope);
+                    state.jarvisThinkingSelectionSource = resolvedSelection.source;
+                    return resolvedSelection;
+                }
+                catch (error) {
+                    await rollbackSelection(previousSelection, previousSource);
+                    throw error;
+                }
+            };
+            if (clearScope) {
+                try {
+                    await clearScopedSelection();
+                }
+                catch (error) {
+                    ctx.ui.notify(`Failed to clear the /jarvis thinking setting ${scopeLabel}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    return;
+                }
+                ctx.ui.notify(`Cleared the /jarvis thinking setting ${scopeLabel}. /jarvis is now ${describeJarvisThinkingSelection(state)}.`, "info");
+                return;
+            }
+            const normalizedRequest = request.toLowerCase();
+            let selection;
+            if (normalizedRequest === "auto") {
+                selection = { mode: "auto" };
+            }
+            else if (normalizedRequest === "follow-main") {
+                selection = { mode: "follow-main" };
+            }
+            else if (isJarvisThinkingLevel(normalizedRequest)) {
+                selection = { mode: "pinned", thinkingLevel: normalizedRequest };
+            }
+            if (!selection) {
+                ctx.ui.notify(`/jarvis is ${describeJarvisThinkingSelection(state)}. Use /jarvis-thinking [--project|--global] clear, auto, follow-main, off, minimal, low, medium, high, or xhigh.`, request ? "error" : "info");
+                return;
+            }
+            try {
+                await persistSelection(selection);
+            }
+            catch (error) {
+                ctx.ui.notify(`Failed to set /jarvis thinking ${scopeLabel}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                return;
+            }
+            ctx.ui.notify(`Set /jarvis thinking to ${formatJarvisThinkingSelection(selection)} ${scopeLabel}. Effective /jarvis thinking is ${getDesiredJarvisThinkingLevel(state) ?? "off"}.`, "info");
+        },
+    });
     pi.on("session_start", async (_event, ctx) => {
         state.bootGeneration += 1;
         state.runtime?.dispose();
@@ -206,11 +293,20 @@ export default function jarvisExtension(pi) {
             selection: { mode: "follow-main" },
             source: "default",
         };
+        let resolvedThinkingSelection = {
+            selection: { mode: "auto" },
+            source: "default",
+        };
         resolvedSelection = resolveConfiguredJarvisModelSelection(ctx.cwd, ctx.modelRegistry, (scope, error) => {
             ctx.ui.notify(`Failed to load the ${scope} /jarvis model setting: ${error instanceof Error ? error.message : String(error)}`, "error");
         });
+        resolvedThinkingSelection = resolveConfiguredJarvisThinkingSelection(ctx.cwd, (scope, error) => {
+            ctx.ui.notify(`Failed to load the ${scope} /jarvis thinking setting: ${error instanceof Error ? error.message : String(error)}`, "error");
+        });
         state.jarvisModelSelection = resolvedSelection.selection;
         state.jarvisModelSelectionSource = resolvedSelection.source;
+        state.jarvisThinkingSelection = resolvedThinkingSelection.selection;
+        state.jarvisThinkingSelectionSource = resolvedThinkingSelection.source;
         updateContextState(pi, state, ctx);
         enforceCompatibilityGuard(state);
         if (resolvedSelection.unavailable) {
@@ -259,7 +355,8 @@ export default function jarvisExtension(pi) {
         state.mainSession.handleModelSelect(formatModelLabel(event.model));
         refreshMainContext(state);
         enforceCompatibilityGuard(state);
-        if (!state.runtime || state.jarvisModelSelection.mode !== "follow-main") {
+        if (!state.runtime ||
+            (state.jarvisModelSelection.mode !== "follow-main" && state.jarvisThinkingSelection.mode !== "follow-main")) {
             return;
         }
         try {
@@ -279,6 +376,8 @@ export default function jarvisExtension(pi) {
         state.lastJarvisSeenMainContext = undefined;
         state.jarvisModelSelection = { mode: "follow-main" };
         state.jarvisModelSelectionSource = "default";
+        state.jarvisThinkingSelection = { mode: "auto" };
+        state.jarvisThinkingSelectionSource = "default";
         state.allowSideTools = false;
         state.allowFollowUpToMain = false;
         state.allowSteerToMain = false;
@@ -301,6 +400,12 @@ function updateContextState(pi, state, ctx) {
 function refreshMainContext(state) {
     state.mainContext = buildMainSessionContext(state.mainSession.snapshot());
 }
+function resetTransientAccessControls(state) {
+    state.allowSideTools = false;
+    state.allowFollowUpToMain = false;
+    state.allowSteerToMain = false;
+    state.runtime?.setToolAccessEnabled(false);
+}
 function getDesiredJarvisModel(state) {
     return state.jarvisModelSelection.mode === "pinned" ? state.jarvisModelSelection.model : state.model;
 }
@@ -309,6 +414,12 @@ function getDesiredJarvisThinkingLevel(state) {
     if (desiredModel?.provider === "xai") {
         return "off";
     }
+    if (state.jarvisThinkingSelection.mode === "pinned") {
+        return state.jarvisThinkingSelection.thinkingLevel;
+    }
+    if (state.jarvisThinkingSelection.mode === "follow-main") {
+        return state.thinkingLevel;
+    }
     return state.jarvisModelSelection.mode === "follow-main" ? state.thinkingLevel : "off";
 }
 function toStoredJarvisModelSelection(selection) {
@@ -351,6 +462,30 @@ function parseJarvisModelCommand(args) {
         clearScope: request.toLowerCase() === "clear",
     };
 }
+function parseJarvisThinkingCommand(args) {
+    const parsed = parseJarvisModelCommand(args);
+    return {
+        request: parsed.request,
+        scope: parsed.scope,
+        clearScope: parsed.clearScope,
+    };
+}
+function isJarvisThinkingLevel(value) {
+    return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+}
+function formatJarvisThinkingSelection(selection) {
+    if (selection.mode === "auto") {
+        return "auto";
+    }
+    if (selection.mode === "follow-main") {
+        return "follow-main";
+    }
+    return selection.thinkingLevel;
+}
+function describeJarvisThinkingSelection(state) {
+    const sourceLabel = formatJarvisModelSelectionSource(state.jarvisThinkingSelectionSource);
+    return `thinking ${formatJarvisThinkingSelection(state.jarvisThinkingSelection)} (effective ${getDesiredJarvisThinkingLevel(state) ?? "off"}; ${sourceLabel})`;
+}
 function resolveStoredJarvisModelSelection(storedSelection, source, modelRegistry) {
     if (storedSelection.mode === "follow-main") {
         return {
@@ -416,6 +551,50 @@ function resolveConfiguredJarvisModelSelection(cwd, modelRegistry, onScopeError)
     }
     return resolveJarvisModelSelectionFromSettings(projectSelection, globalSelection, modelRegistry);
 }
+function resolveJarvisThinkingSelectionFromSettings(projectSelection, globalSelection) {
+    if (projectSelection) {
+        return { selection: projectSelection, source: "project" };
+    }
+    if (globalSelection) {
+        return { selection: globalSelection, source: "global" };
+    }
+    return { selection: { mode: "auto" }, source: "default" };
+}
+function resolveConfiguredJarvisThinkingSelection(cwd, onScopeError) {
+    let projectSelection;
+    let globalSelection;
+    try {
+        projectSelection = loadJarvisThinkingSelectionSetting(cwd, "project");
+    }
+    catch (error) {
+        onScopeError?.("project", error);
+    }
+    try {
+        globalSelection = loadJarvisThinkingSelectionSetting(cwd, "global");
+    }
+    catch (error) {
+        onScopeError?.("global", error);
+    }
+    return resolveJarvisThinkingSelectionFromSettings(projectSelection, globalSelection);
+}
+function loadJarvisModelSelectionForClear(cwd, scope, ctx) {
+    try {
+        return loadJarvisModelSelectionSetting(cwd, scope);
+    }
+    catch (error) {
+        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis model setting while clearing the requested scope: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        return undefined;
+    }
+}
+function loadJarvisThinkingSelectionForClear(cwd, scope, ctx) {
+    try {
+        return loadJarvisThinkingSelectionSetting(cwd, scope);
+    }
+    catch (error) {
+        ctx.ui.notify(`Ignoring malformed ${scope} /jarvis thinking setting while clearing the requested scope: ${error instanceof Error ? error.message : String(error)}`, "warning");
+        return undefined;
+    }
+}
 function isModelBridgeCompatible(model) {
     if (!model) {
         return true;
@@ -509,6 +688,54 @@ async function applyJarvisModelSelection(state, selection) {
         throw error;
     }
 }
+async function applyJarvisThinkingSelection(state, selection) {
+    const previousSelection = state.jarvisThinkingSelection;
+    state.jarvisThinkingSelection = selection;
+    try {
+        await syncRuntimeModelSelection(state);
+    }
+    catch (error) {
+        state.jarvisThinkingSelection = previousSelection;
+        try {
+            await syncRuntimeModelSelection(state);
+        }
+        catch {
+            // Keep the original sync failure; rollback is best-effort only.
+        }
+        throw error;
+    }
+}
+async function executeJarvisSideCommand(pi, state, ctx, runtime, command) {
+    if (command.name === "compact") {
+        await runtime.compactJarvisContext(command.customInstructions);
+        return runtime;
+    }
+    if (command.name === "tree") {
+        if (!command.targetId) {
+            runtime.addSystemMessage(runtime.describeSessionTree());
+            return runtime;
+        }
+        await runtime.navigateSessionTree(command.targetId, {
+            summarize: command.summarize,
+            customInstructions: command.customInstructions,
+        });
+        return runtime;
+    }
+    state.bootGeneration += 1;
+    state.runtime?.dispose();
+    state.runtime = undefined;
+    state.bootPromise = undefined;
+    state.flushPromise = undefined;
+    state.lastJarvisSeenMainContext = undefined;
+    resetTransientAccessControls(state);
+    const sessionFile = await createSideSessionFile(ctx.cwd);
+    const sessionRef = createJarvisSessionRef(sessionFile);
+    state.sessionRef = sessionRef;
+    pi.appendEntry(JARVIS_SESSION_REF_CUSTOM_TYPE, sessionRef);
+    const nextRuntime = await ensureRuntime(pi, state, ctx);
+    nextRuntime.addSystemMessage("Started a new /jarvis side session.");
+    return nextRuntime;
+}
 function normalizeInitialMessage(args) {
     const message = args.trim();
     return message.length > 0 ? message : undefined;
@@ -516,6 +743,38 @@ function normalizeInitialMessage(args) {
 function queueMessage(state, message) {
     state.queuedMessages.push(message);
 }
+function parseJarvisSideCommand(message) {
+    const text = message.trim();
+    if (text === "/new") {
+        return { name: "new" };
+    }
+    if (text === "/compact") {
+        return { name: "compact" };
+    }
+    if (text.startsWith("/compact ")) {
+        return { name: "compact", customInstructions: text.slice("/compact ".length).trim() || undefined };
+    }
+    if (text === "/tree") {
+        return { name: "tree", summarize: false };
+    }
+    if (text.startsWith("/tree ")) {
+        const args = text.slice("/tree ".length).trim();
+        const summarizePrefix = "--summarize ";
+        if (args.startsWith(summarizePrefix)) {
+            const rest = args.slice(summarizePrefix.length).trim();
+            const [targetId, ...instructionTokens] = rest.split(/\s+/).filter(Boolean);
+            return {
+                name: "tree",
+                targetId,
+                summarize: true,
+                customInstructions: instructionTokens.join(" ").trim() || undefined,
+            };
+        }
+        const [targetId] = args.split(/\s+/).filter(Boolean);
+        return { name: "tree", targetId, summarize: false };
+    }
+    return undefined;
+}
 function createOverlayView(pi, state, ctx) {
     const syncToolAccess = () => {
         state.runtime?.setToolAccessEnabled(state.allowSideTools);
@@ -610,6 +869,9 @@ function formatMainContextDeltaLabel(previousContext, currentContext) {
     if (currentContext.summary.latestUserRequest && currentContext.summary.latestUserRequest !== previousContext.summary.latestUserRequest) {
         return `request → ${currentContext.summary.latestUserRequest}`;
     }
+    if (currentContext.summary.latestAssistantText && currentContext.summary.latestAssistantText !== previousContext.summary.latestAssistantText) {
+        return `assistant → ${currentContext.summary.latestAssistantText}`;
+    }
     return "no significant change";
 }
 async function flushQueuedMessages(pi, state, ctx) {
@@ -624,17 +886,24 @@ async function flushQueuedMessages(pi, state, ctx) {
     // rethrowing.
     state.flushPromise = (async () => {
         try {
-            const runtime = await ensureRuntime(pi, state, ctx);
+            let runtime = await ensureRuntime(pi, state, ctx);
             await runtime.syncModel(getDesiredJarvisModel(state), getDesiredJarvisThinkingLevel(state));
             while (state.queuedMessages.length > 0) {
                 const message = state.queuedMessages[0];
+                const command = parseJarvisSideCommand(message);
                 try {
-                    await runtime.sendMessage(message);
+                    if (command) {
+                        runtime = await executeJarvisSideCommand(pi, state, ctx, runtime, command);
+                    }
+                    else {
+                        await runtime.sendMessage(message);
+                        state.lastJarvisSeenMainContext = state.mainContext;
+                    }
                     state.queuedMessages.shift();
-                    state.lastJarvisSeenMainContext = state.mainContext;
                 }
                 catch (error) {
-                    state.bridge.notify(`Failed to send /jarvis message: ${error instanceof Error ? error.message : String(error)}`, "error");
+                    const action = command ? `run ${message.split(/\s+/, 1)[0]}` : "send /jarvis message";
+                    state.bridge.notify(`Failed to ${action}: ${error instanceof Error ? error.message : String(error)}`, "error");
                     break;
                 }
             }