@leg3ndy/otto-bridge 1.1.5 → 1.1.8

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 o patch atual `1.1.5`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_5_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_5_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).
+Para o patch atual `1.1.8`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_8_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_8_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.5.tgz
+npm install -g ./leg3ndy-otto-bridge-1.1.8.tgz
 ```
 
-Na linha `1.1.5`, `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.8`, `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.5` 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.8` 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.5` 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 corrige o `Otto Console` para voltar ao scrollback real, aceitar digitação enquanto o Otto streama e reaproveitar a tela do hub sem duplicar o banner.
+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.8` 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 endurece o `Otto Console`, evita que `otto-bridge update` dispare setup interativo no meio da autoatualizacao e faz o scroll por wheel/trackpad funcionar no Terminal.app sem reativar click tracking.
 
 ## Publicacao
 
@@ -154,7 +154,7 @@ Dentro do console, use:
 - `/workspace clear` para limpar o binding atual do chat/sessão
 - `/new` para iniciar uma nova sessão e limpar o contexto local do console
 
-No TTY, o console agora reaproveita a própria tela do bridge quando você entra no `Otto Console`, em vez de abrir uma segunda viewport logo abaixo do hub. O header é impresso uma vez no topo da sessão, o histórico completo fica salvo no scrollback real do terminal e o conteúdo vai empurrando os blocos para cima naturalmente. O composer continua com placeholder `Peça algo ao Otto`, o footer mantém modelo/tokens/aprovação, e ao digitar `/` o bridge abre uma palette navegável por setas, com `Enter` preenchendo comandos como `/new` para iniciar uma nova sessão local.
+No TTY, o console agora entra em `alternate screen` ao abrir o `Otto Console`, para esconder o scrollbar manual/nativo do terminal e deixar só a viewport interna do Otto. O header é impresso uma vez no topo da sessão, o transcript continua completo dentro da tela do console e o composer fica preso no rodapé com placeholder `Peça algo ao Otto`. Ao digitar `/`, o bridge abre uma palette navegável por setas, com `Enter` preenchendo comandos como `/new` para iniciar uma nova sessão local. Wheel/trackpad usam `alternate scroll` do terminal para navegar o transcript como setas; `PageUp/PageDown` continuam funcionando e cliques deixam de ser reportados como input 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.
 
@@ -170,7 +170,7 @@ Esse comando abre um shell local interativo para instalar extensoes, rodar coman
 
 ### WhatsApp Web em background
 
-Fluxo recomendado na linha `1.1.5`:
+Fluxo recomendado na linha `1.1.8`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -180,13 +180,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.5`:
+Contrato da linha `1.1.8`:
 
 - `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.5
+## Handoff rapido da linha 1.1.8
 
 Ja fechado no codigo:
 

package/dist/agentic_runtime/workspace/manager.js

@@ -56,6 +56,17 @@ const DEFAULT_KEY_FILE_PATTERNS = [
 ];
 const WORKSPACE_INDEX_EXTENSION_LIMIT = 8;
 const WORKSPACE_INDEX_TOP_LEVEL_LIMIT = 16;
+const WORKSPACE_INDEX_TOP_LEVEL_FILE_LIMIT = 12;
+const WORKSPACE_INDEX_DIRECTORY_SAMPLE_LIMIT = 6;
+const WORKSPACE_INDEX_DIRECTORY_KEY_FILE_LIMIT = 6;
+const WORKSPACE_INDEX_DIRECTORY_EXTENSION_LIMIT = 4;
+const WORKSPACE_INDEX_FOCUS_DIRECTORY_LIMIT = 6;
+const WORKSPACE_INDEX_ENTRYPOINT_LIMIT = 12;
+const WORKSPACE_INDEX_STACK_HINT_LIMIT = 8;
+const WORKSPACE_INDEX_SUGGESTED_READ_LIMIT = 10;
+const WORKSPACE_INDEX_SYMBOL_OUTLINE_LIMIT = 8;
+const WORKSPACE_INDEX_SYMBOL_LIMIT = 8;
+const WORKSPACE_INDEX_SYMBOL_FILE_SIZE_LIMIT = 64_000;
 const LOCKFILE_PACKAGE_MANAGER_MAP = {
     "package-lock.json": "npm",
     "pnpm-lock.yaml": "pnpm",
@@ -66,6 +77,67 @@ const LOCKFILE_PACKAGE_MANAGER_MAP = {
     "Cargo.lock": "cargo",
     "go.sum": "go",
 };
+const WORKSPACE_INDEX_DIRECTORY_ROLE_HINTS = {
+    api: ["api", "backend"],
+    app: ["app"],
+    apps: ["app", "monorepo"],
+    backend: ["backend"],
+    components: ["ui"],
+    config: ["config"],
+    docs: ["docs"],
+    frontend: ["frontend"],
+    lib: ["library"],
+    libs: ["library"],
+    packages: ["monorepo"],
+    pages: ["routing", "frontend"],
+    routes: ["routing"],
+    scripts: ["automation"],
+    server: ["backend"],
+    services: ["services"],
+    src: ["source"],
+    test: ["tests"],
+    tests: ["tests"],
+    "__tests__": ["tests"],
+    web: ["frontend"],
+};
+const WORKSPACE_INDEX_ENTRYPOINT_FILENAMES = [
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "README.md",
+    "AGENTS.md",
+    "tsconfig.json",
+    "vite.config.ts",
+    "vite.config.js",
+    "next.config.js",
+    "next.config.mjs",
+    "src/index.ts",
+    "src/index.tsx",
+    "src/main.ts",
+    "src/main.tsx",
+    "src/App.tsx",
+    "app/page.tsx",
+    "app/layout.tsx",
+    "server.ts",
+    "main.go",
+    "main.rs",
+];
+const WORKSPACE_INDEX_CODE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".cs",
+]);
 const WORKSPACE_OBSERVE_ONLY_ACTIONS = new Set([
     "filesystem_inspect",
     "list_files",
@@ -111,6 +183,7 @@ const WORKSPACE_POLICY_ALLOWED_ACTIONS = {
     release_operator: new Set([...WORKSPACE_POLICY_ALL_ACTIONS]),
 };
 const WORKSPACE_POLICY_CONFIRM_ACTIONS = new Set([
+    "run_shell",
     "git_clone",
     "git_fetch",
     "git_checkout",
@@ -151,6 +224,356 @@ function uniqueRuntimeStrings(values, limit) {
         .filter(Boolean);
     return Array.from(new Set(normalized)).slice(0, limit);
 }
+function topLevelSegment(relativePath) {
+    const normalized = asString(relativePath).replace(/^[./]+/, "");
+    if (!normalized || normalized === ".") {
+        return "";
+    }
+    return normalized.split(/[\\/]/, 1)[0] || normalized;
+}
+function extensionStatsFromMap(extensionCounts, limit = WORKSPACE_INDEX_EXTENSION_LIMIT) {
+    return Array.from(extensionCounts.entries())
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, limit)
+        .map(([extension, count]) => ({ extension, count }));
+}
+function roleTagsForDirectory(pathValue, sampleEntries) {
+    const name = topLevelSegment(pathValue).toLowerCase();
+    const tags = new Set(WORKSPACE_INDEX_DIRECTORY_ROLE_HINTS[name] || []);
+    const normalizedSamples = sampleEntries.map((item) => item.toLowerCase());
+    if (normalizedSamples.some((item) => item.endsWith(".tsx"))) {
+        tags.add("react");
+    }
+    if (normalizedSamples.some((item) => item.endsWith(".ts"))) {
+        tags.add("typescript");
+    }
+    if (normalizedSamples.some((item) => item.endsWith(".py"))) {
+        tags.add("python");
+    }
+    if (normalizedSamples.some((item) => item.includes("route") || item.includes("page"))) {
+        tags.add("routing");
+    }
+    return Array.from(tags).sort((left, right) => left.localeCompare(right));
+}
+function workspaceStackHints(options) {
+    const hints = new Set();
+    const keyFiles = new Set(options.keyFiles.map((item) => item.toLowerCase()));
+    const extensions = new Set(options.dominantExtensions.map((item) => item.extension.toLowerCase()));
+    const focusNames = new Set(options.focusDirectories.map((item) => topLevelSegment(item.path).toLowerCase()));
+    const focusTags = new Set(options.focusDirectories.flatMap((item) => item.role_tags));
+    if (keyFiles.has("package.json")) {
+        hints.add("node");
+    }
+    if (keyFiles.has("pnpm-lock.yaml")) {
+        hints.add("pnpm");
+    }
+    if (keyFiles.has("package-lock.json")) {
+        hints.add("npm");
+    }
+    if (keyFiles.has("yarn.lock")) {
+        hints.add("yarn");
+    }
+    if (keyFiles.has("pyproject.toml") || keyFiles.has("requirements.txt") || keyFiles.has("poetry.lock")) {
+        hints.add("python");
+    }
+    if (keyFiles.has("cargo.toml")) {
+        hints.add("rust");
+    }
+    if (keyFiles.has("go.mod")) {
+        hints.add("go");
+    }
+    if (keyFiles.has("tsconfig.json") || extensions.has(".ts") || extensions.has(".tsx")) {
+        hints.add("typescript");
+    }
+    if (extensions.has(".js") || extensions.has(".jsx") || keyFiles.has("package.json")) {
+        hints.add("javascript");
+    }
+    if (extensions.has(".tsx") || focusNames.has("components") || focusTags.has("ui")) {
+        hints.add("react");
+    }
+    if (keyFiles.has("next.config.js") || keyFiles.has("next.config.mjs") || focusNames.has("app") || focusNames.has("pages")) {
+        hints.add("nextjs");
+    }
+    if (focusNames.has("server") || focusNames.has("api") || focusNames.has("backend")) {
+        hints.add("backend");
+    }
+    if (focusNames.has("frontend") || focusNames.has("web") || focusNames.has("components")) {
+        hints.add("frontend");
+    }
+    if (focusNames.has("tests") || focusNames.has("test") || focusNames.has("__tests__")) {
+        hints.add("tests");
+    }
+    return Array.from(hints).slice(0, WORKSPACE_INDEX_STACK_HINT_LIMIT);
+}
+function workspaceEntrypointPaths(options) {
+    const candidates = uniqueStrings([
+        ...WORKSPACE_INDEX_ENTRYPOINT_FILENAMES.filter((item) => options.keyFiles.includes(item) || options.topLevelFiles.includes(item)),
+        ...options.keyFiles,
+        ...options.topLevelFiles,
+        ...options.focusDirectories.flatMap((item) => (item.sample_entries || [])
+            .filter((entry) => /\.(ts|tsx|js|jsx|py|go|rs)$/i.test(entry) || /(?:^|\/)(index|main|app|server)\./i.test(entry))),
+    ]);
+    candidates.sort((left, right) => {
+        const leftIndex = WORKSPACE_INDEX_ENTRYPOINT_FILENAMES.indexOf(left);
+        const rightIndex = WORKSPACE_INDEX_ENTRYPOINT_FILENAMES.indexOf(right);
+        const leftScore = leftIndex >= 0 ? leftIndex : WORKSPACE_INDEX_ENTRYPOINT_FILENAMES.length + left.length;
+        const rightScore = rightIndex >= 0 ? rightIndex : WORKSPACE_INDEX_ENTRYPOINT_FILENAMES.length + right.length;
+        return leftScore - rightScore || left.localeCompare(right);
+    });
+    return candidates.slice(0, WORKSPACE_INDEX_ENTRYPOINT_LIMIT);
+}
+function workspaceSuggestedReadPaths(options) {
+    return uniqueStrings([
+        ...options.entrypointPaths,
+        ...options.keyFiles,
+        ...options.focusDirectories.flatMap((item) => item.sample_entries || []),
+    ]).slice(0, WORKSPACE_INDEX_SUGGESTED_READ_LIMIT);
+}
+function outlineLanguageForPath(relativePath) {
+    const extension = path.extname(relativePath).toLowerCase();
+    switch (extension) {
+        case ".tsx":
+            return "tsx";
+        case ".ts":
+            return "typescript";
+        case ".jsx":
+            return "jsx";
+        case ".js":
+        case ".mjs":
+        case ".cjs":
+            return "javascript";
+        case ".py":
+            return "python";
+        case ".go":
+            return "go";
+        case ".rs":
+            return "rust";
+        case ".java":
+            return "java";
+        case ".kt":
+            return "kotlin";
+        case ".cs":
+            return "csharp";
+        default:
+            return extension.replace(/^\./, "") || "text";
+    }
+}
+function canBuildSymbolOutline(relativePath) {
+    return WORKSPACE_INDEX_CODE_EXTENSIONS.has(path.extname(relativePath).toLowerCase());
+}
+function extractNamedList(value) {
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .map((item) => item.split(/\s+as\s+/i)[0]?.trim() || "")
+        .filter(Boolean);
+}
+function extractJavascriptLikeSymbols(content) {
+    const topLevel = new Set();
+    const exported = new Set();
+    const frameworkHints = new Set();
+    const topLevelPatterns = [
+        /^\s*(?:export\s+default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*export\s+(?:type|interface|enum)\s+([A-Za-z_$][\w$]*)/gm,
+    ];
+    for (const pattern of topLevelPatterns) {
+        for (const match of content.matchAll(pattern)) {
+            const symbol = asString(match[1]);
+            if (symbol) {
+                topLevel.add(symbol);
+            }
+        }
+    }
+    const exportPatterns = [
+        /^\s*export\s+(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*export\s+class\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*export\s+(?:type|interface|enum)\s+([A-Za-z_$][\w$]*)/gm,
+        /^\s*export\s*{\s*([^}]+)\s*}/gm,
+    ];
+    for (const pattern of exportPatterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[0]?.includes("{")) {
+                for (const symbol of extractNamedList(match[1] || "")) {
+                    exported.add(symbol);
+                    topLevel.add(symbol);
+                }
+                continue;
+            }
+            const symbol = asString(match[1]);
+            if (symbol) {
+                exported.add(symbol);
+                topLevel.add(symbol);
+            }
+        }
+    }
+    if (/from\s+["']react["']|React\./.test(content)) {
+        frameworkHints.add("react");
+    }
+    if (/from\s+["']next\/|next\/(app|server|navigation|router)/.test(content)) {
+        frameworkHints.add("nextjs");
+    }
+    if (/from\s+["']express["']|express\(/.test(content)) {
+        frameworkHints.add("express");
+    }
+    if (/from\s+["']fastify["']|fastify\(/.test(content)) {
+        frameworkHints.add("fastify");
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(exported).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: Array.from(frameworkHints).slice(0, 4),
+    };
+}
+function extractPythonSymbols(content) {
+    const topLevel = new Set();
+    const frameworkHints = new Set();
+    for (const match of content.matchAll(/^(?:async\s+)?def\s+([A-Za-z_][\w]*)\s*\(|^class\s+([A-Za-z_][\w]*)\s*[\(:]/gm)) {
+        const symbol = asString(match[1] || match[2]);
+        if (symbol) {
+            topLevel.add(symbol);
+        }
+    }
+    if (/from\s+fastapi\s+import|FastAPI\(/.test(content)) {
+        frameworkHints.add("fastapi");
+    }
+    if (/from\s+flask\s+import|Flask\(/.test(content)) {
+        frameworkHints.add("flask");
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(topLevel).filter((item) => !item.startsWith("_")).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: Array.from(frameworkHints).slice(0, 4),
+    };
+}
+function extractGoSymbols(content) {
+    const topLevel = new Set();
+    for (const match of content.matchAll(/^(?:func|type)\s+([A-Za-z_][\w]*)/gm)) {
+        const symbol = asString(match[1]);
+        if (symbol) {
+            topLevel.add(symbol);
+        }
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(topLevel).filter((item) => /^[A-Z]/.test(item)).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: [],
+    };
+}
+function extractRustSymbols(content) {
+    const topLevel = new Set();
+    const exported = new Set();
+    for (const match of content.matchAll(/^(?:pub\s+)?(?:fn|struct|enum|trait)\s+([A-Za-z_][\w]*)/gm)) {
+        const symbol = asString(match[1]);
+        if (symbol) {
+            topLevel.add(symbol);
+            if (match[0]?.startsWith("pub ")) {
+                exported.add(symbol);
+            }
+        }
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(exported).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: [],
+    };
+}
+function extractJvmLikeSymbols(content) {
+    const topLevel = new Set();
+    for (const match of content.matchAll(/^(?:public\s+|private\s+|protected\s+|internal\s+)?(?:class|interface|enum|object)\s+([A-Za-z_][\w]*)/gm)) {
+        const symbol = asString(match[1]);
+        if (symbol) {
+            topLevel.add(symbol);
+        }
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: [],
+    };
+}
+function extractCSharpSymbols(content) {
+    const topLevel = new Set();
+    const exported = new Set();
+    for (const match of content.matchAll(/^(?:public\s+|internal\s+|private\s+|protected\s+)?(?:class|interface|enum|record)\s+([A-Za-z_][\w]*)/gm)) {
+        const symbol = asString(match[1]);
+        if (symbol) {
+            topLevel.add(symbol);
+            if (match[0]?.startsWith("public ") || match[0]?.startsWith("internal ")) {
+                exported.add(symbol);
+            }
+        }
+    }
+    return {
+        top_level_symbols: Array.from(topLevel).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        exported_symbols: Array.from(exported).slice(0, WORKSPACE_INDEX_SYMBOL_LIMIT),
+        framework_hints: [],
+    };
+}
+function buildSymbolOutline(relativePath, content) {
+    const extension = path.extname(relativePath).toLowerCase();
+    let extracted = null;
+    if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(extension)) {
+        extracted = extractJavascriptLikeSymbols(content);
+    }
+    else if (extension === ".py") {
+        extracted = extractPythonSymbols(content);
+    }
+    else if (extension === ".go") {
+        extracted = extractGoSymbols(content);
+    }
+    else if (extension === ".rs") {
+        extracted = extractRustSymbols(content);
+    }
+    else if (extension === ".java" || extension === ".kt") {
+        extracted = extractJvmLikeSymbols(content);
+    }
+    else if (extension === ".cs") {
+        extracted = extractCSharpSymbols(content);
+    }
+    if (!extracted) {
+        return null;
+    }
+    if (extracted.top_level_symbols.length === 0 && extracted.exported_symbols.length === 0 && extracted.framework_hints.length === 0) {
+        return null;
+    }
+    return {
+        path: relativePath,
+        language: outlineLanguageForPath(relativePath),
+        top_level_symbols: extracted.top_level_symbols,
+        exported_symbols: extracted.exported_symbols,
+        framework_hints: extracted.framework_hints,
+    };
+}
+async function buildWorkspaceSymbolOutlines(basePath, candidatePaths) {
+    const outlines = [];
+    for (const relativePath of candidatePaths) {
+        if (outlines.length >= WORKSPACE_INDEX_SYMBOL_OUTLINE_LIMIT) {
+            break;
+        }
+        if (!canBuildSymbolOutline(relativePath)) {
+            continue;
+        }
+        const absolutePath = path.join(basePath, relativePath);
+        try {
+            const fileStats = await stat(absolutePath);
+            if (!fileStats.isFile() || fileStats.size > WORKSPACE_INDEX_SYMBOL_FILE_SIZE_LIMIT) {
+                continue;
+            }
+            const content = await readFile(absolutePath, "utf8");
+            const outline = buildSymbolOutline(relativePath, content);
+            if (outline) {
+                outlines.push(outline);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return outlines;
+}
 function normalizeWorkspaceMemory(value, workspaceId) {
     if (!value) {
         return undefined;
@@ -661,8 +1084,10 @@ export async function buildWorkspaceIndex(options) {
     ]));
     const queue = [{ directoryPath: basePath, depth: 0 }];
     const topLevelEntries = [];
+    const topLevelFiles = [];
     const keyFiles = new Set();
     const extensionCounts = new Map();
+    const directorySummaryByPath = new Map();
     let scannedDirectoryCount = 0;
     let scannedFileCount = 0;
     let truncated = false;
@@ -684,6 +1109,10 @@ export async function buildWorkspaceIndex(options) {
             continue;
         }
         entries.sort((left, right) => left.name.localeCompare(right.name));
+        const currentRelativePath = toRelativePath(basePath, next.directoryPath);
+        const currentDirectorySummary = next.depth === 1
+            ? directorySummaryByPath.get(currentRelativePath)
+            : undefined;
         for (const entry of entries) {
             const candidatePath = path.join(next.directoryPath, entry.name);
             const relativePath = toRelativePath(basePath, candidatePath);
@@ -697,6 +1126,24 @@ export async function buildWorkspaceIndex(options) {
                 if (ignoredDirectoryNames.has(entry.name)) {
                     continue;
                 }
+                if (next.depth === 0) {
+                    directorySummaryByPath.set(relativePath, {
+                        path: relativePath,
+                        child_file_count: 0,
+                        child_directory_count: 0,
+                        key_files: [],
+                        dominant_extensions: [],
+                        sample_entries: [],
+                        role_tags: [],
+                        extensionCounts: new Map(),
+                    });
+                }
+                if (currentDirectorySummary) {
+                    currentDirectorySummary.child_directory_count += 1;
+                    if (currentDirectorySummary.sample_entries.length < WORKSPACE_INDEX_DIRECTORY_SAMPLE_LIMIT) {
+                        currentDirectorySummary.sample_entries.push(relativePath);
+                    }
+                }
                 if (next.depth + 1 <= maxDepth) {
                     queue.push({
                         directoryPath: candidatePath,
@@ -712,21 +1159,79 @@ export async function buildWorkspaceIndex(options) {
                 continue;
             }
             scannedFileCount += 1;
+            if (next.depth === 0 && topLevelFiles.length < WORKSPACE_INDEX_TOP_LEVEL_FILE_LIMIT) {
+                topLevelFiles.push(relativePath);
+            }
             if (keyFilePatterns.has(entry.name)) {
                 keyFiles.add(relativePath);
+                if (currentDirectorySummary && currentDirectorySummary.key_files.length < WORKSPACE_INDEX_DIRECTORY_KEY_FILE_LIMIT) {
+                    currentDirectorySummary.key_files.push(relativePath);
+                }
             }
             const extension = path.extname(entry.name).toLowerCase() || "[no_ext]";
             extensionCounts.set(extension, (extensionCounts.get(extension) || 0) + 1);
+            if (currentDirectorySummary) {
+                currentDirectorySummary.child_file_count += 1;
+                currentDirectorySummary.extensionCounts.set(extension, (currentDirectorySummary.extensionCounts.get(extension) || 0) + 1);
+                if (currentDirectorySummary.sample_entries.length < WORKSPACE_INDEX_DIRECTORY_SAMPLE_LIMIT) {
+                    currentDirectorySummary.sample_entries.push(relativePath);
+                }
+            }
             if (scannedFileCount >= maxFiles) {
                 truncated = true;
                 break;
             }
         }
     }
-    const dominantExtensions = Array.from(extensionCounts.entries())
-        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
-        .slice(0, WORKSPACE_INDEX_EXTENSION_LIMIT)
-        .map(([extension, count]) => ({ extension, count }));
+    const dominantExtensions = extensionStatsFromMap(extensionCounts, WORKSPACE_INDEX_EXTENSION_LIMIT);
+    const directorySummaries = Array.from(directorySummaryByPath.values())
+        .map((item) => {
+        const sampleEntries = uniqueStrings(item.sample_entries).slice(0, WORKSPACE_INDEX_DIRECTORY_SAMPLE_LIMIT);
+        return {
+            path: item.path,
+            child_file_count: item.child_file_count,
+            child_directory_count: item.child_directory_count,
+            key_files: uniqueStrings(item.key_files).slice(0, WORKSPACE_INDEX_DIRECTORY_KEY_FILE_LIMIT),
+            dominant_extensions: extensionStatsFromMap(item.extensionCounts, WORKSPACE_INDEX_DIRECTORY_EXTENSION_LIMIT),
+            sample_entries: sampleEntries,
+            role_tags: roleTagsForDirectory(item.path, sampleEntries),
+        };
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const focusDirectories = [...directorySummaries]
+        .sort((left, right) => {
+        const leftScore = (left.role_tags.length * 10) + left.child_file_count + left.child_directory_count + (left.key_files.length * 2);
+        const rightScore = (right.role_tags.length * 10) + right.child_file_count + right.child_directory_count + (right.key_files.length * 2);
+        return rightScore - leftScore || left.path.localeCompare(right.path);
+    })
+        .filter((item) => item.child_file_count > 0 || item.child_directory_count > 0 || item.role_tags.length > 0)
+        .slice(0, WORKSPACE_INDEX_FOCUS_DIRECTORY_LIMIT);
+    const normalizedKeyFiles = Array.from(keyFiles).sort((left, right) => left.localeCompare(right));
+    const stackHints = workspaceStackHints({
+        keyFiles: normalizedKeyFiles,
+        dominantExtensions,
+        focusDirectories,
+    });
+    const entrypointPaths = workspaceEntrypointPaths({
+        keyFiles: normalizedKeyFiles,
+        topLevelFiles,
+        focusDirectories,
+    });
+    const suggestedReadPaths = workspaceSuggestedReadPaths({
+        keyFiles: normalizedKeyFiles,
+        entrypointPaths,
+        focusDirectories,
+    });
+    const symbolOutlines = await buildWorkspaceSymbolOutlines(basePath, suggestedReadPaths);
+    const focusSummary = focusDirectories.length > 0
+        ? ` Areas foco: ${focusDirectories.map((item) => item.path).join(", ")}.`
+        : "";
+    const stackSummary = stackHints.length > 0
+        ? ` Stack sugerida: ${stackHints.join(", ")}.`
+        : "";
+    const outlineSummary = symbolOutlines.length > 0
+        ? ` Outline inicial: ${symbolOutlines.map((item) => item.path).join(", ")}.`
+        : "";
     return {
         resolver,
         workspace_id: options.workspaceId,
@@ -735,9 +1240,16 @@ export async function buildWorkspaceIndex(options) {
         scanned_file_count: scannedFileCount,
         truncated,
         top_level_entries: topLevelEntries,
-        key_files: Array.from(keyFiles).sort((left, right) => left.localeCompare(right)),
+        top_level_files: topLevelFiles,
+        key_files: normalizedKeyFiles,
         dominant_extensions: dominantExtensions,
-        summary: `Indexei ${scannedFileCount} arquivo${scannedFileCount === 1 ? "" : "s"} e ${scannedDirectoryCount} diretorio${scannedDirectoryCount === 1 ? "" : "s"} em ${path.basename(basePath) || basePath}.`,
+        directory_summaries: directorySummaries,
+        focus_directories: focusDirectories,
+        stack_hints: stackHints,
+        entrypoint_paths: entrypointPaths,
+        suggested_read_paths: suggestedReadPaths,
+        symbol_outlines: symbolOutlines,
+        summary: `Indexei ${scannedFileCount} arquivo${scannedFileCount === 1 ? "" : "s"} e ${scannedDirectoryCount} diretorio${scannedDirectoryCount === 1 ? "" : "s"} em ${path.basename(basePath) || basePath}.${stackSummary}${focusSummary}${outlineSummary}`.trim(),
     };
 }
 export async function buildRepoManifest(options) {