@leg3ndy/otto-bridge 1.1.0 → 1.1.2

package/README.md

@@ -15,7 +15,7 @@ Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap
 
 Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_0_9_0_RELEASE.md).
 
-Para a release atual `1.1.0`, que consolida o baseline TTY single-line e inaugura a rail de coding com `Commit`, `Workspace` e `Snapshots`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md).
+Para o patch atual `1.1.2`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_2_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_2_PATCH.md). Para o corte funcional da linha `1.1.0`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md).
 
 ## Distribuicao
 
@@ -38,14 +38,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-1.1.0.tgz
+npm install -g ./leg3ndy-otto-bridge-1.1.2.tgz
 ```
 
-Na linha `1.1.0`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+Na linha `1.1.2`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
 
-No macOS, a linha `1.1.0` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No macOS, a linha `1.1.2` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializou isso como runtime agentico; o `1.1.0` preserva o prompt TTY single-line como baseline estavel e adiciona a camada workspace-first com rail de coding, trust/policy por workspace, source control first-class, working set persistido e grounding remoto por repositório.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializou isso como runtime agentico; o `1.1.2` mantem a camada workspace-first com rail de coding, trust/policy por workspace, source control first-class, working set persistido e grounding remoto por repositório, enquanto estabiliza o `Otto Console` com header fixo, intro card sem `model:` e redraw limpo no resize.
 
 ## Publicacao
 
@@ -145,6 +145,7 @@ Dentro do console, use:
 
 - `/model fast` para `OttoAI Fast`
 - `/model thinking` para `OttoAI Thinking`
+- `/approval preview`, `/approval confirm` ou `/approval trusted` para trocar o modo de aprovação do device
 - `/status` para ver detalhes técnicos do bridge e do runtime
 - `/workspace` ou `/workspace status` para ver o workspace ativo desta sessão
 - `/workspace list` para listar workspaces anexados ao device
@@ -152,6 +153,8 @@ Dentro do console, use:
 - `/workspace use <id|n>` para fixar um workspace anexado na sessão atual
 - `/workspace clear` para limpar o binding atual do chat/sessão
 
+No TTY, o console agora usa buffer alternativo com header fixo no topo: banner, card azul com `cwd`/`bridge` e linha de comandos continuam visíveis enquanto o transcript cresce. O composer fica ancorado no rodapé com placeholder `Peça algo ao Otto`, quebra por largura real do terminal e mantém o transcript do Otto sempre acima sem duplicar a viewport no resize. O intro card não repete `model:`, o footer mostra o modelo ativo em cinza claro, e as mensagens renderizam o usuário com `>` e o assistente com bolinha azul, com espaçamento entre os blocos; `Shift+Tab` alterna o modo de aprovação sem sair do console.
+
 No modo `OttoAI Thinking`, o terminal agora marca explicitamente o trecho de raciocínio com `Pensando (OttoAI Thinking)` e separa esse bloco da resposta final do Otto.
 
 Quando o handoff local devolver resultado estruturado, o CLI agora mostra inline a listagem de arquivos e o conteúdo de `read_file`, em vez de só resumir que executou a tarefa.
@@ -166,7 +169,7 @@ Esse comando abre um shell local interativo para instalar extensoes, rodar coman
 
 ### WhatsApp Web em background
 
-Fluxo recomendado na linha `1.1.0`:
+Fluxo recomendado na linha `1.1.2`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -176,13 +179,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato da linha `1.1.0`:
+Contrato da linha `1.1.2`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime do hub estiver ativo, sem depender de uma aba aberta no Safari
 - ao fechar o `otto-bridge`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido da linha 1.1.0
+## Handoff rapido da linha 1.1.2
 
 Ja fechado no codigo:
 

package/dist/cli_terminal.js

@@ -4,9 +4,10 @@ import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { clearScreenDown, cursorTo, moveCursor, } from "node:readline";
 import process, { stdin as input, stdout as output } from "node:process";
-import { defaultDeviceName, getBridgeConfigPath, loadBridgeConfig, normalizeInstalledExtensions, resolveApiBaseUrl, resolveExecutorConfig, } from "./config.js";
+import { defaultDeviceName, getBridgeConfigPath, loadBridgeConfig, normalizeInstalledExtensions, resolveApiBaseUrl, resolveExecutorConfig, saveBridgeConfig, } from "./config.js";
 import { activateWorkspaceForRuntime, attachWorkspaceForRuntime, clearRuntimeWorkspaceForSession, getRuntimeSessionWorkspace, listAttachedWorkspacesForRuntime, } from "./attached_workspaces.js";
 import { streamDeviceCliChat, } from "./chat_cli_client.js";
+import { patchDeviceJson } from "./http.js";
 import { formatManagedBridgeExtensionStatus, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 import { pairDevice } from "./pairing.js";
 import { BridgeRuntime, } from "./runtime.js";
@@ -41,11 +42,13 @@ const CLI_MODEL_REGISTRY = {
         label: "OttoAI Fast",
         requestModel: "deepseek-chat",
         aliases: ["fast", "chat", "default", "ottoai fast", "otto fast"],
+        contextWindowTokens: 128_000,
     },
     thinking: {
         label: "OttoAI Thinking",
         requestModel: "deepseek-reasoner",
         aliases: ["thinking", "reasoner", "think", "ottoai thinking", "otto thinking"],
+        contextWindowTokens: 128_000,
     },
 };
 const MAX_RENDERED_LIST_ENTRIES = 28;
@@ -53,9 +56,11 @@ const MAX_RENDERED_LIST_ENTRIES_COMPACT = 10;
 const MAX_RENDERED_FILE_CHARS = 6_000;
 const MAX_RENDERED_FILE_CHARS_COMPACT = 1_400;
 const CONSOLE_PLACEHOLDER = "Peça algo ao Otto";
-const CONSOLE_COMMAND_HINT = "/help, /model [fast|thinking], /workspace, /status, /clear, /exit";
+const CONSOLE_COMMAND_HINT = "/help, /model [fast|thinking], /approval [preview|confirm|trusted], /workspace, /status, /clear, /exit";
 const CONSOLE_COMPOSER_PROMPT_WIDTH = 2;
 const CONSOLE_COMPOSER_CURSOR_COLUMN = 2;
+const CONSOLE_EST_CHARS_PER_TOKEN = 4;
+const CONSOLE_EST_MESSAGE_OVERHEAD_TOKENS = 8;
 class CliRuntimeSession {
     config;
     runtime = null;
@@ -233,6 +238,9 @@ function renderBanner() {
         `${style(subtitle, ANSI.slate, enabled)}`,
     ].join("\n");
 }
+function getCardMaxContentWidth() {
+    return Math.max(24, Number(output.columns || 96) - 4);
+}
 function createCliExitError() {
     return new Error(CLI_EXIT_SENTINEL);
 }
@@ -297,6 +305,292 @@ function getCliModelLabel(mode) {
 function getCliModelRequestModel(mode) {
     return CLI_MODEL_REGISTRY[mode].requestModel;
 }
+function getCliModelContextWindowTokens(mode) {
+    return CLI_MODEL_REGISTRY[mode].contextWindowTokens;
+}
+function countConsoleChars(value) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value).length;
+    }
+    if (Array.isArray(value)) {
+        return value.reduce((total, item) => total + countConsoleChars(item), 0);
+    }
+    if (typeof value === "object") {
+        return Object.values(value).reduce((total, item) => total + countConsoleChars(item), 0);
+    }
+    return String(value).length;
+}
+function estimateConsoleMessageTokens(messages) {
+    let charCount = 0;
+    let messageCount = 0;
+    for (const message of messages) {
+        if (!message || typeof message !== "object") {
+            continue;
+        }
+        messageCount += 1;
+        charCount += countConsoleChars(message.role);
+        charCount += countConsoleChars(message.content);
+    }
+    const estimatedTokens = Math.ceil(charCount / CONSOLE_EST_CHARS_PER_TOKEN);
+    return Math.max(0, estimatedTokens + (messageCount * CONSOLE_EST_MESSAGE_OVERHEAD_TOKENS));
+}
+function estimateConsoleContextTokens(messages, draftValue) {
+    const draft = String(draftValue || "");
+    const requestMessages = draft
+        ? [...messages, { role: "user", content: draft }]
+        : [...messages];
+    return estimateConsoleMessageTokens(requestMessages);
+}
+function formatCompactTokenCount(tokens) {
+    const value = Math.max(0, Math.round(tokens));
+    if (value < 1_000) {
+        return String(value);
+    }
+    if (value < 10_000) {
+        return `${(value / 1_000).toFixed(1)}K`;
+    }
+    if (value < 1_000_000) {
+        return `${Math.round(value / 1_000)}K`;
+    }
+    return `${(value / 1_000_000).toFixed(1)}M`;
+}
+function getConsoleApprovalFooterState(mode) {
+    if (mode === "trusted") {
+        return {
+            tone: "warning",
+            label: "bypass permissões ativo",
+        };
+    }
+    if (mode === "confirm") {
+        return {
+            tone: "primary",
+            label: "confirmação manual",
+        };
+    }
+    return {
+        tone: "muted",
+        label: "permissões padrão",
+    };
+}
+function getNextApprovalMode(mode) {
+    if (mode === "preview") {
+        return "confirm";
+    }
+    if (mode === "confirm") {
+        return "trusted";
+    }
+    return "preview";
+}
+function styleTranscriptLine(text, tone, enabled) {
+    if (!enabled) {
+        return text;
+    }
+    if (tone === "headline") {
+        return `${ANSI.bold}${ANSI.brandBlue}${text}${ANSI.reset}`;
+    }
+    if (tone === "assistant") {
+        return `${ANSI.white}${text}${ANSI.reset}`;
+    }
+    if (tone === "user") {
+        return `${ANSI.bold}${ANSI.white}${text}${ANSI.reset}`;
+    }
+    if (tone === "reasoning") {
+        return `${ANSI.slateItalic}${text}${ANSI.reset}`;
+    }
+    if (tone === "success") {
+        return `${ANSI.green}${text}${ANSI.reset}`;
+    }
+    if (tone === "warning") {
+        return `${ANSI.amber}${text}${ANSI.reset}`;
+    }
+    if (tone === "error") {
+        return `${ANSI.red}${text}${ANSI.reset}`;
+    }
+    return `${ANSI.slate}${text}${ANSI.reset}`;
+}
+function buildConsoleUsageBar(width, usageRatio, enabled) {
+    const clampedWidth = Math.max(10, width);
+    const clampedRatio = Math.max(0, Math.min(usageRatio, 1));
+    const filled = Math.round(clampedWidth * clampedRatio);
+    const empty = Math.max(0, clampedWidth - filled);
+    const filledBar = style("█".repeat(filled), ANSI.brandBlue, enabled);
+    const emptyBar = style("░".repeat(empty), ANSI.slate, enabled);
+    return `${style("[", ANSI.white, enabled)}${filledBar}${emptyBar}${style("]", ANSI.white, enabled)}`;
+}
+function buildConsoleFooterStatusLine(width, modelMode, usageTokens, enabled) {
+    const contextLimit = getCliModelContextWindowTokens(modelMode);
+    const usageRatio = contextLimit > 0 ? usageTokens / contextLimit : 0;
+    const percent = Math.round(Math.max(0, Math.min(usageRatio, 1)) * 100);
+    const barWidth = Math.max(12, Math.min(28, Math.floor(width * 0.18)));
+    const modelLabel = style(getCliModelLabel(modelMode), ANSI.slate, enabled);
+    return `${modelLabel} | ${buildConsoleUsageBar(barWidth, usageRatio, enabled)} ${percent}% | ${formatCompactTokenCount(usageTokens)} tokens`;
+}
+function buildConsoleFooterApprovalLine(mode, enabled, statusSuffix) {
+    const state = getConsoleApprovalFooterState(mode);
+    const hint = statusSuffix || "Shift+Tab para alternar";
+    return style(`${state.label} (${hint})`, state.tone === "warning" ? ANSI.red : state.tone === "primary" ? ANSI.amber : ANSI.slate, enabled);
+}
+function styleTranscriptPrefix(text, tone, enabled) {
+    if (!enabled || !text) {
+        return text;
+    }
+    if (tone === "assistant") {
+        return `${ANSI.bold}${ANSI.brandBlue}${text}${ANSI.reset}`;
+    }
+    if (tone === "user") {
+        return `${ANSI.bold}${ANSI.white}${text}${ANSI.reset}`;
+    }
+    return text;
+}
+class ConsoleScreenRenderer {
+    modelMode;
+    approvalMode;
+    headerFactory;
+    transcript = [];
+    onResize = () => {
+        this.render();
+    };
+    nextEntryId = 1;
+    active = false;
+    draftValue = "";
+    conversationMessages = [];
+    approvalStatusSuffix = null;
+    usingAlternateBuffer = false;
+    constructor(modelMode, approvalMode, headerFactory = () => []) {
+        this.modelMode = modelMode;
+        this.approvalMode = approvalMode;
+        this.headerFactory = headerFactory;
+    }
+    activate() {
+        if (this.active || !supportsAnsi() || !input.isTTY || !output.isTTY) {
+            return;
+        }
+        this.active = true;
+        output.write("\u001b[?1049h");
+        this.usingAlternateBuffer = true;
+        output.on("resize", this.onResize);
+        this.render();
+    }
+    dispose() {
+        if (!this.active) {
+            return;
+        }
+        output.off("resize", this.onResize);
+        this.active = false;
+        output.write("\u001b[?25h");
+        if (this.usingAlternateBuffer) {
+            output.write("\u001b[?1049l");
+            this.usingAlternateBuffer = false;
+        }
+    }
+    isActive() {
+        return this.active;
+    }
+    clearTranscript() {
+        this.transcript.splice(0, this.transcript.length);
+        this.render();
+    }
+    pushEntry(entry) {
+        const id = this.nextEntryId++;
+        this.transcript.push({
+            id,
+            ...entry,
+        });
+        this.render();
+        return id;
+    }
+    appendToEntry(id, text) {
+        if (!id || !text) {
+            return;
+        }
+        const entry = this.transcript.find((item) => item.id === id);
+        if (!entry) {
+            return;
+        }
+        entry.text += text;
+        this.render();
+    }
+    setDraftValue(value) {
+        this.draftValue = value;
+        this.render();
+    }
+    setConversationMessages(messages) {
+        this.conversationMessages = [...messages];
+        this.render();
+    }
+    setModelMode(mode) {
+        this.modelMode = mode;
+        this.render();
+    }
+    setApprovalMode(mode) {
+        this.approvalMode = mode;
+        this.approvalStatusSuffix = null;
+        this.render();
+    }
+    setApprovalStatusSuffix(value) {
+        this.approvalStatusSuffix = value;
+        this.render();
+    }
+    buildEntryLines(entry, width) {
+        const logicalLines = entry.text.split("\n");
+        const prefix = entry.prefix || "";
+        const continuationPrefix = entry.continuationPrefix ?? " ".repeat(prefix.length);
+        const rendered = [];
+        let isFirstVisualLine = true;
+        for (const logicalLine of logicalLines) {
+            const currentPrefix = isFirstVisualLine ? prefix : continuationPrefix;
+            const wrapped = sliceByWidth(logicalLine, Math.max(1, width - currentPrefix.length));
+            wrapped.forEach((segment, index) => {
+                const linePrefix = isFirstVisualLine && index === 0 ? prefix : continuationPrefix;
+                const prefixTone = isFirstVisualLine && index === 0 ? entry.prefixTone : undefined;
+                rendered.push(`${styleTranscriptPrefix(linePrefix, prefixTone, supportsAnsi())}${styleTranscriptLine(segment, entry.tone, supportsAnsi())}`);
+            });
+            if (logicalLine.length === 0 && wrapped.length === 0) {
+                rendered.push("");
+            }
+            isFirstVisualLine = false;
+        }
+        return rendered;
+    }
+    render() {
+        if (!this.active) {
+            return;
+        }
+        const enabled = supportsAnsi();
+        const width = Math.max(48, Number(output.columns || 96));
+        const height = Math.max(12, Number(output.rows || 24));
+        const headerLines = this.headerFactory();
+        const separator = style("─".repeat(width), ANSI.brandBlue, enabled);
+        const composer = renderConsoleComposerLines(this.draftValue, width, enabled);
+        const usageTokens = Math.min(estimateConsoleContextTokens(this.conversationMessages, this.draftValue), getCliModelContextWindowTokens(this.modelMode));
+        const footerLines = [
+            separator,
+            ...composer.renderedLines,
+            separator,
+            buildConsoleFooterStatusLine(width, this.modelMode, usageTokens, enabled),
+            buildConsoleFooterApprovalLine(this.approvalMode, enabled, this.approvalStatusSuffix),
+        ];
+        const visibleHeader = headerLines.slice(0, Math.max(0, height - footerLines.length));
+        const transcriptHeight = Math.max(0, height - visibleHeader.length - footerLines.length);
+        const transcriptLines = this.transcript.flatMap((entry) => this.buildEntryLines(entry, width));
+        const visibleTranscript = transcriptLines.slice(-transcriptHeight);
+        const paddedTranscript = [
+            ...Array.from({ length: Math.max(0, transcriptHeight - visibleTranscript.length) }, () => ""),
+            ...visibleTranscript,
+        ];
+        output.write("\u001b[?25l");
+        output.write("\u001b[H\u001b[2J");
+        output.write([...visibleHeader, ...paddedTranscript, ...footerLines].join("\n"));
+        cursorTo(output, Math.min(width - 1, CONSOLE_COMPOSER_CURSOR_COLUMN + composer.cursorColumn), visibleHeader.length + transcriptHeight + 1 + composer.cursorLineIndex);
+        output.write("\u001b[?25h");
+    }
+}
 export function resolveCliModelMode(value) {
     const normalized = normalizeText(value).toLowerCase();
     if (!normalized) {
@@ -531,13 +825,14 @@ function styleCardLine(line, tone, enabled) {
     }
     return `${ANSI.white}${line}${ANSI.reset}`;
 }
-function renderInfoCard(lines) {
+export function renderInfoCard(lines, maxContentWidth = 82) {
     const enabled = supportsAnsi();
+    const safeMaxContentWidth = Math.max(20, maxContentWidth);
     const normalized = lines.map((line) => ({
-        text: truncate(line.text, 82),
+        text: truncate(line.text, safeMaxContentWidth),
         tone: line.tone,
     }));
-    const width = Math.max(44, ...normalized.map((line) => line.text.length));
+    const width = Math.max(Math.min(44, safeMaxContentWidth), ...normalized.map((line) => line.text.length));
     const top = style(`┌${"─".repeat(width + 2)}┐`, ANSI.brandBlue, enabled);
     const bottom = style(`└${"─".repeat(width + 2)}┘`, ANSI.brandBlue, enabled);
     return [
@@ -550,17 +845,31 @@ function renderInfoCard(lines) {
         bottom,
     ].join("\n");
 }
-function buildWelcomeCard(runtimeSession, modelMode) {
+export function buildWelcomeCard(runtimeSession) {
     return [
         { text: "Welcome to OttoAI", tone: "title" },
         { text: "", tone: "muted" },
         { text: "/help inside the console, /status for bridge details", tone: "muted" },
         { text: "", tone: "muted" },
-        { text: `model: ${getCliModelLabel(modelMode)}`, tone: "muted" },
         { text: `cwd: ${process.cwd()}`, tone: "muted" },
         { text: renderRuntimeHeadline(runtimeSession), tone: "muted" },
     ];
 }
+function buildConsoleHeaderLines(runtimeSession) {
+    const lines = [
+        ...renderBanner().split("\n"),
+        "",
+        ...renderInfoCard(buildWelcomeCard(runtimeSession), getCardMaxContentWidth()).split("\n"),
+    ];
+    const releaseNotice = runtimeSession.getReleaseNotice();
+    if (releaseNotice) {
+        lines.push("");
+        lines.push(...renderInfoCard(buildBridgeReleaseCard(releaseNotice), getCardMaxContentWidth()).split("\n"));
+    }
+    lines.push("");
+    lines.push(style(`Comandos: ${CONSOLE_COMMAND_HINT}`, ANSI.slateItalic, supportsAnsi()));
+    return lines;
+}
 function buildBridgeReleaseCard(notice) {
     const isRequired = notice.kind === "required";
     return [
@@ -650,29 +959,20 @@ async function buildExtensionsCard(config) {
     }
     return lines;
 }
-function printHubScreen(runtimeSession, modelMode) {
+function printHubScreen(runtimeSession) {
     clearScreen();
     console.log(renderBanner());
     console.log("");
-    console.log(renderInfoCard(buildWelcomeCard(runtimeSession, modelMode)));
+    console.log(renderInfoCard(buildWelcomeCard(runtimeSession), getCardMaxContentWidth()));
     const releaseNotice = runtimeSession?.getReleaseNotice();
     if (releaseNotice) {
         console.log("");
-        console.log(renderInfoCard(buildBridgeReleaseCard(releaseNotice)));
+        console.log(renderInfoCard(buildBridgeReleaseCard(releaseNotice), getCardMaxContentWidth()));
     }
 }
-function printConsoleScreen(runtimeSession, modelMode) {
+function printConsoleScreen(runtimeSession) {
     clearScreen();
-    console.log(renderBanner());
-    console.log("");
-    console.log(renderInfoCard(buildWelcomeCard(runtimeSession, modelMode)));
-    const releaseNotice = runtimeSession.getReleaseNotice();
-    if (releaseNotice) {
-        console.log("");
-        console.log(renderInfoCard(buildBridgeReleaseCard(releaseNotice)));
-    }
-    console.log("");
-    printSoft(`Comandos: ${CONSOLE_COMMAND_HINT}`);
+    console.log(buildConsoleHeaderLines(runtimeSession).join("\n"));
     console.log("");
 }
 function formatConsoleWorkspaceLine(workspace, options) {
@@ -806,6 +1106,16 @@ async function handleConsoleWorkspaceCommand(normalizedPrompt, config, sessionId
     printWarning("Comando de workspace inválido. Use /workspace help.");
     return true;
 }
+async function updateConsoleApprovalMode(config, approvalMode) {
+    const response = await patchDeviceJson(config.apiBaseUrl, config.deviceToken, "/v1/devices/cli/device/settings", {
+        approval_mode: approvalMode,
+    });
+    const resolvedMode = normalizeText(response.device?.approval_mode);
+    const nextMode = resolvedMode || approvalMode;
+    config.approvalMode = nextMode;
+    await saveBridgeConfig(config);
+    return nextMode;
+}
 function renderPromptFrameLine(width, edgeLeft, edgeRight) {
     return style(`${edgeLeft}${"─".repeat(width)}${edgeRight}`, ANSI.brandBlue, supportsAnsi());
 }
@@ -817,11 +1127,18 @@ function sliceByWidth(text, width) {
         return [""];
     }
     const parts = [];
-    let offset = 0;
-    while (offset < text.length) {
-        parts.push(text.slice(offset, offset + width));
-        offset += width;
+    let remaining = text;
+    while (remaining.length > width) {
+        const breakpoint = Math.max(remaining.lastIndexOf(" ", width), remaining.lastIndexOf("\t", width));
+        if (breakpoint > 0) {
+            parts.push(remaining.slice(0, breakpoint).trimEnd());
+            remaining = remaining.slice(breakpoint).replace(/^[ \t]+/, "");
+            continue;
+        }
+        parts.push(remaining.slice(0, width));
+        remaining = remaining.slice(width);
     }
+    parts.push(remaining);
     return parts.length ? parts : [""];
 }
 export function buildConsoleComposerLayout(value, innerWidth) {
@@ -834,16 +1151,16 @@ export function buildConsoleComposerLayout(value, innerWidth) {
         };
     }
     const logicalLines = value.split("\n");
-    const lastLogicalLine = logicalLines[logicalLines.length - 1] ?? "";
     const lines = [];
     for (const logicalLine of logicalLines) {
         const wrapped = sliceByWidth(logicalLine, lineContentWidth);
         lines.push(...wrapped);
     }
     const trailingNewline = value.endsWith("\n");
+    const lastVisualLine = lines[lines.length - 1] ?? "";
     const needsSoftWrapCursorRow = !trailingNewline
-        && lastLogicalLine.length > 0
-        && lastLogicalLine.length % lineContentWidth === 0;
+        && lastVisualLine.length > 0
+        && lastVisualLine.length === lineContentWidth;
     if (needsSoftWrapCursorRow) {
         lines.push("");
     }
@@ -856,7 +1173,7 @@ export function buildConsoleComposerLayout(value, innerWidth) {
         ? 0
         : needsSoftWrapCursorRow
             ? 0
-            : lastLogicalLine.length % lineContentWidth;
+            : lastVisualLine.length;
     return {
         lines,
         cursorLineIndex,
@@ -906,6 +1223,19 @@ export function tryConsumeControlSequence(buffer) {
             };
         }
     }
+    const approvalCycleSequences = [
+        "\u001b[Z",
+        "\u001b[1;2Z",
+        "\u001b[27;2;9~",
+    ];
+    for (const sequence of approvalCycleSequences) {
+        if (buffer.startsWith(sequence)) {
+            return {
+                consumed: sequence.length,
+                action: "cycle_approval",
+            };
+        }
+    }
     if (buffer === "\u001b" || /^\u001b\[[0-9;?]*$/.test(buffer)) {
         return {
             consumed: 0,
@@ -934,7 +1264,7 @@ export function tryConsumeControlSequence(buffer) {
     }
     return null;
 }
-async function askConsoleInput(rl) {
+async function askConsoleInput(rl, options) {
     if (!supportsAnsi() || typeof input.setRawMode !== "function" || !input.isTTY) {
         return normalizeText(await question(rl, "> "));
     }
@@ -943,16 +1273,19 @@ async function askConsoleInput(rl) {
     input.resume();
     return await new Promise((resolve, reject) => {
         const enabled = supportsAnsi();
+        const ui = options?.ui && options.ui.isActive() ? options.ui : null;
         const availableWidth = Number(output.columns || 96);
         const innerWidth = Math.max(42, Math.min(availableWidth - 8, 116));
         const sectionTopOffsetFromInputLine = 1;
-        let renderedOnce = false;
         let value = "";
+        let renderedOnce = false;
+        let controlBuffer = "";
         const cleanup = () => {
             input.removeListener("data", onData);
             input.setRawMode(false);
             input.pause();
             rl.resume();
+            ui?.setDraftValue("");
         };
         const renderInputContent = () => {
             const promptPlain = "> ";
@@ -968,7 +1301,11 @@ async function askConsoleInput(rl) {
                 : value;
             return `${promptStyled} ${visibleValue}${" ".repeat(Math.max(0, maxValueLength - visibleValue.length))}`;
         };
-        const render = () => {
+        const renderLegacyInput = () => {
+            if (ui) {
+                ui.setDraftValue(value);
+                return;
+            }
             if (renderedOnce) {
                 cursorTo(output, 0);
                 moveCursor(output, 0, -sectionTopOffsetFromInputLine);
@@ -987,9 +1324,38 @@ async function askConsoleInput(rl) {
             const visibleValueLength = Math.min(value.length, Math.max(0, innerWidth - 2));
             cursorTo(output, 4 + visibleValueLength);
         };
+        const consumeControlBuffer = () => {
+            while (controlBuffer.length > 0) {
+                const parsed = tryConsumeControlSequence(controlBuffer);
+                if (!parsed) {
+                    controlBuffer = "";
+                    return;
+                }
+                if (parsed.action === "incomplete") {
+                    return;
+                }
+                controlBuffer = controlBuffer.slice(parsed.consumed);
+                if (parsed.action === "ignore") {
+                    continue;
+                }
+                if (parsed.action === "cycle_approval") {
+                    void options?.onCycleApprovalMode?.();
+                    continue;
+                }
+                if (parsed.action === "newline") {
+                    value += "\n";
+                    renderLegacyInput();
+                }
+            }
+        };
         const onData = (chunk) => {
             const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
             for (const char of Array.from(text)) {
+                if (controlBuffer || char === "\u001b") {
+                    controlBuffer += char;
+                    consumeControlBuffer();
+                    continue;
+                }
                 if (char === "\u0003") {
                     cleanup();
                     reject(createCliExitError());
@@ -997,23 +1363,25 @@ async function askConsoleInput(rl) {
                 }
                 if (char === "\r" || char === "\n") {
                     cleanup();
-                    output.write("\n");
+                    if (!ui) {
+                        output.write("\n");
+                    }
                     resolve(normalizeText(value));
                     return;
                 }
                 if (char === "\u007f" || char === "\b") {
                     value = value.slice(0, -1);
-                    render();
+                    renderLegacyInput();
                     continue;
                 }
-                if (char === "\u001b") {
+                if (char === "\t") {
                     continue;
                 }
                 value += char;
-                render();
+                renderLegacyInput();
             }
         };
-        render();
+        renderLegacyInput();
         input.on("data", onData);
     });
 }
@@ -1315,15 +1683,266 @@ async function followConsoleJob(rl, config, jobId) {
 }
 async function runOttoConsole(rl, config, runtimeSession, options) {
     let activeModel = "fast";
-    printConsoleScreen(runtimeSession, activeModel);
     const sessionId = randomUUID();
     const conversation = [];
+    const ui = supportsAnsi() && typeof input.setRawMode === "function" && input.isTTY && output.isTTY
+        ? new ConsoleScreenRenderer(activeModel, config.approvalMode, () => buildConsoleHeaderLines(runtimeSession))
+        : null;
+    ui?.activate();
+    if (!ui) {
+        printConsoleScreen(runtimeSession);
+    }
+    const renderConversationState = () => {
+        ui?.setConversationMessages(conversation);
+        ui?.setModelMode(activeModel);
+    };
+    renderConversationState();
+    const emitConsoleEntry = (text, tone, options) => {
+        if (ui) {
+            ui.pushEntry({
+                text,
+                tone,
+                prefix: options?.prefix,
+                prefixTone: options?.prefixTone,
+                continuationPrefix: options?.continuationPrefix,
+            });
+            return;
+        }
+        if (options?.prefix) {
+            console.log(`${styleTranscriptPrefix(options.prefix, options.prefixTone, supportsAnsi())}${styleTranscriptLine(text, tone, supportsAnsi())}`);
+            return;
+        }
+        if (tone === "warning") {
+            printWarning(text);
+            return;
+        }
+        if (tone === "error") {
+            printError(text);
+            return;
+        }
+        if (tone === "success") {
+            printSuccess(text);
+            return;
+        }
+        if (tone === "muted" || tone === "reasoning") {
+            printSoft(text);
+            return;
+        }
+        console.log(text);
+    };
+    const emitUserPrompt = (text) => {
+        emitConsoleEntry(text, "user", {
+            prefix: "> ",
+            prefixTone: "user",
+            continuationPrefix: "  ",
+        });
+    };
+    const emitAssistantPrompt = (text) => {
+        emitConsoleEntry(text, "assistant", {
+            prefix: "• ",
+            prefixTone: "assistant",
+            continuationPrefix: "  ",
+        });
+    };
+    const setApprovalMode = async (nextMode) => {
+        if (ui) {
+            ui.setApprovalStatusSuffix("atualizando...");
+        }
+        try {
+            const resolvedMode = await updateConsoleApprovalMode(config, nextMode);
+            ui?.setApprovalMode(resolvedMode);
+            emitConsoleEntry(`Modo de aprovação: ${getConsoleApprovalFooterState(resolvedMode).label}.`, "muted");
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error || "Falha ao atualizar o modo de aprovação.");
+            ui?.setApprovalStatusSuffix("falha ao atualizar");
+            emitConsoleEntry(detail, "error");
+        }
+    };
+    const cycleApprovalMode = () => {
+        void setApprovalMode(getNextApprovalMode(config.approvalMode));
+    };
+    const readConsoleInput = async () => {
+        return await askConsoleInput(rl, {
+            ui,
+            onCycleApprovalMode: cycleApprovalMode,
+        });
+    };
+    const askConsoleDecision = async (promptText, defaultValue = true) => {
+        emitConsoleEntry(`${promptText} ${defaultValue ? "[Y/n]" : "[y/N]"}`, "warning");
+        const answer = normalizeText(await readConsoleInput()).toLowerCase();
+        emitUserPrompt(answer || (defaultValue ? "sim" : "não"));
+        if (!answer) {
+            return defaultValue;
+        }
+        return ["y", "yes", "s", "sim"].includes(answer);
+    };
     const printConsoleHelp = () => {
-        printSection("Console");
-        printSoft("Comandos: /help, /model [fast|thinking], /workspace, /status, /clear, /exit");
-        printSoft("Bridge: otto-bridge terminal, otto-bridge extensions --install <name>, otto-bridge update");
-        printSoft("Composer: Enter envia. Multiline desativado para evitar duplicacao no terminal.");
-        printSoft("Workspace: /workspace list, /workspace attach <path>, /workspace use <id|n>, /workspace clear");
+        emitConsoleEntry("Console", "headline");
+        emitConsoleEntry("Comandos: /help, /model [fast|thinking], /approval [preview|confirm|trusted], /workspace, /status, /clear, /exit", "muted");
+        emitConsoleEntry("Composer: Enter envia, Shift+Enter adiciona linha e Shift+Tab alterna o modo de aprovação.", "muted");
+        emitConsoleEntry("Workspace: /workspace list, /workspace attach <path>, /workspace use <id|n>, /workspace clear", "muted");
+    };
+    const printConsoleWorkspaceStatus = async () => {
+        const [workspaces, activeWorkspace] = await Promise.all([
+            listAttachedWorkspacesForRuntime({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                baseCwd: process.cwd(),
+            }),
+            getRuntimeSessionWorkspace({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                sessionId,
+                baseCwd: process.cwd(),
+            }),
+        ]);
+        emitConsoleEntry("Workspace", "headline");
+        if (activeWorkspace) {
+            emitConsoleEntry(`Ativo neste console: ${formatConsoleWorkspaceLine(activeWorkspace, { isActive: true })}`, "success");
+        }
+        else {
+            emitConsoleEntry("Nenhum workspace ativo neste console.", "muted");
+        }
+        if (workspaces.length === 0) {
+            emitConsoleEntry("Nenhum workspace anexado. Use /workspace attach <caminho>.", "muted");
+            return;
+        }
+        workspaces.forEach((workspace, index) => {
+            const isActive = normalizeText(workspace.workspace_id) === normalizeText(activeWorkspace?.workspace_id);
+            emitConsoleEntry(formatConsoleWorkspaceLine(workspace, { index, isActive }), "muted");
+        });
+    };
+    const handleWorkspaceCommand = async (normalizedPrompt) => {
+        if (!normalizedPrompt.startsWith("/workspace")) {
+            return false;
+        }
+        const remainder = normalizeText(normalizedPrompt.slice("/workspace".length));
+        if (!remainder || remainder === "list" || remainder === "status") {
+            await printConsoleWorkspaceStatus();
+            return true;
+        }
+        if (remainder === "help") {
+            emitConsoleEntry("Workspace", "headline");
+            emitConsoleEntry("/workspace lista os workspaces anexados e o ativo", "muted");
+            emitConsoleEntry("/workspace attach <path> anexa uma pasta ou repo neste device", "muted");
+            emitConsoleEntry("/workspace use <id|n> ativa o workspace para o console atual", "muted");
+            emitConsoleEntry("/workspace clear remove o workspace ativo deste console", "muted");
+            return true;
+        }
+        if (remainder.startsWith("attach ")) {
+            const rootPath = normalizeText(remainder.slice("attach ".length));
+            if (!rootPath) {
+                emitConsoleEntry("Use /workspace attach <caminho>.", "warning");
+                return true;
+            }
+            const workspace = await attachWorkspaceForRuntime({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                rootPath,
+                baseCwd: process.cwd(),
+            });
+            emitConsoleEntry(`Workspace anexado: ${formatConsoleWorkspaceLine(workspace)}`, "success");
+            return true;
+        }
+        if (remainder.startsWith("use ")) {
+            const selectionToken = normalizeText(remainder.slice("use ".length));
+            if (!selectionToken) {
+                emitConsoleEntry("Use /workspace use <id|numero>.", "warning");
+                return true;
+            }
+            const workspaces = await listAttachedWorkspacesForRuntime({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                baseCwd: process.cwd(),
+            });
+            const selectedWorkspace = resolveConsoleWorkspaceSelection(selectionToken, workspaces);
+            if (!selectedWorkspace?.workspace_id) {
+                emitConsoleEntry("Workspace não encontrado. Rode /workspace para listar as opções.", "warning");
+                return true;
+            }
+            const activated = await activateWorkspaceForRuntime({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                workspaceId: selectedWorkspace.workspace_id,
+                sessionId,
+                baseCwd: process.cwd(),
+            });
+            if (activated) {
+                emitConsoleEntry(`Workspace ativo neste console: ${formatConsoleWorkspaceLine(activated, { isActive: true })}`, "success");
+            }
+            else {
+                emitConsoleEntry("Não foi possível ativar o workspace selecionado.", "warning");
+            }
+            return true;
+        }
+        if (remainder === "clear") {
+            await clearRuntimeWorkspaceForSession({
+                apiBaseUrl: config.apiBaseUrl,
+                deviceToken: config.deviceToken,
+                sessionId,
+            });
+            emitConsoleEntry("Workspace ativo deste console removido.", "muted");
+            return true;
+        }
+        emitConsoleEntry("Comando de workspace inválido. Use /workspace help.", "warning");
+        return true;
+    };
+    const followConsoleJobUi = async (jobId) => {
+        let lastStatus = "";
+        let lastStepId = "";
+        let awaitingDecision = false;
+        for (;;) {
+            const envelope = await getRuntimeCliJob(config, jobId);
+            const job = envelope.job || {};
+            const status = normalizeText(job.status).toLowerCase() || "unknown";
+            const stepId = extractJobStepId(job);
+            if (status !== lastStatus || stepId !== lastStepId) {
+                const statusLabel = `${status}${stepId ? ` · ${stepId}` : ""}`;
+                emitConsoleEntry(`local: ${statusLabel}`, "muted");
+                lastStatus = status;
+                lastStepId = stepId;
+            }
+            if (status === "confirm_required" && !awaitingDecision) {
+                awaitingDecision = true;
+                emitConsoleEntry(extractConfirmationPrompt(job), "warning");
+                const approve = await askConsoleDecision("Aprovar este passo", true);
+                if (approve) {
+                    await confirmRuntimeCliJob(config, jobId, "approve");
+                }
+                else {
+                    const reject = await askConsoleDecision("Rejeitar explicitamente este passo", true);
+                    if (reject) {
+                        await confirmRuntimeCliJob(config, jobId, "reject");
+                    }
+                    else {
+                        await cancelRuntimeCliJob(config, jobId, "Cancelado no Otto Console");
+                    }
+                }
+                awaitingDecision = false;
+                continue;
+            }
+            if (status === "completed" || status === "failed" || status === "cancelled") {
+                const summary = extractJobSummary(job)
+                    || (status === "completed"
+                        ? "Execução local concluída."
+                        : status === "failed"
+                            ? "Execução local falhou."
+                            : "Execução local cancelada.");
+                if (status === "completed") {
+                    emitAssistantPrompt(summary);
+                }
+                else {
+                    emitConsoleEntry(summary, status === "failed" ? "error" : "warning");
+                }
+                const rendered = renderStructuredOutcome(job);
+                if (rendered) {
+                    emitConsoleEntry(rendered, "muted");
+                }
+                return buildConversationSummary(summary, job);
+            }
+            await delay(1400);
+        }
     };
     const handlePrompt = async (promptText) => {
         const normalizedPrompt = normalizeText(promptText);
@@ -1336,62 +1955,89 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
         }
         if (normalizedPrompt === "/clear") {
             conversation.splice(0, conversation.length);
-            printConsoleScreen(runtimeSession, activeModel);
-            printMuted("Contexto local do console limpo.");
+            ui?.clearTranscript();
+            renderConversationState();
+            if (!ui) {
+                printConsoleScreen(runtimeSession);
+            }
+            emitConsoleEntry("Contexto local do console limpo.", "muted");
             return;
         }
         if (normalizedPrompt === "/model") {
-            printMuted(`Modelo ativo: ${getCliModelLabel(activeModel)}.`);
-            printSoft("Use /model fast ou /model thinking para trocar.");
+            emitConsoleEntry(`Modelo ativo: ${getCliModelLabel(activeModel)}.`, "muted");
+            emitConsoleEntry("Use /model fast ou /model thinking para trocar.", "muted");
             return;
         }
         if (normalizedPrompt.startsWith("/model ")) {
             const nextMode = resolveCliModelMode(normalizedPrompt.slice("/model ".length));
             if (!nextMode) {
-                printWarning("Modelo inválido. Use /model fast ou /model thinking.");
+                emitConsoleEntry("Modelo inválido. Use /model fast ou /model thinking.", "warning");
                 return;
             }
             if (nextMode === activeModel) {
-                printMuted(`Modelo já está em ${getCliModelLabel(activeModel)}.`);
+                emitConsoleEntry(`Modelo já está em ${getCliModelLabel(activeModel)}.`, "muted");
                 return;
             }
             activeModel = nextMode;
-            printConsoleScreen(runtimeSession, activeModel);
-            printSuccess(`Modelo ativo: ${getCliModelLabel(activeModel)}.`);
+            renderConversationState();
+            emitConsoleEntry(`Modelo ativo: ${getCliModelLabel(activeModel)}.`, "success");
+            return;
+        }
+        if (normalizedPrompt === "/approval") {
+            emitConsoleEntry(`Modo atual: ${getConsoleApprovalFooterState(config.approvalMode).label}.`, "muted");
+            emitConsoleEntry("Use /approval preview, /approval confirm ou /approval trusted.", "muted");
+            return;
+        }
+        if (normalizedPrompt.startsWith("/approval ")) {
+            const nextMode = normalizeText(normalizedPrompt.slice("/approval ".length)).toLowerCase();
+            if (!["preview", "confirm", "trusted"].includes(nextMode)) {
+                emitConsoleEntry("Modo inválido. Use /approval preview, /approval confirm ou /approval trusted.", "warning");
+                return;
+            }
+            if (nextMode === config.approvalMode) {
+                emitConsoleEntry(`O modo de aprovação já está em ${getConsoleApprovalFooterState(config.approvalMode).label}.`, "muted");
+                return;
+            }
+            await setApprovalMode(nextMode);
             return;
         }
         if (normalizedPrompt === "/status") {
-            console.log(`${style("Model", ANSI.brandBlue, supportsAnsi())}: ${getCliModelLabel(activeModel)}`);
-            renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
+            emitConsoleEntry(`Model: ${getCliModelLabel(activeModel)}`, "muted");
+            renderStatusOverview(config, runtimeSession).forEach((line) => emitConsoleEntry(line, "muted"));
             const runtimeFailure = runtimeSession.getLastError();
             if (runtimeFailure) {
-                printWarning(`Runtime reportou erro: ${runtimeFailure}`);
+                emitConsoleEntry(`Runtime reportou erro: ${runtimeFailure}`, "warning");
             }
             return;
         }
         if (normalizedPrompt.startsWith("/workspace")) {
             try {
-                if (await handleConsoleWorkspaceCommand(normalizedPrompt, config, sessionId)) {
+                if (await handleWorkspaceCommand(normalizedPrompt)) {
                     return;
                 }
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error || "Erro ao gerenciar workspace.");
-                printError(detail);
+                emitConsoleEntry(detail, "error");
                 return;
             }
         }
         if (normalizedPrompt === "/exit") {
             throw createCliExitError();
         }
+        emitUserPrompt(normalizedPrompt);
+        emitConsoleEntry("", "muted");
         conversation.push({ role: "user", content: normalizedPrompt });
         while (conversation.length > 18) {
             conversation.shift();
         }
+        renderConversationState();
         let streamedAssistant = "";
+        let assistantEntryId = null;
         let assistantPrefixPrinted = false;
         let reasoningPrefixPrinted = false;
         let contentSeparatedFromReasoning = false;
+        let reasoningEntryId = null;
         let handoffPayload = null;
         await streamDeviceCliChat(config, {
             messages: conversation,
@@ -1407,7 +2053,7 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
             if (chunkType === "search_status") {
                 const status = normalizeText(event.status);
                 if (status) {
-                    printMuted(`Busca: ${status}`);
+                    emitConsoleEntry(`Busca: ${status}`, "muted");
                 }
                 return;
             }
@@ -1420,10 +2066,18 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
                 : "";
             if (reasoningChunk) {
                 if (!reasoningPrefixPrinted) {
-                    output.write(`${style("Pensando (OttoAI Thinking)\n", ANSI.brandBlue, supportsAnsi())}`);
+                    emitConsoleEntry("Pensando (OttoAI Thinking)", "headline");
+                    reasoningEntryId = ui
+                        ? ui.pushEntry({ text: "", tone: "reasoning" })
+                        : null;
                     reasoningPrefixPrinted = true;
                 }
-                output.write(style(reasoningChunk, ANSI.slateItalic, supportsAnsi()));
+                if (ui && reasoningEntryId) {
+                    ui.appendToEntry(reasoningEntryId, reasoningChunk);
+                }
+                else {
+                    output.write(style(reasoningChunk, ANSI.slateItalic, supportsAnsi()));
+                }
                 return;
             }
             const contentChunk = typeof event.content === "string" ? event.content : "";
@@ -1431,17 +2085,33 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
                 return;
             }
             if (reasoningPrefixPrinted && !contentSeparatedFromReasoning) {
-                output.write("\n\n");
+                emitConsoleEntry("", "muted");
                 contentSeparatedFromReasoning = true;
             }
             if (!assistantPrefixPrinted) {
-                output.write(`${style("•", ANSI.brandBlue, supportsAnsi())} `);
+                assistantEntryId = ui
+                    ? ui.pushEntry({
+                        text: "",
+                        tone: "assistant",
+                        prefix: "• ",
+                        prefixTone: "assistant",
+                        continuationPrefix: "  ",
+                    })
+                    : null;
+                if (!ui) {
+                    output.write(styleTranscriptPrefix("• ", "assistant", supportsAnsi()));
+                }
                 assistantPrefixPrinted = true;
             }
-            output.write(contentChunk);
+            if (ui && assistantEntryId) {
+                ui.appendToEntry(assistantEntryId, contentChunk);
+            }
+            else {
+                output.write(contentChunk);
+            }
             streamedAssistant += contentChunk;
         });
-        if (assistantPrefixPrinted) {
+        if (assistantPrefixPrinted && !ui) {
             output.write("\n");
         }
         let finalAssistantSummary = normalizeText(streamedAssistant);
@@ -1453,10 +2123,10 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
                 : null;
             const jobId = normalizeText(job?.id);
             if (bridgeSummary && !jobId) {
-                printAssistantMessage(bridgeSummary);
+                emitAssistantPrompt(bridgeSummary);
             }
             if (jobId) {
-                finalAssistantSummary = await followConsoleJob(rl, config, jobId);
+                finalAssistantSummary = await followConsoleJobUi(jobId);
             }
             else if (bridgeSummary) {
                 finalAssistantSummary = bridgeSummary;
@@ -1467,23 +2137,29 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
             while (conversation.length > 18) {
                 conversation.shift();
             }
+            renderConversationState();
         }
     };
-    if (options?.initialPrompt) {
-        await handlePrompt(options.initialPrompt);
-    }
-    for (;;) {
-        const promptText = await askConsoleInput(rl);
-        try {
-            await handlePrompt(promptText);
+    try {
+        if (options?.initialPrompt) {
+            await handlePrompt(options.initialPrompt);
         }
-        catch (error) {
-            if (isCliExitError(error)) {
-                break;
+        for (;;) {
+            const promptText = await readConsoleInput();
+            try {
+                await handlePrompt(promptText);
+            }
+            catch (error) {
+                if (isCliExitError(error)) {
+                    break;
+                }
+                throw error;
             }
-            throw error;
         }
     }
+    finally {
+        ui?.dispose();
+    }
 }
 async function printStatusView(rl, config, runtimeSession) {
     printSection("Bridge Status");
@@ -1516,7 +2192,7 @@ async function printHelpView(rl) {
         { text: "otto-bridge version | otto-bridge unpair", tone: "primary" },
         { text: "Mostra a versao instalada ou remove o pairing local.", tone: "muted" },
         { text: "", tone: "muted" },
-        { text: "Dentro do console: /help, /model fast|thinking, /status, /clear, /exit", tone: "muted" },
+        { text: "Dentro do console: /help, /model fast|thinking, /approval preview|confirm|trusted, /status, /clear, /exit", tone: "muted" },
     ]));
     await pauseForEnter(rl);
 }
@@ -1570,7 +2246,7 @@ export async function launchInteractiveCli(options) {
     try {
         let config = await loadBridgeConfig();
         if (!config) {
-            printHubScreen(null, "fast");
+            printHubScreen(null);
             const setup = await runSetupWizard(rl, options);
             config = setup.config;
             if (config && setup.openConsole) {
@@ -1587,7 +2263,7 @@ export async function launchInteractiveCli(options) {
         await runtimeSession.ensureStarted();
         await runtimeSession.waitForReady();
         for (;;) {
-            printHubScreen(runtimeSession, "fast");
+            printHubScreen(runtimeSession);
             const choice = await pickHomeChoice(rl, true);
             if (choice === "exit") {
                 break;
@@ -1685,7 +2361,7 @@ export async function runSetupCommand(options) {
     const rl = await createPromptInterface();
     let runtimeSession = null;
     try {
-        printHubScreen(null, "fast");
+        printHubScreen(null);
         const setup = await runSetupWizard(rl, options);
         if (setup.config && setup.openConsole) {
             runtimeSession = new CliRuntimeSession(setup.config);
@@ -1708,7 +2384,7 @@ export async function runConsoleCommand(initialPrompt) {
     const rl = await createPromptInterface();
     let runtimeSession = null;
     try {
-        printHubScreen(null, "fast");
+        printHubScreen(null);
         let config = await loadBridgeConfig();
         if (!config) {
             const setup = await runSetupWizard(rl);

package/dist/http.js

@@ -60,6 +60,15 @@ export async function postDeviceJson(apiBaseUrl, deviceToken, pathname, body) {
         body: JSON.stringify(body),
     });
 }
+export async function patchDeviceJson(apiBaseUrl, deviceToken, pathname, body) {
+    return await requestJson(apiBaseUrl, pathname, {
+        method: "PATCH",
+        headers: buildDeviceAuthHeaders(deviceToken, {
+            "Content-Type": "application/json",
+        }),
+        body: JSON.stringify(body),
+    });
+}
 export async function deleteDeviceJson(apiBaseUrl, deviceToken, pathname) {
     return await requestJson(apiBaseUrl, pathname, {
         method: "DELETE",

package/dist/main.js

@@ -122,6 +122,7 @@ Console:
   /help
   /model fast
   /model thinking
+  /approval preview|confirm|trusted
   /workspace
   /workspace attach <path>
   /workspace use <id|n>

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "1.1.0";
+export const BRIDGE_VERSION = "1.1.2";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",

package/scripts/postinstall.mjs

@@ -24,7 +24,7 @@ if (!existsSync(mainPath)) {
   process.exit(0);
 }
 
-console.log("\n[otto-bridge] Welcome to OTTOAI 1.1.0");
+console.log("\n[otto-bridge] Welcome to OTTOAI 1.1.2");
 console.log("[otto-bridge] Vamos iniciar o setup interativo do bridge.\n");
 
 const result = spawnSync(process.execPath, [mainPath, "setup", "--postinstall"], {