pzero-operator 0.1.7 → 0.1.8

package/dist/core/agent-session.js

@@ -52,9 +52,9 @@ export function parseSkillBlock(text) {
 // Constants
 // ============================================================================
 /** Standard thinking levels */
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const THINKING_LEVELS = ["off", "low", "medium", "high"];
 /** Thinking levels including xhigh (for supported models) */
-const THINKING_LEVELS_WITH_XHIGH = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const THINKING_LEVELS_WITH_XHIGH = ["off", "low", "medium", "high", "xhigh"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -1887,7 +1887,7 @@ export class AgentSession {
         this._applyExtensionBindings(this._extensionRunner);
         const defaultActiveToolNames = this._baseToolsOverride
             ? Object.keys(this._baseToolsOverride)
-            : ["read", "bash", "edit", "write"];
+            : ["read", "bash", "edit", "write", "web_search"];
         const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
         this._refreshToolRegistry({
             activeToolNames: baseActiveToolNames,

package/dist/core/keybindings.js

@@ -25,6 +25,7 @@ export const KEYBINDINGS = {
     },
     "app.model.select": { defaultKeys: "ctrl+l", description: "Open model selector" },
     "app.tools.expand": { defaultKeys: "ctrl+o", description: "Toggle tool output" },
+    "app.history.full": { defaultKeys: "ctrl+r", description: "Toggle full conversation view" },
     "app.thinking.toggle": {
         defaultKeys: "ctrl+t",
         description: "Toggle thinking blocks",

package/dist/core/sdk.js

@@ -13,12 +13,12 @@ import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
 import { SettingsManager } from "./settings-manager.js";
 import { isInstallTelemetryEnabled } from "./telemetry.js";
 import { time } from "./timings.js";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
+import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWebSearchTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
 // Re-exports
 export * from "./agent-session-runtime.js";
 export { withFileMutationQueue, 
 // Tool factories (for custom cwd)
-createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, createWebSearchTool, };
 // Helper Functions
 function getDefaultAgentDir() {
     return getAgentDir();
@@ -135,7 +135,7 @@ export async function createAgentSession(options = {}) {
     if (!model || !model.reasoning) {
         thinkingLevel = "off";
     }
-    const defaultActiveToolNames = ["read", "bash", "edit", "write"];
+    const defaultActiveToolNames = ["read", "bash", "edit", "write", "web_search"];
     const initialActiveToolNames = options.tools ? [...options.tools] : defaultActiveToolNames;
     let agent;
     // Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)

package/dist/core/system-prompt.js

@@ -45,7 +45,7 @@ export function buildSystemPrompt(options) {
     const examplesPath = getExamplesPath();
     // Build tools list based on selected tools.
     // A tool appears in Available tools only when the caller provides a one-line snippet.
-    const tools = selectedTools || ["read", "bash", "edit", "write"];
+    const tools = selectedTools || ["read", "bash", "edit", "write", "web_search"];
     const visibleTools = tools.filter((name) => !!toolSnippets?.[name]);
     const toolsList = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
     // Build guidelines based on which tools are actually available
@@ -63,6 +63,7 @@ export function buildSystemPrompt(options) {
     const hasFind = tools.includes("find");
     const hasLs = tools.includes("ls");
     const hasRead = tools.includes("read");
+    const hasWebSearch = tools.includes("web_search");
     // File exploration guidelines
     if (hasBash && !hasGrep && !hasFind && !hasLs) {
         addGuideline("Use bash for file operations like ls, rg, find");
@@ -70,6 +71,9 @@ export function buildSystemPrompt(options) {
     else if (hasBash && (hasGrep || hasFind || hasLs)) {
         addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)");
     }
+    if (hasWebSearch) {
+        addGuideline("Use web_search for current external information, public docs, and recent web content.");
+    }
     for (const guideline of promptGuidelines ?? []) {
         const normalized = guideline.trim();
         if (normalized.length > 0) {

package/dist/core/tools/index.js

@@ -6,6 +6,7 @@ export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
+export { createWebSearchTool, createWebSearchToolDefinition, } from "./web-search.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
 import { createBashTool, createBashToolDefinition } from "./bash.js";
 import { createEditTool, createEditToolDefinition } from "./edit.js";
@@ -13,8 +14,9 @@ import { createFindTool, createFindToolDefinition } from "./find.js";
 import { createGrepTool, createGrepToolDefinition } from "./grep.js";
 import { createLsTool, createLsToolDefinition } from "./ls.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
+import { createWebSearchTool, createWebSearchToolDefinition } from "./web-search.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "web_search"]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":
@@ -31,6 +33,8 @@ export function createToolDefinition(toolName, cwd, options) {
             return createFindToolDefinition(cwd, options?.find);
         case "ls":
             return createLsToolDefinition(cwd, options?.ls);
+        case "web_search":
+            return createWebSearchToolDefinition(cwd, options?.web_search);
         default:
             throw new Error(`Unknown tool name: ${toolName}`);
     }
@@ -51,6 +55,8 @@ export function createTool(toolName, cwd, options) {
             return createFindTool(cwd, options?.find);
         case "ls":
             return createLsTool(cwd, options?.ls);
+        case "web_search":
+            return createWebSearchTool(cwd, options?.web_search);
         default:
             throw new Error(`Unknown tool name: ${toolName}`);
     }
@@ -61,6 +67,7 @@ export function createCodingToolDefinitions(cwd, options) {
         createBashToolDefinition(cwd, options?.bash),
         createEditToolDefinition(cwd, options?.edit),
         createWriteToolDefinition(cwd, options?.write),
+        createWebSearchToolDefinition(cwd, options?.web_search),
     ];
 }
 export function createReadOnlyToolDefinitions(cwd, options) {
@@ -80,6 +87,7 @@ export function createAllToolDefinitions(cwd, options) {
         grep: createGrepToolDefinition(cwd, options?.grep),
         find: createFindToolDefinition(cwd, options?.find),
         ls: createLsToolDefinition(cwd, options?.ls),
+        web_search: createWebSearchToolDefinition(cwd, options?.web_search),
     };
 }
 export function createCodingTools(cwd, options) {
@@ -88,6 +96,7 @@ export function createCodingTools(cwd, options) {
         createBashTool(cwd, options?.bash),
         createEditTool(cwd, options?.edit),
         createWriteTool(cwd, options?.write),
+        createWebSearchTool(cwd, options?.web_search),
     ];
 }
 export function createReadOnlyTools(cwd, options) {
@@ -107,6 +116,7 @@ export function createAllTools(cwd, options) {
         grep: createGrepTool(cwd, options?.grep),
         find: createFindTool(cwd, options?.find),
         ls: createLsTool(cwd, options?.ls),
+        web_search: createWebSearchTool(cwd, options?.web_search),
     };
 }
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/tools/web-search.js

@@ -0,0 +1,162 @@
+import { Text } from "@operator/tui";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { Type } from "typebox";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { getTextOutput, invalidArgText, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+const WEB_SEARCH_HELPER = `${process.env.HOME || ""}/.tools/web_search/search.cjs`;
+const webSearchSchema = Type.Object({
+    query: Type.Optional(Type.String({ description: "Search query for full, ddg, instant, or wiki modes" })),
+    url: Type.Optional(Type.String({ description: "Page URL to extract when mode is 'page'" })),
+    mode: Type.Optional(Type.Union([
+        Type.Literal("full"),
+        Type.Literal("ddg"),
+        Type.Literal("instant"),
+        Type.Literal("wiki"),
+        Type.Literal("page"),
+    ], { description: "Search mode (default: full)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of results for ddg/wiki/full (default: 5)" })),
+});
+function formatWebSearchCall(args, theme) {
+    const mode = str(args?.mode) || "full";
+    const query = str(args?.query);
+    const url = str(args?.url);
+    const target = mode === "page" ? url : query;
+    const invalidArg = invalidArgText(theme);
+    return `${theme.fg("toolTitle", theme.bold("web.search"))} ${theme.fg("toolOutput", `[${mode}] `)}${target === null ? invalidArg : theme.fg("accent", target || "...")}`;
+}
+function formatWebSearchResult(result, options, theme, showImages) {
+    const output = getTextOutput(result, showImages).trim();
+    if (!output) {
+        return "";
+    }
+    const lines = output.split("\n");
+    const maxLines = options.expanded ? lines.length : 20;
+    const displayLines = lines.slice(0, maxLines);
+    const remaining = lines.length - maxLines;
+    let text = `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+    if (remaining > 0) {
+        text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")})`;
+    }
+    const truncation = result.details?.truncation;
+    if (truncation?.truncated) {
+        text += `\n${theme.fg("warning", `[Truncated: ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit]`)}`;
+    }
+    return text;
+}
+export function createWebSearchToolDefinition(_cwd, _options) {
+    return {
+        name: "web_search",
+        label: "web.search",
+        description: `Search the web using DuckDuckGo and Wikipedia, or extract readable text from a web page. Best for current external information, documentation, and quick validation. Output is truncated to ${DEFAULT_MAX_BYTES / 1024}KB if needed.`,
+        promptSnippet: "Search the web for current external information or extract text from a URL",
+        promptGuidelines: [
+            "Use web_search when the user asks for current external information, recent updates, or public web content.",
+        ],
+        parameters: webSearchSchema,
+        async execute(_toolCallId, { query, url, mode, limit }, signal, _onUpdate, _ctx) {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                if (!existsSync(WEB_SEARCH_HELPER)) {
+                    reject(new Error(`Web search helper not found: ${WEB_SEARCH_HELPER}`));
+                    return;
+                }
+                const effectiveMode = mode || "full";
+                const target = effectiveMode === "page" ? url : query;
+                if (!target) {
+                    reject(new Error(effectiveMode === "page" ? "url is required for page mode" : "query is required for search mode"));
+                    return;
+                }
+                const args = [WEB_SEARCH_HELPER, "--json"];
+                if (effectiveMode === "page") {
+                    args.push("--page", target);
+                }
+                else if (effectiveMode === "ddg") {
+                    args.push("--ddg", target);
+                }
+                else if (effectiveMode === "instant") {
+                    args.push("--instant", target);
+                }
+                else if (effectiveMode === "wiki") {
+                    args.push("--wiki", target);
+                }
+                else {
+                    args.push(target);
+                }
+                if (limit !== undefined && effectiveMode !== "page" && effectiveMode !== "instant") {
+                    args.push("--limit", String(limit));
+                }
+                const child = spawn(process.execPath, args, {
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                let stdout = "";
+                let stderr = "";
+                let settled = false;
+                const settle = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal?.removeEventListener("abort", onAbort);
+                    fn();
+                };
+                const onAbort = () => {
+                    if (!child.killed) {
+                        child.kill();
+                    }
+                    settle(() => reject(new Error("Operation aborted")));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                child.stdout?.on("data", (chunk) => {
+                    stdout += chunk.toString();
+                });
+                child.stderr?.on("data", (chunk) => {
+                    stderr += chunk.toString();
+                });
+                child.on("error", (error) => {
+                    settle(() => reject(new Error(`Failed to run web search helper: ${error.message}`)));
+                });
+                child.on("close", (code) => {
+                    if (signal?.aborted) {
+                        settle(() => reject(new Error("Operation aborted")));
+                        return;
+                    }
+                    if (code !== 0) {
+                        settle(() => reject(new Error(stderr.trim() || `web_search exited with code ${code}`)));
+                        return;
+                    }
+                    const output = stdout.trim();
+                    if (!output) {
+                        settle(() => resolve({
+                            content: [{ type: "text", text: "No web search results returned" }],
+                            details: undefined,
+                        }));
+                        return;
+                    }
+                    const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
+                    settle(() => resolve({
+                        content: [{ type: "text", text: truncation.content }],
+                        details: truncation.truncated ? { truncation } : undefined,
+                    }));
+                });
+            });
+        },
+        renderCall(args, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatWebSearchCall(args, theme));
+            return text;
+        },
+        renderResult(result, options, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatWebSearchResult(result, options, theme, context.showImages));
+            return text;
+        },
+    };
+}
+export function createWebSearchTool(cwd, options) {
+    return wrapToolDefinition(createWebSearchToolDefinition(cwd, options));
+}

package/dist/migrations.js

@@ -16,7 +16,7 @@ const DEFAULT_MODELS_CONFIG = {
             authHeader: true,
             compat: {
                 supportsDeveloperRole: true,
-                supportsReasoningEffort: false,
+                supportsReasoningEffort: true,
             },
             models: [
                 {
@@ -32,13 +32,14 @@ const DEFAULT_MODELS_CONFIG = {
             authHeader: true,
             compat: {
                 supportsDeveloperRole: true,
-                supportsReasoningEffort: false,
+                supportsReasoningEffort: true,
             },
             models: [
                 {
                     id: "qwen3-6",
                     name: "qwen3.6 27b",
                     reasoning: true,
+                    input: ["text", "image"],
                 },
             ],
         },
@@ -48,13 +49,14 @@ const DEFAULT_MODELS_CONFIG = {
             authHeader: true,
             compat: {
                 supportsDeveloperRole: true,
-                supportsReasoningEffort: false,
+                supportsReasoningEffort: true,
             },
             models: [
                 {
                     id: "gemma4",
                     name: "gemma4",
                     reasoning: true,
+                    input: ["text", "image"],
                 },
             ],
         },
@@ -110,8 +112,8 @@ function migrateAlemBaseUrls() {
             if (!gptOssProvider.compat || typeof gptOssProvider.compat !== "object") {
                 gptOssProvider.compat = {};
             }
-            if (gptOssProvider.compat.supportsReasoningEffort !== false) {
-                gptOssProvider.compat.supportsReasoningEffort = false;
+            if (gptOssProvider.compat.supportsReasoningEffort !== true) {
+                gptOssProvider.compat.supportsReasoningEffort = true;
                 changed = true;
             }
         }
@@ -126,6 +128,31 @@ function migrateAlemBaseUrls() {
                 provider.baseUrl = "https://llm.alem.ai/v1";
                 changed = true;
             }
+            if (!provider.compat || typeof provider.compat !== "object") {
+                provider.compat = {};
+            }
+            if (provider.compat.supportsReasoningEffort !== true) {
+                provider.compat.supportsReasoningEffort = true;
+                changed = true;
+            }
+            if (Array.isArray(provider.models)) {
+                for (const model of provider.models) {
+                    if (!model || typeof model !== "object") {
+                        continue;
+                    }
+                    if (!model.compat || typeof model.compat !== "object") {
+                        model.compat = {};
+                    }
+                    if (model.compat.supportsReasoningEffort !== true) {
+                        model.compat.supportsReasoningEffort = true;
+                        changed = true;
+                    }
+                    if (model.reasoning !== true) {
+                        model.reasoning = true;
+                        changed = true;
+                    }
+                }
+            }
         }
         if (changed) {
             writeFileSync(modelsPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf-8");

package/dist/modes/interactive/components/footer.js

@@ -134,7 +134,7 @@ export class FooterComponent {
         if (state.model?.reasoning) {
             const thinkingLevel = state.thinkingLevel || "off";
             rightSideWithoutProvider =
-                thinkingLevel === "off" ? `${modelName} | reasoning off` : `${modelName} | reasoning ${thinkingLevel}`;
+                thinkingLevel === "off" ? `${modelName} | reasoning fast` : `${modelName} | reasoning ${thinkingLevel}`;
         }
         const providerName = state.model?.provider || "none";
         const sessionValue = sessionName || "unnamed";

package/dist/modes/interactive/components/thinking-selector.js

@@ -6,11 +6,10 @@ const THINKING_SELECT_LIST_LAYOUT = {
     maxPrimaryColumnWidth: 32,
 };
 const LEVEL_DESCRIPTIONS = {
-    off: "No analysis pass",
-    minimal: "Tiny analysis pass (~1k tokens)",
-    low: "Light analysis pass (~2k tokens)",
-    medium: "Balanced analysis pass (~8k tokens)",
-    high: "Deep analysis pass (~16k tokens)",
+    off: "Fast mode. Direct output, lowest latency.",
+    low: "Light analysis. Quick check before answering.",
+    medium: "Balanced analysis. Best default for most tasks.",
+    high: "Deep analysis. Slower, but stronger reasoning.",
     xhigh: "Maximum analysis pass (~32k tokens)",
 };
 /**
@@ -22,7 +21,7 @@ export class ThinkingSelectorComponent extends Container {
         super();
         const thinkingLevels = availableLevels.map((level) => ({
             value: level,
-            label: level,
+            label: level === "off" ? "fast" : level,
             description: LEVEL_DESCRIPTIONS[level],
         }));
         // Add top border

package/dist/modes/interactive/interactive-mode.js

@@ -6,7 +6,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@operator/tui";
+import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, truncateToWidth, visibleWidth, } from "@operator/tui";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, getAgentDir, getDebugLogPath, getShareViewerUrl, getUpdateInstruction, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
@@ -24,6 +24,7 @@ import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/cha
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
 import { parseGitUrl } from "../../utils/git.js";
+import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { ArminComponent } from "./components/armin.js";
@@ -89,6 +90,133 @@ class StartupHeroText extends Text {
         clearInterval(this.interval);
     }
 }
+function fitLine(line, width) {
+    const fitted = truncateToWidth(line ?? "", Math.max(0, width), theme.fg("dim", "..."));
+    const padding = Math.max(0, width - visibleWidth(fitted));
+    return fitted + " ".repeat(padding);
+}
+function framedLines(lines, width, title = " OPERATOR ") {
+    if (width < 8)
+        return lines;
+    const innerWidth = Math.max(1, width - 4);
+    const titleText = truncateToWidth(title, Math.max(0, innerWidth - 2), "");
+    const topFill = Math.max(0, width - 3 - visibleWidth(titleText));
+    const top = theme.fg("borderAccent", "┌") + theme.bold(theme.fg("accent", titleText)) + theme.fg("borderAccent", "─".repeat(topFill) + "┐");
+    const bottom = theme.fg("borderAccent", "└" + "─".repeat(width - 2) + "┘");
+    return [
+        top,
+        ...lines.map((line) => theme.fg("borderAccent", "│ ") + fitLine(line, innerWidth) + theme.fg("borderAccent", " │")),
+        bottom,
+    ];
+}
+function formatTokensCompact(count) {
+    if (!count)
+        return "0";
+    if (count < 1000)
+        return String(count);
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    return `${(count / 1000000).toFixed(1)}M`;
+}
+function renderGauge(value, width) {
+    const pct = Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : 0;
+    const slots = Math.max(6, Math.min(18, width - 10));
+    const filled = Math.round((slots * pct) / 100);
+    return `[${theme.fg("borderAccent", "█".repeat(filled))}${theme.fg("dim", "░".repeat(slots - filled))}] ${pct.toFixed(1)}%`;
+}
+function getSpinnerFrame(frame) {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    return frames[frame % frames.length] || "•";
+}
+function formatReasoningLevel(level) {
+    const normalized = level === "low" || level === "medium" || level === "high" ? level : "off";
+    if (normalized === "low")
+        return `${theme.fg("success", "[LOW]")} ${theme.fg("success", "•")} ${theme.fg("dim", "light analysis")}`;
+    if (normalized === "medium")
+        return `${theme.fg("warning", "[MEDIUM]")} ${theme.fg("warning", "••")} ${theme.fg("dim", "balanced depth")}`;
+    if (normalized === "high")
+        return `${theme.fg("error", "[HIGH]")} ${theme.fg("error", "•••")} ${theme.fg("dim", "deep reasoning")}`;
+    return `${theme.fg("accent", "[FAST]")} ${theme.fg("accent", "⚡")} ${theme.fg("dim", "direct output")}`;
+}
+function formatReasoningLegend() {
+    return [
+        `${theme.fg("accent", "FAST")} ${theme.fg("dim", "⚡")}`,
+        `${theme.fg("success", "LOW")} ${theme.fg("success", "•")}`,
+        `${theme.fg("warning", "MED")} ${theme.fg("warning", "••")}`,
+        `${theme.fg("error", "HIGH")} ${theme.fg("error", "•••")}`,
+    ].join(theme.fg("dim", "  "));
+}
+function displayThinkingLevel(level) {
+    return level === "off" ? "fast" : level;
+}
+class OperatorWorkspaceLayout {
+    mode;
+    frame = 0;
+    interval;
+    constructor(mode) {
+        this.mode = mode;
+        this.interval = setInterval(() => {
+            this.frame = (this.frame + 1) % 24;
+            this.mode.ui.requestRender();
+        }, 380);
+        this.interval.unref?.();
+    }
+    dispose() {
+        clearInterval(this.interval);
+    }
+    render(width) {
+        const terminalHeight = this.mode.ui.terminal.rows || 30;
+        const headerHeight = this.mode.headerContainer.render(width).length;
+        const outerFrame = width >= 72;
+        const contentWidth = outerFrame ? Math.max(1, width - 4) : width;
+        const maxRows = Math.max(8, terminalHeight - headerHeight - (outerFrame ? 2 : 0));
+        const renderBody = (bodyLines) => outerFrame ? framedLines(bodyLines, width, this.mode.fullHistoryView ? " OPERATOR / FULL CHAT " : " OPERATOR / WORKSPACE ") : bodyLines;
+        if (contentWidth < 96) {
+            const leftLines = this.clampLeftLines(this.renderLeft(contentWidth), maxRows);
+            return renderBody([
+                ...leftLines,
+                theme.fg("borderMuted", "─".repeat(Math.max(0, contentWidth))),
+                ...this.mode.renderOperatorSidebar(contentWidth).slice(0, Math.max(0, maxRows - leftLines.length - 1)),
+            ]);
+        }
+        const gutter = 3;
+        const leftWidth = Math.max(64, Math.floor(contentWidth * 0.65) - 1);
+        const rightWidth = Math.max(28, contentWidth - leftWidth - gutter);
+        const separator = theme.fg("borderMuted", " │ ");
+        const leftLines = this.clampLeftLines(this.renderLeft(leftWidth), maxRows);
+        const rightLines = this.mode.renderOperatorSidebar(rightWidth).slice(0, maxRows);
+        const rowCount = this.mode.fullHistoryView ? Math.max(maxRows, leftLines.length) : maxRows;
+        const rightStart = Math.max(0, rowCount - maxRows);
+        const lines = [];
+        for (let i = 0; i < rowCount; i++) {
+            const rightIndex = this.mode.fullHistoryView ? i - rightStart : i;
+            lines.push(fitLine(leftLines[i] ?? "", leftWidth) + separator + fitLine(rightLines[rightIndex] ?? "", rightWidth));
+        }
+        return renderBody(lines);
+    }
+    renderLeft(width) {
+        const components = [
+            this.mode.chatContainer,
+            this.mode.pendingMessagesContainer,
+            this.mode.statusContainer,
+            this.mode.widgetContainerAbove,
+            this.mode.editorDeckContainer,
+            this.mode.editorContainer,
+            this.mode.widgetContainerBelow,
+        ];
+        return components.flatMap((component) => component.render(width));
+    }
+    clampLeftLines(lines, maxRows) {
+        if (this.mode.fullHistoryView)
+            return lines;
+        if (lines.length <= maxRows)
+            return lines;
+        const marker = theme.fg("dim", `... ${lines.length - maxRows + 1} earlier lines hidden in current view ...`);
+        return [marker, ...lines.slice(-(maxRows - 1))];
+    }
+}
 function isUnknownModel(model) {
     return !!model && model.provider === "unknown" && model.id === "unknown" && model.api === "unknown";
 }
@@ -126,6 +254,7 @@ export class InteractiveMode {
     fdPath;
     editorDeckContainer;
     editorContainer;
+    workspaceLayout;
     footer;
     footerDataProvider;
     // Stored so the same manager can be injected into custom editors, selectors, and extension UI.
@@ -155,6 +284,7 @@ export class InteractiveMode {
     isFirstUserMessage = true;
     // Tool output expansion state
     toolOutputExpanded = false;
+    fullHistoryView = false;
     // Thinking block visibility state
     hideThinkingBlock = false;
     // Skill commands: command name -> skill file path
@@ -177,6 +307,7 @@ export class InteractiveMode {
     retryEscapeHandler;
     // Messages queued while compaction is running
     compactionQueuedMessages = [];
+    pendingImageAttachments = [];
     // Shutdown state
     shutdownRequested = false;
     // Extension UI state
@@ -238,6 +369,7 @@ export class InteractiveMode {
         this.editorDeckContainer = new Container();
         this.editorContainer = new Container();
         this.editorContainer.addChild(this.editor);
+        this.workspaceLayout = new OperatorWorkspaceLayout(this);
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = new FooterComponent(this.session, this.footerDataProvider);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
@@ -472,15 +604,8 @@ export class InteractiveMode {
             this.builtInHeader = new Text("", 0, 0);
             this.headerContainer.addChild(this.builtInHeader);
         }
-        this.ui.addChild(this.chatContainer);
-        this.ui.addChild(this.pendingMessagesContainer);
-        this.ui.addChild(this.statusContainer);
         this.renderWidgets(); // Initialize with default spacer
-        this.ui.addChild(this.widgetContainerAbove);
-        this.ui.addChild(this.editorDeckContainer);
-        this.ui.addChild(this.editorContainer);
-        this.ui.addChild(this.widgetContainerBelow);
-        this.ui.addChild(this.footer);
+        this.ui.addChild(this.workspaceLayout);
         this.ui.setFocus(this.editor);
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
@@ -591,7 +716,9 @@ export class InteractiveMode {
                     continue;
                 }
                 this.dismissStartupHero();
-                await this.session.prompt(userInput);
+                const text = typeof userInput === "string" ? userInput : userInput.text;
+                const images = typeof userInput === "string" ? undefined : userInput.images;
+                await this.session.prompt(text, { images });
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
@@ -1512,22 +1639,12 @@ export class InteractiveMode {
         if (this.customFooter?.dispose) {
             this.customFooter.dispose();
         }
-        // Remove current footer from UI
-        if (this.customFooter) {
-            this.ui.removeChild(this.customFooter);
-        }
-        else {
-            this.ui.removeChild(this.footer);
-        }
         if (factory) {
-            // Create and add custom footer, passing the data provider
+            // Custom footer is rendered inside the right sidebar.
             this.customFooter = factory(this.ui, theme, this.footerDataProvider);
-            this.ui.addChild(this.customFooter);
         }
         else {
-            // Restore built-in footer
             this.customFooter = undefined;
-            this.ui.addChild(this.footer);
         }
         this.ui.requestRender();
     }
@@ -1981,6 +2098,7 @@ export class InteractiveMode {
         this.ui.onDebug = () => this.handleDebugCommand();
         this.defaultEditor.onAction("app.model.select", () => this.showModelSelector());
         this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
+        this.defaultEditor.onAction("app.history.full", () => this.toggleFullHistoryView());
         this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
         this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
         this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
@@ -2007,14 +2125,15 @@ export class InteractiveMode {
             if (!image) {
                 return;
             }
-            // Write to temp file
-            const tmpDir = os.tmpdir();
             const ext = extensionForImageMimeType(image.mimeType) ?? "png";
-            const fileName = `operator-clipboard-${crypto.randomUUID()}.${ext}`;
-            const filePath = path.join(tmpDir, fileName);
-            fs.writeFileSync(filePath, Buffer.from(image.bytes));
-            // Insert file path directly
-            this.editor.insertTextAtCursor?.(filePath);
+            this.pendingImageAttachments.push({
+                type: "image",
+                data: Buffer.from(image.bytes).toString("base64"),
+                mimeType: image.mimeType,
+                filename: `clipboard-${crypto.randomUUID()}.${ext}`,
+            });
+            this.showStatus(`Image attached (${this.pendingImageAttachments.length})`);
+            this.updateEditorDeck();
             this.ui.requestRender();
         }
         catch {
@@ -2024,7 +2143,9 @@ export class InteractiveMode {
     setupEditorSubmitHandler() {
         this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
-            if (!text)
+            const { text: normalizedText, images } = await this.preparePromptPayload(text);
+            text = normalizedText;
+            if (!text && !images?.length)
                 return;
             if (DISABLED_SLASH_COMMANDS.has(text) || Array.from(DISABLED_SLASH_COMMANDS).some((command) => text.startsWith(`${command} `))) {
                 this.editor.setText("");
@@ -2059,28 +2180,30 @@ export class InteractiveMode {
                 }
                 const value = text.startsWith("/thinking ") ? text.slice(10).trim().toLowerCase() : "";
                 if (!value) {
-                    const selected = await this.showExtensionSelector("Select analysis depth", ["low", "medium", "high"]);
+                    const selected = await this.showExtensionSelector("Select analysis depth", ["fast", "low", "medium", "high"]);
                     if (!selected) {
                         this.showStatus("Analysis depth selection cancelled");
                         return;
                     }
-                    this.session.setThinkingLevel(selected);
+                    this.session.setThinkingLevel(selected === "fast" ? "off" : selected);
                     const after = this.session.thinkingLevel || "off";
                     this.footer.invalidate();
                     this.updateEditorBorderColor();
-                    this.showStatus(`Analysis depth: ${after}`);
+                    this.showStatus(`Analysis depth: ${displayThinkingLevel(after)}`);
                     return;
                 }
-                if (!["low", "medium", "high"].includes(value)) {
-                    this.showStatus("Use /thinking low, /thinking medium, or /thinking high");
+                if (!["fast", "low", "medium", "high"].includes(value)) {
+                    this.showStatus("Use /thinking fast, /thinking low, /thinking medium, or /thinking high");
                     return;
                 }
                 const before = this.session.thinkingLevel || "off";
-                this.session.setThinkingLevel(value);
+                this.session.setThinkingLevel(value === "fast" ? "off" : value);
                 const after = this.session.thinkingLevel || "off";
                 this.footer.invalidate();
                 this.updateEditorBorderColor();
-                this.showStatus(before === after ? `Analysis depth unchanged: ${after}` : `Analysis depth: ${after}`);
+                this.showStatus(before === after
+                    ? `Analysis depth unchanged: ${displayThinkingLevel(after)}`
+                    : `Analysis depth: ${displayThinkingLevel(after)}`);
                 return;
             }
             if (text === "/copy") {
@@ -2167,10 +2290,10 @@ export class InteractiveMode {
                 if (this.isExtensionCommand(text)) {
                     this.editor.addToHistory?.(text);
                     this.editor.setText("");
-                    await this.session.prompt(text);
+                    await this.session.prompt(text, { images });
                 }
                 else {
-                    this.queueCompactionMessage(text, "steer");
+                    this.queueCompactionMessage(text, "steer", images);
                 }
                 return;
             }
@@ -2179,7 +2302,7 @@ export class InteractiveMode {
             if (this.session.isStreaming) {
                 this.editor.addToHistory?.(text);
                 this.editor.setText("");
-                await this.session.prompt(text, { streamingBehavior: "steer" });
+                await this.session.prompt(text, { streamingBehavior: "steer", images });
                 this.updatePendingMessagesDisplay();
                 this.ui.requestRender();
                 return;
@@ -2188,9 +2311,11 @@ export class InteractiveMode {
             // First, move any pending bash components to chat
             this.flushPendingBashComponents();
             if (this.onInputCallback) {
-                this.onInputCallback(text);
+                this.onInputCallback({ text, images });
             }
             this.editor.addToHistory?.(text);
+            this.pendingImageAttachments = [];
+            this.updateEditorDeck();
         };
     }
     subscribeToAgent() {
@@ -2206,6 +2331,7 @@ export class InteractiveMode {
         switch (event.type) {
             case "agent_start":
                 this.ui.terminal.setProgress(true);
+                this.fullHistoryView = false;
                 // Restore main escape handler if retry handler is still active
                 // (retry success event fires later, but we need main handler now)
                 if (this.retryEscapeHandler) {
@@ -2483,7 +2609,11 @@ export class InteractiveMode {
         const textBlocks = typeof message.content === "string"
             ? [{ type: "text", text: message.content }]
             : message.content.filter((c) => c.type === "text");
-        return textBlocks.map((c) => c.text).join("");
+        const imageCount = typeof message.content === "string"
+            ? 0
+            : message.content.filter((c) => c.type === "image").length;
+        const text = textBlocks.map((c) => c.text).join("");
+        return imageCount > 0 ? `${text}\n\n[Attached images: ${imageCount}]` : text;
     }
     /**
      * Show a status message in the chat.
@@ -2670,6 +2800,50 @@ export class InteractiveMode {
             };
         });
     }
+    async buildImageAttachmentsFromPaths(text) {
+        const attachments = [];
+        const keptLines = [];
+        const lines = text.split("\n");
+        for (const line of lines) {
+            const candidate = line.trim();
+            if (!candidate) {
+                keptLines.push(line);
+                continue;
+            }
+            const resolvedPath = path.isAbsolute(candidate)
+                ? candidate
+                : path.resolve(this.sessionManager.getCwd(), candidate);
+            if (!fs.existsSync(resolvedPath)) {
+                keptLines.push(line);
+                continue;
+            }
+            const mimeType = await detectSupportedImageMimeTypeFromFile(resolvedPath).catch(() => null);
+            if (!mimeType) {
+                keptLines.push(line);
+                continue;
+            }
+            attachments.push({
+                type: "image",
+                data: fs.readFileSync(resolvedPath).toString("base64"),
+                mimeType,
+                filename: path.basename(resolvedPath),
+            });
+        }
+        return {
+            text: keptLines.join("\n").trim(),
+            images: attachments,
+        };
+    }
+    async preparePromptPayload(text) {
+        const pathAttachments = await this.buildImageAttachmentsFromPaths(text);
+        const images = [...this.pendingImageAttachments, ...pathAttachments.images];
+        this.pendingImageAttachments = [];
+        this.updateEditorDeck();
+        return {
+            text: pathAttachments.text || text,
+            images: images.length > 0 ? images : undefined,
+        };
+    }
     rebuildChatFromMessages() {
         this.chatContainer.clear();
         const context = this.sessionManager.buildSessionContext();
@@ -2779,33 +2953,36 @@ export class InteractiveMode {
     }
     async handleFollowUp() {
         const text = (this.editor.getExpandedText?.() ?? this.editor.getText()).trim();
-        if (!text)
+        if (!text && this.pendingImageAttachments.length === 0)
+            return;
+        if (!this.session.isStreaming && !this.session.isCompacting) {
+            if (this.editor.onSubmit) {
+                this.editor.onSubmit(text);
+            }
             return;
+        }
+        const payload = await this.preparePromptPayload(text);
         // Queue input during compaction (extension commands execute immediately)
         if (this.session.isCompacting) {
-            if (this.isExtensionCommand(text)) {
-                this.editor.addToHistory?.(text);
+            if (this.isExtensionCommand(payload.text)) {
+                this.editor.addToHistory?.(payload.text);
                 this.editor.setText("");
-                await this.session.prompt(text);
+                await this.session.prompt(payload.text, { images: payload.images });
             }
             else {
-                this.queueCompactionMessage(text, "followUp");
+                this.queueCompactionMessage(payload.text, "followUp", payload.images);
             }
             return;
         }
         // Alt+Enter queues a follow-up message (waits until agent finishes)
         // This handles extension commands (execute immediately), prompt template expansion, and queueing
         if (this.session.isStreaming) {
-            this.editor.addToHistory?.(text);
+            this.editor.addToHistory?.(payload.text);
             this.editor.setText("");
-            await this.session.prompt(text, { streamingBehavior: "followUp" });
+            await this.session.prompt(payload.text, { streamingBehavior: "followUp", images: payload.images });
             this.updatePendingMessagesDisplay();
             this.ui.requestRender();
         }
-        // If not streaming, Alt+Enter acts like regular Enter (trigger onSubmit)
-        else if (this.editor.onSubmit) {
-            this.editor.onSubmit(text);
-        }
     }
     handleDequeue() {
         const restored = this.restoreQueuedMessagesToEditor();
@@ -2829,17 +3006,105 @@ export class InteractiveMode {
     }
     updateEditorDeck() {
         this.editorDeckContainer.clear();
-        const modeLabel = this.isBashMode ? "shell lane" : "prompt lane";
-        const stateLabel = this.isInterruptibleWorkActive()
-            ? "live processing  •  ctrl+c interrupt"
-            : `ready  •  ${keyText("tui.input.submit")} send`;
+        const modeLabel = this.isBashMode ? "shell" : "prompt";
+        const stateLabel = this.isInterruptibleWorkActive() ? "active" : "ready";
+        const imageLabel = this.pendingImageAttachments.length > 0
+            ? theme.fg("warning", `${this.pendingImageAttachments.length} image${this.pendingImageAttachments.length > 1 ? "s" : ""}`)
+            : "";
         const hintLabel = this.isBashMode
-            ? `! shell  •  ${keyText("app.clear")} interrupt  •  ${keyText("app.model.select")} engines`
-            : `/ commands  •  ${keyText("app.thinking.cycle")} analysis  •  ${keyText("app.model.select")} engines  •  ${keyText("app.editor.external")} external editor`;
-        this.editorDeckContainer.addChild(new Text(theme.bold(theme.fg("accent", `INPUT DECK // ${modeLabel}`)), 0, 0));
-        this.editorDeckContainer.addChild(new Text(theme.fg("dim", `${stateLabel}  •  ${hintLabel}`), 0, 0));
+            ? theme.fg("dim", `! shell | ${keyText("app.clear")} stop`)
+            : theme.fg("dim", `/ cmd | ${keyText("app.history.full")} full | ${keyText("app.thinking.cycle")} `) +
+                formatReasoningLegend() +
+                theme.fg("dim", ` | ${keyText("app.model.select")} model`);
+        this.editorDeckContainer.addChild(new TruncatedText(theme.bold(theme.fg(this.isBashMode ? "warning" : "accent", `INPUT ${modeLabel}`)) +
+            theme.fg("dim", "  |  ") +
+            theme.fg(this.isInterruptibleWorkActive() ? "warning" : "success", stateLabel) +
+            (imageLabel ? theme.fg("dim", "  |  ") + imageLabel : "") +
+            theme.fg("dim", "  |  ") +
+            hintLabel, 0, 0));
         this.editorDeckContainer.addChild(new Spacer(1));
     }
+    renderOperatorSidebar(width) {
+        const state = this.session.state;
+        const contextUsage = this.session.getContextUsage();
+        const contextWindow = contextUsage?.contextWindow ?? state.model?.contextWindow ?? 0;
+        const contextPercent = contextUsage?.percent ?? 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalCacheRead = 0;
+        for (const entry of this.session.sessionManager.getEntries()) {
+            if (entry.type === "message" && entry.message.role === "assistant") {
+                totalInput += entry.message.usage.input;
+                totalOutput += entry.message.usage.output;
+                totalCacheRead += entry.message.usage.cacheRead;
+            }
+        }
+        const cwd = this.session.sessionManager.getCwd().replace(process.env.HOME || "", "~");
+        const sessionName = this.session.sessionManager.getSessionName() || "unnamed";
+        const modelName = state.model?.id || "no-model";
+        const providerName = state.model?.provider || "none";
+        const thinking = state.model?.reasoning ? this.session.thinkingLevel || "off" : "off";
+        const reasoningText = formatReasoningLevel(thinking);
+        const active = this.isInterruptibleWorkActive();
+        const activeTools = this.pendingTools.size;
+        const queued = this.session.pendingMessageCount || 0;
+        const activeToolNames = this.session.getActiveToolNames?.() || [];
+        const toolText = activeToolNames.length ? activeToolNames.slice(0, 6).join(", ") : "read, bash, edit, write";
+        const pulse = active ? ["●", "●", "●", "○"][Math.floor((this.workspaceLayout.frame % 24) / 6)] : "●";
+        const loadingMessage = this.loadingAnimation?.message || this.defaultWorkingMessage;
+        const spinner = getSpinnerFrame(this.workspaceLayout.frame);
+        const rule = theme.fg("borderMuted", "─".repeat(Math.max(0, width)));
+        const section = (name) => fitLine(theme.bold(theme.fg("accent", `▌ ${name}`)) + theme.fg("borderMuted", " " + "─".repeat(Math.max(0, width - visibleWidth(name) - 4))), width);
+        const label = (name, value, color = "text") => fitLine(theme.fg("dim", `${name.padEnd(10)} `) + theme.fg(color, value), width);
+        const rawLabel = (name, value) => fitLine(theme.fg("dim", `${name.padEnd(10)} `) + value, width);
+        const lines = [
+            theme.bold(fitLine(theme.fg("accent", "OPERATOR CONTROL"), width)),
+            fitLine(theme.fg("dim", "agent loop dashboard"), width),
+            rule,
+            section("RUN"),
+            label("state", `${pulse} ${active ? "RUNNING" : "READY"}`, active ? "warning" : "success"),
+            label("phase", active ? "working / verify" : "waiting input", active ? "accent" : "muted"),
+            label("queue", `${queued} pending`, queued ? "warning" : "text"),
+            ...(active
+                ? [
+                    rawLabel("activity", `${theme.fg("accent", spinner)} ${theme.fg("text", loadingMessage)}`),
+                    "",
+                ]
+                : []),
+            ...(!active ? [""] : []),
+            section("CONTEXT"),
+            fitLine(renderGauge(contextPercent, width), width),
+            label("window", `${formatTokensCompact(contextWindow)} tokens`),
+            label("usage", `↑${formatTokensCompact(totalInput)} ↓${formatTokensCompact(totalOutput)} R${formatTokensCompact(totalCacheRead)}`),
+            label("history", this.fullHistoryView ? "full view" : "compact", this.fullHistoryView ? "warning" : "text"),
+            "",
+            section("ENGINE"),
+            label("model", modelName),
+            rawLabel("reason", reasoningText),
+            label("provider", providerName),
+            "",
+            section("WORKSPACE"),
+            label("path", cwd),
+            label("thread", sessionName),
+            "",
+            section("TOOLS"),
+            label("active", `${activeTools} running`, activeTools ? "warning" : "text"),
+            fitLine(theme.fg("text", toolText), width),
+            "",
+            rule,
+            fitLine(theme.fg("dim", `${keyText("app.clear")} stop  ${keyText("app.history.full")} full chat`), width),
+            fitLine(theme.fg("dim", `${keyText("app.thinking.cycle")} reason: `) + formatReasoningLegend(), width),
+            fitLine(theme.fg("dim", `${keyText("app.model.select")} model  ${keyText("app.editor.external")} editor`), width),
+        ];
+        const extensionStatuses = this.footerDataProvider.getExtensionStatuses();
+        if (extensionStatuses.size > 0) {
+            lines.splice(lines.length - 3, 0, "", fitLine(theme.fg("accent", "EXTENSIONS"), width), ...Array.from(extensionStatuses.values()).slice(0, 4).map((value) => fitLine(theme.fg("text", String(value).replace(/[\r\n\t]/g, " ")), width)));
+        }
+        if (this.customFooter) {
+            lines.splice(lines.length - 3, 0, "", ...this.customFooter.render(width).map((line) => fitLine(line, width)));
+        }
+        return lines;
+    }
     cycleThinkingLevel() {
         if (this.isBusyForModelOrThinkingChange()) {
             this.showBusyModelOrThinkingStatus();
@@ -2852,7 +3117,7 @@ export class InteractiveMode {
         else {
             this.footer.invalidate();
             this.updateEditorBorderColor();
-            this.showStatus(`Analysis depth: ${newLevel}`);
+            this.showStatus(`Analysis depth: ${displayThinkingLevel(newLevel)}`);
         }
     }
     async cycleModel(direction) {
@@ -2880,6 +3145,19 @@ export class InteractiveMode {
     toggleToolOutputExpansion() {
         this.setToolsExpanded(!this.toolOutputExpanded);
     }
+    toggleFullHistoryView() {
+        if (this.isInterruptibleWorkActive()) {
+            this.fullHistoryView = false;
+            this.showStatus("Full conversation view is available after the current run finishes");
+            this.ui.requestRender();
+            return;
+        }
+        this.fullHistoryView = !this.fullHistoryView;
+        this.showStatus(this.fullHistoryView
+            ? "Full conversation view enabled. Press Ctrl+R again to return to compact view."
+            : "Compact conversation view enabled.");
+        this.ui.requestRender();
+    }
     setToolsExpanded(expanded) {
         this.toolOutputExpanded = expanded;
         const activeHeader = this.customHeader ?? this.builtInHeader;
@@ -3044,8 +3322,8 @@ export class InteractiveMode {
         }
         return allQueued.length;
     }
-    queueCompactionMessage(text, mode) {
-        this.compactionQueuedMessages.push({ text, mode });
+    queueCompactionMessage(text, mode, images) {
+        this.compactionQueuedMessages.push({ text, mode, images });
         this.editor.addToHistory?.(text);
         this.editor.setText("");
         this.updatePendingMessagesDisplay();
@@ -3077,13 +3355,13 @@ export class InteractiveMode {
                 // When retry is pending, queue messages for the retry turn
                 for (const message of queuedMessages) {
                     if (this.isExtensionCommand(message.text)) {
-                        await this.session.prompt(message.text);
+                        await this.session.prompt(message.text, { images: message.images });
                     }
                     else if (message.mode === "followUp") {
-                        await this.session.followUp(message.text);
+                        await this.session.followUp(message.text, message.images);
                     }
                     else {
-                        await this.session.steer(message.text);
+                        await this.session.steer(message.text, message.images);
                     }
                 }
                 this.updatePendingMessagesDisplay();
@@ -3094,7 +3372,7 @@ export class InteractiveMode {
             if (firstPromptIndex === -1) {
                 // All extension commands - execute them all
                 for (const message of queuedMessages) {
-                    await this.session.prompt(message.text);
+                    await this.session.prompt(message.text, { images: message.images });
                 }
                 return;
             }
@@ -3103,22 +3381,22 @@ export class InteractiveMode {
             const firstPrompt = queuedMessages[firstPromptIndex];
             const rest = queuedMessages.slice(firstPromptIndex + 1);
             for (const message of preCommands) {
-                await this.session.prompt(message.text);
+                await this.session.prompt(message.text, { images: message.images });
             }
             // Send first prompt (starts streaming)
-            const promptPromise = this.session.prompt(firstPrompt.text).catch((error) => {
+            const promptPromise = this.session.prompt(firstPrompt.text, { images: firstPrompt.images }).catch((error) => {
                 restoreQueue(error);
             });
             // Queue remaining messages
             for (const message of rest) {
                 if (this.isExtensionCommand(message.text)) {
-                    await this.session.prompt(message.text);
+                    await this.session.prompt(message.text, { images: message.images });
                 }
                 else if (message.mode === "followUp") {
-                    await this.session.followUp(message.text);
+                    await this.session.followUp(message.text, message.images);
                 }
                 else {
-                    await this.session.steer(message.text);
+                    await this.session.steer(message.text, message.images);
                 }
             }
             this.updatePendingMessagesDisplay();
@@ -4351,6 +4629,7 @@ export class InteractiveMode {
             this.loadingAnimation.stop();
             this.loadingAnimation = undefined;
         }
+        this.workspaceLayout.dispose();
         this.clearExtensionTerminalInputListeners();
         this.footer.dispose();
         this.footerDataProvider.dispose();

package/node_modules/@operator/ai/dist/providers/openai-completions.js

@@ -396,6 +396,11 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
         params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+        // LiteLLM proxies may reject OpenAI-only params unless they are explicitly allow-listed.
+        // Alem AI Plus sits behind LiteLLM and returns UnsupportedParamsError without this field.
+        if (model.baseUrl.includes("llm.alem.ai")) {
+            params.allowed_openai_params = ["reasoning_effort"];
+        }
     }
     // OpenRouter provider routing preferences
     if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
@@ -851,4 +856,4 @@ function getCompat(model) {
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
     };
 }
-//# sourceMappingURL=openai-completions.js.map
+//# sourceMappingURL=openai-completions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pzero-operator",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "description": "Operator is a coding-first terminal AI agent from ProjectZero for software development, shell execution, local project workflows, and broader device-level operator control.",