@leg3ndy/otto-bridge 1.0.12 → 1.1.0

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.0.12`, com composer TTY simplificado para um prompt multiline sem moldura, cursor alinhado ao placeholder e newline sem abrir caixas duplicadas, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_0_12_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_0_12_PATCH.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).
 
 ## 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.0.12.tgz
+npm install -g ./leg3ndy-otto-bridge-1.1.0.tgz
 ```
 
-Na linha `1.0.12`, `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.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.
 
-No macOS, a linha `1.0.12` 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.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 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.0.12` preserva esse fluxo, simplifica o prompt TTY para evitar artefatos de moldura em terminais mais temperamentais, mantem o composer multiline e melhora as views de status/extensoes e o refresh ao sair do `Terminal`.
+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.
 
 ## Publicacao
 
@@ -84,6 +84,8 @@ otto-bridge
 
 Em TTY, o comando sem argumentos agora abre o hub interativo com banner, setup, status, extensoes e o `Otto Console`. Se ja existir pairing salvo, o próprio `otto-bridge` sobe o runtime local automaticamente e mostra o estado da conexão no hub.
 
+Na web, o acesso ao Otto Bridge fica no botao com icone de estrela/brilho ao lado do botao de anexos.
+
 ### Setup interativo
 
 ```bash
@@ -92,6 +94,8 @@ otto-bridge setup
 
 Esse fluxo pede `API base URL`, `pairing code`, nome do dispositivo e executor. Em install global interativo, o pacote tambem tenta abrir esse setup automaticamente quando ainda nao existe pairing salvo.
 
+O `pairing code` e gerado no modal do Otto Bridge aberto pela interface web, no botao com icone de estrela ao lado de anexos.
+
 ### Parear o dispositivo
 
 ```bash
@@ -142,6 +146,11 @@ Dentro do console, use:
 - `/model fast` para `OttoAI Fast`
 - `/model thinking` para `OttoAI Thinking`
 - `/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
+- `/workspace attach <path>` para anexar uma pasta/repo novo pelo helper autenticado
+- `/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 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.
 
@@ -157,7 +166,7 @@ Esse comando abre um shell local interativo para instalar extensoes, rodar coman
 
 ### WhatsApp Web em background
 
-Fluxo recomendado na linha `1.0.12`:
+Fluxo recomendado na linha `1.1.0`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -167,13 +176,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.0.12`:
+Contrato da linha `1.1.0`:
 
 - `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.0.12
+## Handoff rapido da linha 1.1.0
 
 Ja fechado no codigo:
 
@@ -187,8 +196,10 @@ Ja fechado no codigo:
 - o executor `native-macos` agora reporta o step atual por acao e publica inline artifacts estruturados para resultados locais nao-uploadados
 - o `runtime_contract` agora pode declarar `workspace_context` com roots/targets e descriptors de `instruction_bundle`, `repo_manifest`, `workspace_index`, `workspace_memory` e `workspace_policy` para jobs de arquivo e shell
 - o bridge agora resolve `workspace_context` em paths absolutos, detecta `repo_root`, carrega `AGENTS.md` por precedencia e publica `instruction_bundle`, `repo_manifest`, `workspace_index`, `workspace_memory` e `workspace_policy` no resultado
+- workspaces anexados pelo modal web agora tambem viram parte do metadata do helper: o `otto-bridge` consulta `/v1/devices/runtime/workspaces` com `device_token`, sonda localmente `repo_root`, `branch` e a cadeia de `AGENTS.md` antes do `device.hello`, e reage a `device.metadata.refresh` para republicar esse snapshot quando o usuario anexa/remove um workspace com o bridge online
 - filesystem e shell locais agora respeitam os roots declarados do workspace, em vez de operar como superficie global quando o job vier escopado
 - `workspace_policy` agora aplica perfis `observe_only`, `dev_assist`, `workspace_coding` e `release_operator` antes da execucao local de actions escopadas
+- cada workspace anexado agora tambem persiste o proprio `policy_profile_id`; o modal do Otto Bridge permite trocar esse perfil, o banner do chat mostra o trust atual e o runtime trata esse valor como teto real da sessao antes de shell, patch, delete ou release
 - `write_json_file`, `mkdir`, `move_file` e `delete_file` agora fazem parte da familia inicial de file ops tipadas do workspace
 - `workspace.patch`, `git.clone`, `git.fetch`, `git.checkout`, `git.rebase`, `git.merge`, `git.tag`, `git.status`, `git.diff`, `git.stage`, `git.commit`, `git.push` e `workspace.tests` agora fazem parte da primeira familia tipada de coding agent do catalogo local
 - `apply_patch`, `git_status`, `git_diff`, `run_tests`, `git_clone`, `git_fetch`, `git_checkout`, `git_rebase`, `git_merge`, `git_tag`, `git_add`, `git_commit` e `git_push` agora executam dentro do workspace escopado e devolvem snapshots estruturados em vez de shell cru
@@ -207,6 +218,10 @@ Ja fechado no codigo:
 - o `instruction_updater` agora e um descriptor explicito do runtime, com `source_entrypoints`, `target_paths` e `recommended_validation_stage_ids` quando o plano toca `AGENTS.md`, `README.md` ou `docs/`
 - `workspace.tests` agora consegue resolver `profile=auto` via `validation_ladder`, executando stages como `typecheck`, `build`, `node_test`, `lint` e `pytest` por stack, com snapshot agregado por etapa
 - o executor `native-macos` agora publica `runtime_hook_trace` somando hooks de lifecycle e tool-use (`session_start`, `pre_tool_use`, `post_tool_use`, `validation_ladder_started/completed`, `session_end`), preparando enforcement, replay fino e metricas futuras
+- o frontend agora consome `runtime_hook_trace`, `runtime_replay` e o progresso corrente como feed inline persistente no chat, para o usuario ver o Otto lendo, procurando, editando, validando e concluindo em tempo real
+- o chat web agora mostra esse plano/checklist acima do input enquanto o job local roda, e deixa o bloco detalhado de runtime apenas para o resultado final quando houver detalhe real de arquivo/diff/source control/validacao/erro
+- o catalogo local agora inclui `filesystem.open_path`, usado para abrir um arquivo/pasta local no app padrao do macOS ou revelar no Finder a partir dos links clicaveis do timeline
+- o modal do Otto Bridge agora mostra `Jobs locais` em resumo textual, `Snapshot do workspace` com source control/validacao/working set e links de path que disparam `open_path` local, sem repetir a timeline detalhada do chat
 - o bridge agora possui um CLI interativo proprio com setup inicial, hub terminal e `Otto Console` para conversar com o Otto pelo proprio terminal
 - o backend agora expoe caminhos `device-auth` para o console do bridge usar chat com quota/plano (`/v1/devices/cli/chat/completions`) e acompanhar approval/job usando apenas `device_token`
 - o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta

package/dist/agentic_runtime/workspace/manager.js

@@ -245,6 +245,12 @@ function normalizeWorkspacePolicy(value, workspaceId, actionTypes, destructiveAc
     const title = asString(value?.title) || WORKSPACE_POLICY_TITLES[profileId] || "Workspace Policy";
     const summary = asString(value?.summary)
         || `Policy ${profileId} carregada para o workspace ${workspaceId} com ${allowedActionTypes.length} action types permitidos.`;
+    const rationale = asString(value?.rationale)
+        || (normalizedActionTypes.length > 0
+            ? value?.profile_id
+                ? `Perfil ${profileId} aplicado ao workspace para actions do runtime: ${normalizedActionTypes.join(", ")}.`
+                : `Perfil inferido a partir das actions do runtime: ${normalizedActionTypes.join(", ")}.`
+            : undefined);
     return {
         profile_id: profileId || "observe_only",
         title,
@@ -252,9 +258,7 @@ function normalizeWorkspacePolicy(value, workspaceId, actionTypes, destructiveAc
         allowed_action_types: allowedActionTypes,
         blocked_action_types: blockedActionTypes,
         requires_confirmation_action_types: requiresConfirmationActionTypes,
-        rationale: asString(value?.rationale) || (normalizedActionTypes.length > 0
-            ? `Perfil inferido a partir das actions do runtime: ${normalizedActionTypes.join(", ")}.`
-            : undefined),
+        rationale,
         allow_shell: allowShell,
         allow_code_write: allowCodeWrite,
         allow_destructive: allowDestructive,
@@ -1036,9 +1040,9 @@ export function assertActionAllowedByWorkspacePolicy(workspace, actionType) {
         return;
     }
     if (workspacePolicy.blocked_action_types.includes(normalizedActionType)) {
-        throw new Error(`A action ${normalizedActionType} foi bloqueada pela policy ${workspacePolicy.profile_id} do workspace ${workspace.workspaceId}.`);
+        throw new Error(`A policy ${workspacePolicy.profile_id} deste workspace bloqueia a action ${normalizedActionType}. Troque o perfil de confiança do workspace para liberar essa operação.`);
     }
     if (!workspacePolicy.allowed_action_types.includes(normalizedActionType)) {
-        throw new Error(`A action ${normalizedActionType} nao esta permitida pela policy ${workspacePolicy.profile_id} do workspace ${workspace.workspaceId}.`);
+        throw new Error(`A action ${normalizedActionType} nao está permitida no perfil ${workspacePolicy.profile_id} deste workspace. Ajuste a policy do workspace para permitir essa operação.`);
     }
 }

package/dist/attached_workspaces.js

@@ -0,0 +1,259 @@
+import { execFile } from "node:child_process";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { deleteDeviceJson, getDeviceJson, postDeviceJson } from "./http.js";
+import { resolveWorkspaceContext, expandUserPathLike } from "./agentic_runtime/workspace/manager.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_IGNORED_DIRECTORY_NAMES = [
+    ".git",
+    ".next",
+    ".venv",
+    "__pycache__",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "venv",
+];
+const DEFAULT_KEY_FILE_PATTERNS = [
+    "AGENTS.md",
+    "README.md",
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+];
+function asString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((item) => asString(item)).filter(Boolean)));
+}
+function slugifyWorkspaceToken(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return slug.slice(0, 120) || "workspace_local";
+}
+function deriveWorkspaceLabel(rootPath) {
+    const normalized = rootPath.replace(/[\\/]+$/, "");
+    const basename = path.basename(normalized);
+    return basename || normalized || "Workspace local";
+}
+function normalizeAttachedWorkspaceCandidate(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const payload = value;
+    const rootPath = asString(payload.root_path)
+        || asString(payload.path)
+        || asString(payload.workspace_root);
+    if (!rootPath) {
+        return null;
+    }
+    const workspaceId = asString(payload.workspace_id) || `workspace_${slugifyWorkspaceToken(rootPath)}`;
+    return {
+        workspace_id: workspaceId,
+        label: asString(payload.label) || asString(payload.name) || deriveWorkspaceLabel(rootPath),
+        root_path: rootPath,
+        repo_root: asString(payload.repo_root) || rootPath,
+        branch: asString(payload.branch) || null,
+        is_git_repo: Boolean(payload.is_git_repo),
+        agents_loaded: payload.agents_loaded === true,
+        agents_paths: Array.isArray(payload.agents_paths)
+            ? uniqueStrings(payload.agents_paths)
+            : [],
+        policy_profile_id: asString(payload.policy_profile_id) || asString(payload.workspace_policy_profile) || "workspace_coding",
+        policy_updated_at: asString(payload.policy_updated_at) || null,
+        updated_at: asString(payload.updated_at) || null,
+    };
+}
+async function resolveWorkspaceRootPath(rootPath, baseCwd) {
+    const expanded = expandUserPathLike(rootPath, baseCwd);
+    try {
+        const fileStat = await stat(expanded);
+        if (fileStat.isFile()) {
+            return path.dirname(expanded);
+        }
+    }
+    catch {
+        return expanded;
+    }
+    return expanded;
+}
+async function readGitBranch(repoRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", repoRoot, "branch", "--show-current"], {
+            timeout: 4000,
+        });
+        const branch = asString(stdout);
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function probeAttachedWorkspace(workspace, options) {
+    const resolvedRootPath = await resolveWorkspaceRootPath(workspace.root_path, options?.baseCwd);
+    const resolvedWorkspace = await resolveWorkspaceContext({
+        baseCwd: options?.baseCwd,
+        workspaceContext: {
+            workspace_id: workspace.workspace_id,
+            roots: [
+                {
+                    root_id: "workspace_root_01",
+                    path: resolvedRootPath,
+                    kind: "declared_path",
+                    scope_reason: "attached_workspace_root",
+                    action_types: ["filesystem_inspect"],
+                    source: "bridge_attached_workspace_probe",
+                },
+            ],
+            targets: [
+                {
+                    target_id: "workspace_target_01",
+                    path: resolvedRootPath,
+                    kind: "directory",
+                    access_mode: "enumerate",
+                    action_type: "filesystem_inspect",
+                    source: "bridge_attached_workspace_probe",
+                },
+            ],
+            instruction_bundle: {
+                resolver: "bridge_local_agents_md",
+                entrypoints: ["AGENTS.md"],
+                precedence: [
+                    "nearest_target_agents_md",
+                    "workspace_repo_agents_md",
+                    "monorepo_root_agents_md",
+                ],
+            },
+            repo_manifest: {
+                resolver: "bridge_workspace_repo_probe",
+                marker_paths: [".git"],
+                manifest_paths: ["AGENTS.md", "README.md", "package.json", "pyproject.toml", "requirements.txt", "Cargo.toml", "go.mod"],
+                lockfile_paths: ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "poetry.lock", "Pipfile.lock", "Cargo.lock", "go.sum"],
+                include_instruction_sources: true,
+                vcs_hint: "git",
+            },
+            workspace_index: {
+                resolver: "bridge_workspace_scan_light",
+                max_depth: 1,
+                max_directories: 8,
+                max_files: 32,
+                ignored_directory_names: DEFAULT_IGNORED_DIRECTORY_NAMES,
+                key_file_patterns: DEFAULT_KEY_FILE_PATTERNS,
+            },
+        },
+    });
+    const repoRoot = resolvedWorkspace?.repoRoot || resolvedRootPath;
+    const branch = resolvedWorkspace?.repoRoot
+        ? await readGitBranch(resolvedWorkspace.repoRoot).catch(() => null)
+        : null;
+    const agentsPaths = resolvedWorkspace?.instructionBundle?.sources.map((item) => item.path) || [];
+    return {
+        workspace_id: workspace.workspace_id,
+        label: workspace.label || deriveWorkspaceLabel(resolvedRootPath),
+        root_path: resolvedRootPath,
+        repo_root: repoRoot,
+        branch: branch || workspace.branch || null,
+        is_git_repo: Boolean(resolvedWorkspace?.repoRoot),
+        agents_loaded: agentsPaths.length > 0,
+        agents_paths: agentsPaths,
+        policy_profile_id: workspace.policy_profile_id || "workspace_coding",
+        policy_updated_at: workspace.policy_updated_at || workspace.updated_at || null,
+        updated_at: new Date().toISOString(),
+    };
+}
+export async function loadAttachedWorkspacesForHello(options) {
+    const fallbackCandidates = Array.isArray(options.fallbackMetadata?.attached_workspaces)
+        ? options.fallbackMetadata?.attached_workspaces || []
+        : [];
+    let rawCandidates = fallbackCandidates;
+    try {
+        const response = await getDeviceJson(options.apiBaseUrl, options.deviceToken, "/v1/devices/runtime/workspaces");
+        if (Array.isArray(response.workspaces)) {
+            rawCandidates = response.workspaces;
+        }
+    }
+    catch {
+        // Fall back to whatever the local config already knows.
+    }
+    const candidates = rawCandidates
+        .map((item) => normalizeAttachedWorkspaceCandidate(item))
+        .filter((item) => Boolean(item));
+    if (candidates.length === 0) {
+        return [];
+    }
+    const probed = await Promise.all(candidates.map(async (workspace) => {
+        try {
+            return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+        }
+        catch {
+            return {
+                ...workspace,
+                root_path: expandUserPathLike(workspace.root_path, options.baseCwd),
+                updated_at: new Date().toISOString(),
+            };
+        }
+    }));
+    return probed;
+}
+export async function listAttachedWorkspacesForRuntime(options) {
+    return await loadAttachedWorkspacesForHello({
+        apiBaseUrl: options.apiBaseUrl,
+        deviceToken: options.deviceToken,
+        baseCwd: options.baseCwd,
+    });
+}
+export async function getRuntimeSessionWorkspace(options) {
+    const sessionId = asString(options.sessionId);
+    if (!sessionId) {
+        return null;
+    }
+    const response = await getDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/sessions/${encodeURIComponent(sessionId)}/workspace`);
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        return null;
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function attachWorkspaceForRuntime(options) {
+    const response = await postDeviceJson(options.apiBaseUrl, options.deviceToken, "/v1/devices/runtime/workspaces/attach", {
+        root_path: options.rootPath,
+        label: asString(options.label) || undefined,
+        repo_root: asString(options.repoRoot) || undefined,
+        branch: asString(options.branch) || undefined,
+    });
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        throw new Error("Workspace anexado sem payload válido.");
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function activateWorkspaceForRuntime(options) {
+    const workspaceId = asString(options.workspaceId);
+    const sessionId = asString(options.sessionId);
+    if (!workspaceId || !sessionId) {
+        throw new Error("Workspace e sessão são obrigatórios para ativar o contexto do console.");
+    }
+    const response = await postDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/workspaces/${encodeURIComponent(workspaceId)}/activate`, { session_id: sessionId });
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        return null;
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function clearRuntimeWorkspaceForSession(options) {
+    const sessionId = asString(options.sessionId);
+    if (!sessionId) {
+        return;
+    }
+    await deleteDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/sessions/${encodeURIComponent(sessionId)}/workspace`);
+}

package/dist/cli_terminal.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
-import { cursorTo, moveCursor, } from "node:readline";
+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 { activateWorkspaceForRuntime, attachWorkspaceForRuntime, clearRuntimeWorkspaceForSession, getRuntimeSessionWorkspace, listAttachedWorkspacesForRuntime, } from "./attached_workspaces.js";
 import { streamDeviceCliChat, } from "./chat_cli_client.js";
 import { formatManagedBridgeExtensionStatus, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 import { pairDevice } from "./pairing.js";
@@ -52,7 +53,7 @@ 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], /status, /clear, /exit";
+const CONSOLE_COMMAND_HINT = "/help, /model [fast|thinking], /workspace, /status, /clear, /exit";
 const CONSOLE_COMPOSER_PROMPT_WIDTH = 2;
 const CONSOLE_COMPOSER_CURSOR_COLUMN = 2;
 class CliRuntimeSession {
@@ -674,11 +675,139 @@ function printConsoleScreen(runtimeSession, modelMode) {
     printSoft(`Comandos: ${CONSOLE_COMMAND_HINT}`);
     console.log("");
 }
-function enableTerminalEnhancedKeys() {
-    output.write("\u001b[>4;2m");
+function formatConsoleWorkspaceLine(workspace, options) {
+    const prefix = options?.isActive ? "*" : "-";
+    const indexPrefix = typeof options?.index === "number" ? `${options.index + 1}. ` : "";
+    const label = normalizeText(workspace.label || workspace.workspace_id || "Workspace local");
+    const rootPath = normalizeText(workspace.repo_root || workspace.root_path || "");
+    const branch = normalizeText(workspace.branch);
+    const agents = workspace.agents_loaded ? "AGENTS.md" : "sem AGENTS.md";
+    return `${prefix} ${indexPrefix}${label}${rootPath ? ` -> ${rootPath}` : ""}${branch ? ` [${branch}]` : ""} (${agents})`;
+}
+function resolveConsoleWorkspaceSelection(token, workspaces) {
+    const normalized = normalizeText(token);
+    if (!normalized) {
+        return null;
+    }
+    const numericIndex = Number(normalized);
+    if (Number.isInteger(numericIndex) && numericIndex >= 1 && numericIndex <= workspaces.length) {
+        return workspaces[numericIndex - 1] || null;
+    }
+    const lowered = normalized.toLowerCase();
+    return workspaces.find((workspace) => {
+        const workspaceId = normalizeText(workspace.workspace_id).toLowerCase();
+        const label = normalizeText(workspace.label).toLowerCase();
+        const rootPath = normalizeText(workspace.root_path || workspace.repo_root).toLowerCase();
+        return workspaceId === lowered || label === lowered || rootPath === lowered;
+    }) || null;
+}
+async function printConsoleWorkspaceStatus(config, sessionId) {
+    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(),
+        }),
+    ]);
+    printSection("Workspace");
+    if (activeWorkspace) {
+        printSuccess(`Ativo neste console: ${formatConsoleWorkspaceLine(activeWorkspace, { isActive: true })}`);
+    }
+    else {
+        printMuted("Nenhum workspace ativo neste console.");
+    }
+    if (workspaces.length === 0) {
+        printSoft("Nenhum workspace anexado. Use /workspace attach <caminho>.");
+        return;
+    }
+    workspaces.forEach((workspace, index) => {
+        const isActive = normalizeText(workspace.workspace_id) === normalizeText(activeWorkspace?.workspace_id);
+        console.log(formatConsoleWorkspaceLine(workspace, { index, isActive }));
+    });
+}
+async function handleConsoleWorkspaceCommand(normalizedPrompt, config, sessionId) {
+    if (!normalizedPrompt.startsWith("/workspace")) {
+        return false;
+    }
+    const remainder = normalizeText(normalizedPrompt.slice("/workspace".length));
+    if (!remainder || remainder === "list" || remainder === "status") {
+        await printConsoleWorkspaceStatus(config, sessionId);
+        return true;
+    }
+    if (remainder === "help") {
+        printSection("Workspace");
+        printSoft("/workspace                lista os workspaces anexados e o ativo");
+        printSoft("/workspace attach <path>  anexa uma pasta/repo neste device");
+        printSoft("/workspace use <id|n>     ativa o workspace para o console atual");
+        printSoft("/workspace clear          remove o workspace ativo deste console");
+        return true;
+    }
+    if (remainder.startsWith("attach ")) {
+        const rootPath = normalizeText(remainder.slice("attach ".length));
+        if (!rootPath) {
+            printWarning("Use /workspace attach <caminho>.");
+            return true;
+        }
+        const workspace = await attachWorkspaceForRuntime({
+            apiBaseUrl: config.apiBaseUrl,
+            deviceToken: config.deviceToken,
+            rootPath,
+            baseCwd: process.cwd(),
+        });
+        printSuccess(`Workspace anexado: ${formatConsoleWorkspaceLine(workspace, { isActive: false })}`);
+        return true;
+    }
+    if (remainder.startsWith("use ")) {
+        const selectionToken = normalizeText(remainder.slice("use ".length));
+        if (!selectionToken) {
+            printWarning("Use /workspace use <id|numero>.");
+            return true;
+        }
+        const workspaces = await listAttachedWorkspacesForRuntime({
+            apiBaseUrl: config.apiBaseUrl,
+            deviceToken: config.deviceToken,
+            baseCwd: process.cwd(),
+        });
+        const selectedWorkspace = resolveConsoleWorkspaceSelection(selectionToken, workspaces);
+        if (!selectedWorkspace?.workspace_id) {
+            printWarning("Workspace não encontrado. Rode /workspace para listar as opções.");
+            return true;
+        }
+        const activated = await activateWorkspaceForRuntime({
+            apiBaseUrl: config.apiBaseUrl,
+            deviceToken: config.deviceToken,
+            workspaceId: selectedWorkspace.workspace_id,
+            sessionId,
+            baseCwd: process.cwd(),
+        });
+        if (activated) {
+            printSuccess(`Workspace ativo neste console: ${formatConsoleWorkspaceLine(activated, { isActive: true })}`);
+        }
+        else {
+            printWarning("Não foi possível ativar o workspace selecionado.");
+        }
+        return true;
+    }
+    if (remainder === "clear") {
+        await clearRuntimeWorkspaceForSession({
+            apiBaseUrl: config.apiBaseUrl,
+            deviceToken: config.deviceToken,
+            sessionId,
+        });
+        printMuted("Workspace ativo deste console removido.");
+        return true;
+    }
+    printWarning("Comando de workspace inválido. Use /workspace help.");
+    return true;
 }
-function disableTerminalEnhancedKeys() {
-    output.write("\u001b[>4m");
+function renderPromptFrameLine(width, edgeLeft, edgeRight) {
+    return style(`${edgeLeft}${"─".repeat(width)}${edgeRight}`, ANSI.brandBlue, supportsAnsi());
 }
 function sliceByWidth(text, width) {
     if (width <= 0) {
@@ -757,6 +886,9 @@ function renderConsoleComposerLines(value, innerWidth, enabled) {
         cursorColumn: layout.cursorColumn,
     };
 }
+function renderConsoleComposerText(lines) {
+    return lines.join("\r\n");
+}
 export function tryConsumeControlSequence(buffer) {
     const knownNewlineSequences = [
         "\u001b[13;2u",
@@ -813,98 +945,75 @@ async function askConsoleInput(rl) {
         const enabled = supportsAnsi();
         const availableWidth = Number(output.columns || 96);
         const innerWidth = Math.max(42, Math.min(availableWidth - 8, 116));
+        const sectionTopOffsetFromInputLine = 1;
         let renderedOnce = false;
-        let lastRenderedLineCount = 0;
-        let lastCursorLineIndex = 0;
         let value = "";
-        let pendingControlBuffer = "";
         const cleanup = () => {
             input.removeListener("data", onData);
-            disableTerminalEnhancedKeys();
             input.setRawMode(false);
             input.pause();
             rl.resume();
         };
+        const renderInputContent = () => {
+            const promptPlain = "> ";
+            const promptStyled = style(">", `${ANSI.bold}${ANSI.white}`, enabled);
+            const maxValueLength = Math.max(0, innerWidth - promptPlain.length);
+            if (!value) {
+                const placeholder = truncate(CONSOLE_PLACEHOLDER, maxValueLength);
+                const padded = `${style(placeholder, ANSI.slate, enabled)}${" ".repeat(Math.max(0, maxValueLength - placeholder.length))}`;
+                return `${promptStyled} ${padded}`;
+            }
+            const visibleValue = value.length > maxValueLength
+                ? value.slice(value.length - maxValueLength)
+                : value;
+            return `${promptStyled} ${visibleValue}${" ".repeat(Math.max(0, maxValueLength - visibleValue.length))}`;
+        };
         const render = () => {
-            const composer = renderConsoleComposerLines(value, innerWidth, enabled);
             if (renderedOnce) {
-                moveCursor(output, 0, -lastCursorLineIndex);
                 cursorTo(output, 0);
+                moveCursor(output, 0, -sectionTopOffsetFromInputLine);
             }
             else {
                 renderedOnce = true;
             }
-            output.write("\u001b[J");
-            output.write(composer.renderedLines.join("\n"));
-            moveCursor(output, 0, -Math.max(0, composer.renderedLines.length - 1 - composer.cursorLineIndex));
-            cursorTo(output, CONSOLE_COMPOSER_CURSOR_COLUMN + composer.cursorColumn);
-            lastRenderedLineCount = composer.renderedLines.length;
-            lastCursorLineIndex = composer.cursorLineIndex;
-        };
-        const insertNewline = () => {
-            value = `${value}\n`;
-            render();
-        };
-        const submitPrompt = () => {
-            if (renderedOnce) {
-                moveCursor(output, 0, Math.max(0, lastRenderedLineCount - 1 - lastCursorLineIndex));
-                cursorTo(output, 0);
-            }
-            cleanup();
-            output.write("\n");
-            resolve(normalizeText(value));
+            const top = renderPromptFrameLine(innerWidth + 2, "┌", "┐");
+            const border = style("│", ANSI.brandBlue, enabled);
+            const middle = `${border} ${renderInputContent()} ${border}`;
+            const bottom = renderPromptFrameLine(innerWidth + 2, "└", "┘");
+            clearScreenDown(output);
+            output.write(`${top}\n${middle}\n${bottom}\n`);
+            cursorTo(output, 0);
+            moveCursor(output, 0, -2);
+            const visibleValueLength = Math.min(value.length, Math.max(0, innerWidth - 2));
+            cursorTo(output, 4 + visibleValueLength);
         };
         const onData = (chunk) => {
-            pendingControlBuffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
-            while (pendingControlBuffer.length > 0) {
-                if (pendingControlBuffer.startsWith("\u0003")) {
+            const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+            for (const char of Array.from(text)) {
+                if (char === "\u0003") {
                     cleanup();
                     reject(createCliExitError());
                     return;
                 }
-                if (pendingControlBuffer.startsWith("\r")) {
-                    if (pendingControlBuffer.startsWith("\r\n")) {
-                        pendingControlBuffer = pendingControlBuffer.slice(2);
-                    }
-                    else {
-                        pendingControlBuffer = pendingControlBuffer.slice(1);
-                    }
-                    submitPrompt();
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    output.write("\n");
+                    resolve(normalizeText(value));
                     return;
                 }
-                if (pendingControlBuffer.startsWith("\n")) {
-                    pendingControlBuffer = pendingControlBuffer.slice(1);
-                    insertNewline();
-                    continue;
-                }
-                if (pendingControlBuffer.startsWith("\u007f") || pendingControlBuffer.startsWith("\b")) {
-                    pendingControlBuffer = pendingControlBuffer.slice(1);
+                if (char === "\u007f" || char === "\b") {
                     value = value.slice(0, -1);
                     render();
                     continue;
                 }
-                const controlSequence = tryConsumeControlSequence(pendingControlBuffer);
-                if (controlSequence) {
-                    if (controlSequence.action === "incomplete") {
-                        return;
-                    }
-                    pendingControlBuffer = pendingControlBuffer.slice(controlSequence.consumed);
-                    if (controlSequence.action === "newline") {
-                        insertNewline();
-                    }
+                if (char === "\u001b") {
                     continue;
                 }
-                const [char] = Array.from(pendingControlBuffer);
-                if (!char) {
-                    return;
-                }
-                pendingControlBuffer = pendingControlBuffer.slice(char.length);
                 value += char;
                 render();
             }
         };
         render();
-        enableTerminalEnhancedKeys();
         input.on("data", onData);
     });
 }
@@ -1211,9 +1320,10 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
     const conversation = [];
     const printConsoleHelp = () => {
         printSection("Console");
-        printSoft("Comandos: /help, /model [fast|thinking], /status, /clear, /exit");
+        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; Shift+Enter quebra linha quando suportado; Ctrl+J tambem insere newline.");
+        printSoft("Composer: Enter envia. Multiline desativado para evitar duplicacao no terminal.");
+        printSoft("Workspace: /workspace list, /workspace attach <path>, /workspace use <id|n>, /workspace clear");
     };
     const handlePrompt = async (promptText) => {
         const normalizedPrompt = normalizeText(promptText);
@@ -1259,6 +1369,18 @@ async function runOttoConsole(rl, config, runtimeSession, options) {
             }
             return;
         }
+        if (normalizedPrompt.startsWith("/workspace")) {
+            try {
+                if (await handleConsoleWorkspaceCommand(normalizedPrompt, config, sessionId)) {
+                    return;
+                }
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error || "Erro ao gerenciar workspace.");
+                printError(detail);
+                return;
+            }
+        }
         if (normalizedPrompt === "/exit") {
             throw createCliExitError();
         }

package/dist/executors/native_macos.js

@@ -941,6 +941,17 @@ function parseStructuredActions(job) {
             }
             continue;
         }
+        if (type === "open_path" || type === "open_local_path" || type === "reveal_in_finder") {
+            const targetPath = asString(action.path) || asString(action.target_path) || asString(action.file_path);
+            if (targetPath) {
+                actions.push({
+                    type: "open_path",
+                    path: targetPath,
+                    reveal_in_finder: action.reveal_in_finder === true || type === "reveal_in_finder",
+                });
+            }
+            continue;
+        }
         if (type === "create_note" || type === "write_note") {
             const text = asString(action.text) || asString(action.body) || asString(action.content);
             if (text) {
@@ -2062,6 +2073,26 @@ export class NativeMacOSJobExecutor {
                     });
                     continue;
                 }
+                if (action.type === "open_path") {
+                    await reportActionProgress(action.reveal_in_finder === true
+                        ? `Revelando ${action.path} no Finder`
+                        : `Abrindo ${action.path} no app padrão`);
+                    const openedPath = await this.openPathSnapshot(action.path, action.reveal_in_finder === true, workspaceContext);
+                    resultPayload.open_path = openedPath;
+                    resultPayload.summary = openedPath.summary;
+                    appendActionArtifact("open_path_result", {
+                        summary: openedPath.summary,
+                        path: openedPath.resolved_path,
+                        filename: openedPath.name,
+                    });
+                    completionNotes.push(openedPath.summary);
+                    appendHookEvent("post_tool_use", {
+                        stepId: currentActionStepId,
+                        message: `${action.type} concluido.`,
+                        metadata: { action_type: action.type, status: "completed" },
+                    });
+                    continue;
+                }
                 if (action.type === "read_file") {
                     await reportActionProgress(`Lendo ${action.path}`);
                     const fileContent = await this.readLocalFileSnapshot(action.path, action.max_chars, workspaceContext);
@@ -3044,6 +3075,37 @@ export class NativeMacOSJobExecutor {
         }
         await this.runCommand("open", [url]);
     }
+    async openPathSnapshot(targetPath, revealInFinder = false, workspaceContext) {
+        const resolvedPath = workspaceContext
+            ? assertPathInsideWorkspace(workspaceContext, targetPath)
+            : expandUserPath(targetPath);
+        const entryStat = await stat(resolvedPath);
+        const itemKind = entryStat.isDirectory()
+            ? "directory"
+            : entryStat.isFile()
+                ? "file"
+                : "other";
+        if (revealInFinder === true) {
+            await this.runCommand("open", ["-R", resolvedPath]);
+        }
+        else {
+            await this.runCommand("open", [resolvedPath]);
+        }
+        const summary = revealInFinder
+            ? `Revelei ${resolvedPath} no Finder do macOS.`
+            : itemKind === "directory"
+                ? `Abri a pasta ${resolvedPath} no Finder do macOS.`
+                : `Abri ${resolvedPath} no app padrao do macOS.`;
+        return {
+            captured_at: new Date().toISOString(),
+            path: targetPath,
+            resolved_path: resolvedPath,
+            name: path.basename(resolvedPath) || resolvedPath,
+            item_kind: itemKind,
+            reveal_in_finder: revealInFinder,
+            summary,
+        };
+    }
     async ensureSafariSpotifySearchUrl(url) {
         const targetUrl = normalizeUrl(url);
         for (let attempt = 0; attempt < 2; attempt += 1) {
@@ -8398,6 +8460,11 @@ if let output = String(data: data, encoding: .utf8) {
         if (action.type === "filesystem_inspect") {
             return `Inspecao local concluida em ${action.path}`;
         }
+        if (action.type === "open_path") {
+            return action.reveal_in_finder
+                ? `${action.path} foi revelado no Finder`
+                : `${action.path} foi aberto no app padrao do macOS`;
+        }
         if (action.type === "read_file") {
             return `${action.path} foi lido no macOS`;
         }

package/dist/http.js

@@ -60,6 +60,12 @@ export async function postDeviceJson(apiBaseUrl, deviceToken, pathname, body) {
         body: JSON.stringify(body),
     });
 }
+export async function deleteDeviceJson(apiBaseUrl, deviceToken, pathname) {
+    return await requestJson(apiBaseUrl, pathname, {
+        method: "DELETE",
+        headers: buildDeviceAuthHeaders(deviceToken),
+    });
+}
 export async function uploadDeviceJobArtifact(apiBaseUrl, deviceToken, jobId, params) {
     const form = new FormData();
     form.append("file", new Blob([Buffer.from(params.bytes)], { type: params.contentType || "application/octet-stream" }), params.filename);

package/dist/main.js

@@ -122,6 +122,10 @@ Console:
   /help
   /model fast
   /model thinking
+  /workspace
+  /workspace attach <path>
+  /workspace use <id|n>
+  /workspace clear
   /status
   /clear
   /exit

package/dist/runtime.js

@@ -7,6 +7,7 @@ import { isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "
 import { LocalAutomationRuntime } from "./local_automations.js";
 import { buildLocalToolCatalog } from "./tool_catalog.js";
 import { parseJobRuntimeManifest, runtimeStepIdForEvent, } from "./runtime_contract.js";
+import { loadAttachedWorkspacesForHello } from "./attached_workspaces.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -108,6 +109,19 @@ export class BridgeRuntime {
     emit(event) {
         this.options.logger?.event?.(event);
     }
+    async refreshHelloMetadata(socket, reason = "manual") {
+        if (socket.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        try {
+            await this.sendHello(socket);
+            this.logInfo(`[otto-bridge] hello metadata refreshed reason=${reason}`);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.logError(`[otto-bridge] hello metadata refresh failed: ${detail}`);
+        }
+    }
     async buildHelloMetadata() {
         const metadata = {
             ...(this.config.metadata || {}),
@@ -164,6 +178,21 @@ export class BridgeRuntime {
         });
         metadata.local_tools_version = toolCatalog.version;
         metadata.local_tools = toolCatalog.tools;
+        const attachedWorkspaces = await loadAttachedWorkspacesForHello({
+            apiBaseUrl: this.config.apiBaseUrl,
+            deviceToken: this.config.deviceToken,
+            fallbackMetadata: this.config.metadata || {},
+        }).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.logWarn(`[otto-bridge] attached workspace probe failed: ${detail}`);
+            return [];
+        });
+        if (attachedWorkspaces.length > 0) {
+            metadata.attached_workspaces = attachedWorkspaces;
+        }
+        else {
+            delete metadata.attached_workspaces;
+        }
         return metadata;
     }
     async sendHello(socket) {
@@ -367,6 +396,9 @@ export class BridgeRuntime {
             case "device.job.cancel":
                 await this.cancelJob(String(message.job_id || ""), String(message.step_id || ""));
                 return;
+            case "device.metadata.refresh":
+                await this.refreshHelloMetadata(socket, String(message.reason || "remote_request"));
+                return;
             default:
                 this.logInfo(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
         }

package/dist/tool_catalog.js

@@ -65,6 +65,14 @@ const NATIVE_MACOS_BASE_TOOLS = [
         mode: "observe",
         action_types: ["read_file"],
     },
+    {
+        id: "filesystem.open_path",
+        title: "Abrir arquivo ou pasta local",
+        description: "Abre um caminho local no app padrao do macOS para inspecao rapida.",
+        category: "filesystem",
+        mode: "control",
+        action_types: ["open_path"],
+    },
     {
         id: "filesystem.write_text",
         title: "Escrita de arquivo de texto",

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "1.0.12";
+export const BRIDGE_VERSION = "1.1.0";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;
@@ -10,4 +10,4 @@ export const DEFAULT_RECONNECT_MAX_DELAY_MS = 15000;
 export const DEFAULT_EXECUTOR_TYPE = "mock";
 export const DEFAULT_CLAWD_CURSOR_BASE_URL = "http://127.0.0.1:3847";
 export const DEFAULT_CLAWD_CURSOR_POLL_INTERVAL_MS = 1500;
-export const BRIDGE_LOCAL_TOOLS_VERSION = 7;
+export const BRIDGE_LOCAL_TOOLS_VERSION = 8;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "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.0.12");
+console.log("\n[otto-bridge] Welcome to OTTOAI 1.1.0");
 console.log("[otto-bridge] Vamos iniciar o setup interativo do bridge.\n");
 
 const result = spawnSync(process.execPath, [mainPath, "setup", "--postinstall"], {