@asm-agent/coding-agent 0.9.3 → 0.9.4

package/bundled-extensions/OLLAMA-TOOL-FORCING.md

@@ -0,0 +1,155 @@
+# Ollama Tool-Forcing Extension
+
+Esta extensão resolve um problema comum ao usar modelos abertos menores (Qwen 27b, Llama, etc) rodando via Ollama com o ASM Agent.
+
+## Problema
+
+Quando você roda um modelo menor localmente via Ollama, o seguinte comportamento pode ocorrer:
+
+1. O modelo começa a **gerar seu raciocínio** (thinking/internal reasoning)
+2. **Após pensar**, o modelo **não chama nenhuma ferramenta**
+3. O modelo **não gera nenhum texto final** para o usuário
+4. O modelo simplesmente **emite um "token de parada"** e encerra
+5. O ASM Agent fica **parado esperando você falar**
+
+Isso não é um "bug" — é um comportamento comum de modelos menores quando não há instrução explícita.
+
+## Solução
+
+Esta extensão **injeta automaticamente** uma instrução forte no system prompt que:
+
+- ✅ **Força o modelo a chamar ferramentas** antes de parar
+- ✅ **Proíbe gerações vazias** (só thinking sem ação)
+- ✅ **Mantém o loop autônomo** funcionando continuamente
+- ✅ **Funciona automaticamente** — sem precisar de comandos especiais
+
+## Como Usar
+
+### 1. Ativar a Extensão
+
+A extensão já foi colocada em:
+```
+~/.asm-agent/extensions/ollama-tool-forcing.ts
+```
+
+Ela é **auto-descoberta** — não precisa fazer nada especial. Será carregada automaticamente na próxima vez que você iniciar o ASM Agent.
+
+### 2. Recarregar em Tempo Real
+
+Se o ASM Agent já está rodando, use o comando:
+```
+/reload
+```
+
+Isso recarrega todas as extensões sem precisar reiniciar.
+
+### 3. Verificar Status
+
+Use o comando:
+```
+/ollama-tools-info
+```
+
+Ele mostra se a extensão está ativa (✅) e permite fazer toggle (ligar/desligar).
+
+## O Que a Extensão Faz
+
+Quando você envia uma tarefa, a extensão adiciona isto ao final do system prompt:
+
+```
+## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+Você está rodando num modelo aberto (Ollama/local). Para garantir que trabalhe autonomamente:
+
+1. **NUNCA pare sem chamar uma ferramenta**: Depois de pensar/raciocinar, você DEVE chamar
+   uma ferramenta (bash, edit, ipython, etc) para continuar o trabalho.
+
+2. **Sem gerações vazias**: Não é permitido apenas gerar um "thinking" e depois parar.
+
+3. **Ferramentas = Continuidade**: Use-as para:
+   - Verificar status (bash, ipython)
+   - Fazer alterações (edit, bash)
+   - Validar resultados (bash com testes)
+   - Avançar a tarefa passo a passo
+
+4. **Padrão de turno correto**:
+   a) Receber tarefa e pensar (thinking)
+   b) Chamar uma ferramenta para agir
+   c) Observar resultado
+   d) Voltar ao passo (a) se precisar avançar
+
+5. **Proibido**: Terminar turno com apenas uma seção vazia de thinking.
+```
+
+## Quando Usar
+
+- ✅ Rodando **Qwen 27b/32b** via Ollama
+- ✅ Rodando **Llama** via Ollama
+- ✅ Rodando qualquer **modelo aberto local**
+- ✅ Modelo que às vezes **congela ou gera vazio**
+
+## Quando Pode Desativar
+
+- Se rodando **Claude/GPT** (APIs online)
+- Se o modelo está **funcionando bem** sem a regra
+- Quando quer testar comportamento natural
+
+Use `/ollama-tools-info` para toggle sem reiniciar.
+
+## Dicas Adicionais
+
+### Para melhor desempenho com Qwen:
+
+```bash
+# Use a versão Coder (superior para tool-calling)
+ollama pull qwen2.5-coder:32b
+
+# Rode com mais contexto
+ollama run qwen2.5-coder:32b
+```
+
+### Atualize o Ollama:
+
+Versões antigas do Ollama podem engolir chamadas de ferramenta do Qwen. Mantenha atualizado:
+
+```bash
+ollama --version
+# Se antigo, atualize
+```
+
+### Use a extensão + instruções diretas:
+
+Se o modelo ainda ficar preso, você pode também dar um empurrãozinho manualmente:
+
+```
+"Como está o andamento? Use a ferramenta de bash para verificar e continue o trabalho imediatamente."
+```
+
+## Removendo a Extensão
+
+Se quiser remover a regra permanentemente:
+
+```bash
+rm ~/.asm-agent/extensions/ollama-tool-forcing.ts
+/reload
+```
+
+## Arquivos Relacionados
+
+- **Extensão**: `~/.asm-agent/extensions/ollama-tool-forcing.ts`
+- **Documentação**: Este arquivo
+- **Comando**: `/ollama-tools-info` (dentro do ASM Agent)
+- **Reload**: `/reload` (para recarregar extensões)
+
+## Suporte
+
+Se a extensão não funcionar:
+
+1. Verifique se o arquivo está em `~/.asm-agent/extensions/`
+2. Use `/reload` para recarregar
+3. Use `/ollama-tools-info` para verificar status
+4. Verifique logs do ASM Agent para erros de compilação TypeScript
+
+---
+
+**Criado para resolver o problema de modelos abertos gerando vazios com ASM Agent.**

package/bundled-extensions/README.txt

@@ -0,0 +1,178 @@
+
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                    🎉 CUSTOM RULE CRIADA E PRONTA!                            ║
+║                  Ollama Tool-Forcing Extension v1.0                            ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+
+📂 LOCALIZAÇÃO:
+   ~/.asm-agent/extensions/
+
+📦 ARQUIVOS CRIADOS (5 arquivos, ~18 KB total):
+
+   1. ollama-tool-forcing.ts (3.2 KB)
+      → Extensão principal (TypeScript)
+      → Auto-descoberta pelo ASM Agent
+      → Sem dependências externas
+
+   2. OLLAMA-TOOL-FORCING.md (4.4 KB)
+      → Manual completo
+      → Explicação detalhada do problema
+      → Quando usar/não usar
+      → Dicas de otimização
+
+   3. OLLAMA-TOOL-FORCING-QUICK-START.txt (5.8 KB)
+      → Referência rápida visual
+      → Instruções em poucas linhas
+      → Próximos passos
+
+   4. OLLAMA-TOOL-FORCING-TESTS.md (4.5 KB)
+      → 5 exemplos de teste
+      → Como verificar se funciona
+      → Troubleshooting
+
+   5. OLLAMA-TOOL-FORCING-IMPLEMENTATION.md (6.5 KB)
+      → Guia de implementação
+      → Como funciona internamente
+      → Personalização avançada
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✨ O QUE ESSA CUSTOM RULE FAZ:
+
+┌─ PROBLEMA ORIGINAL ────────────────────────────────────────────────────────┐
+│                                                                              │
+│  Você roda Qwen/Llama via Ollama com ASM Agent:                             │
+│  ❌ Modelo pensa um pouco                                                   │
+│  ❌ Modelo para (emit stop token)                                           │
+│  ❌ Modelo não chama ferramenta                                             │
+│  ❌ ASM Agent fica esperando "e aí?"                                        │
+│  ❌ Loop autônomo quebrado                                                  │
+│                                                                              │
+└────────────────────────────────────────────────────────────────────────────┘
+
+                                    ↓ SOLUÇÃO ↓
+
+┌─ COM A EXTENSÃO ──────────────────────────────────────────────────────────┐
+│                                                                             │
+│  ✅ Extensão intercepta requisição (before_agent_start)                   │
+│  ✅ Injeta regra CRÍTICA no system prompt                                 │
+│  ✅ Modelo recebe instrução forte: "NUNCA PARE SEM CHAMAR FERRAMENTA"     │
+│  ✅ Modelo é forçado a chamar bash/edit/ipython                          │
+│  ✅ Loop autônomo continua funcionando                                    │
+│  ✅ Tarefa completada sem intervenção                                     │
+│                                                                             │
+└────────────────────────────────────────────────────────────────────────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🚀 USAR AGORA (3 PASSOS):
+
+1️⃣  NADA! A extensão já está em ~/.asm-agent/extensions/
+
+2️⃣  Próxima vez que iniciar ASM Agent:
+    - Extensão será auto-descoberta
+    - Regra será injetada automaticamente
+    - Funcionará em TODAS as requisições
+
+3️⃣  Se ASM Agent já está rodando:
+    /reload        (recarrega extensões)
+    /ollama-tools-info  (verifica status)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 REGRA INJETADA NO SYSTEM PROMPT:
+
+    ## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+    1. NUNCA pare sem chamar uma ferramenta
+    2. Sem gerações vazias (só thinking não é permitido)
+    3. Ferramentas = continuidade (use bash, edit, ipython constantemente)
+    4. Padrão correto: pensar → agir → observar → repetir
+    5. Proibido: terminar turno sem chamar ferramenta
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💻 TESTE AGORA:
+
+Cole isso no ASM Agent com seu Qwen/Llama rodando:
+
+    "Crie um arquivo 'test.txt' com conteúdo 'Olá Ollama!' e use bash 
+    para verificar que foi criado corretamente."
+
+Resultado esperado:
+    ✅ Modelo chama edit (criar arquivo)
+    ✅ Modelo chama bash (verificar)
+    ✅ Tarefa completa, sem ele ficar preso
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 DOCUMENTAÇÃO:
+
+Arquivo               │ Objetivo                        │ Leia quando...
+──────────────────────┼─────────────────────────────────┼──────────────────
+OLLAMA-TOOL-FORCING.md │ Manual completo                 │ Quer detalhes
+QUICK-START.txt       │ Referência rápida               │ Quer começar logo
+TESTS.md              │ 5 exemplos de teste             │ Quer testar agora
+IMPLEMENTATION.md     │ Como funciona internamente      │ Quer customizar
+
+Todos em ~/.asm-agent/extensions/
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚙️  PERSONALIZAÇÃO:
+
+Quer mudar o comportamento?
+
+    Edite: ~/.asm-agent/extensions/ollama-tool-forcing.ts
+    Depois: /reload
+
+Quer desativar temporariamente?
+
+    /ollama-tools-info   (faz toggle)
+
+Quer remover permanentemente?
+
+    rm ~/.asm-agent/extensions/ollama-tool-forcing.ts
+    /reload
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 RESUMO TÉCNICO:
+
+• TYPE: Custom Rule (Extensão ASM Agent)
+• LINGUAGEM: TypeScript (compilado automaticamente)
+• TAMANHO: ~3 KB executável, impacto ZERO em performance
+• COMPATIBILIDADE: Qualquer modelo aberto (Qwen, Llama, Mistral, etc)
+• DEPENDÊNCIAS: Nenhuma (usa API nativa do ASM Agent)
+• ATIVAÇÃO: Auto-descoberta (~/.asm-agent/extensions/)
+• SCOPO: Injeta regra no system prompt (antes do modelo pensar)
+• REVERT: Pode ser desativado ou removido a qualquer hora
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ CHECKLIST DE IMPLEMENTAÇÃO:
+
+☑ Extensão criada: ~/.asm-agent/extensions/ollama-tool-forcing.ts
+☑ Documentação escrita: 4 arquivos .md/.txt
+☑ Comando registrado: /ollama-tools-info
+☑ Auto-descoberta: Funcionará na próxima sessão
+☑ Exemplos de teste: OLLAMA-TOOL-FORCING-TESTS.md
+☑ Troubleshooting: Incluído em OLLAMA-TOOL-FORCING.md
+☑ Sem dependencies: 100% nativo do ASM Agent
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎬 PRÓXIMA AÇÃO:
+
+1. Reinicie ASM Agent (ou use /reload se já estiver rodando)
+2. Teste com uma tarefa simples
+3. Observe o modelo chamar ferramentas continuamente
+4. Aproveite o loop autônomo sem interrupções!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                🎊 Configuração completa! Bom trabalho! 🎊                       ║
+║                   Seus modelos Ollama agora trabalham melhor                    ║
+║                         com o ASM Agent autonomamente.                          ║
+╚════════════════════════════════════════════════════════════════════════════════╝

package/bundled-extensions/ollama-tool-forcing.ts

@@ -0,0 +1,90 @@
+/**
+ * Ollama Tool-Forcing Extension
+ *
+ * Força modelos open-weights rodando via Ollama a sempre chamar uma ferramenta
+ * antes de parar, evitando que gerem apenas tokens de parada sem completar tarefas.
+ *
+ * Problema: Modelos menores (Qwen 27b, Llama, etc) às vezes apenas pensam
+ * e depois emitem um stop token sem chamar ferramentas ou gerar texto.
+ *
+ * Solução: Injeta no system prompt uma instrução forte que força o modelo a:
+ * 1. Nunca parar sem chamar uma ferramenta
+ * 2. Usar ferramentas para continuar o trabalho
+ * 3. Sempre completar o ciclo de tarefas
+ *
+ * Uso:
+ * 1. Copie este arquivo para ~/.asm-agent/extensions/ (global)
+ *    ou .asm-agent/extensions/ (projeto-local)
+ * 2. Use /reload para ativar (se em modo interativo)
+ * 3. A extensão funciona automaticamente em todas as requisições
+ *
+ * Opcional: Use /ollama-tools-info para ver o status
+ */
+
+import type { ExtensionAPI } from "@asm-agent/coding-agent";
+
+export default function ollamaToolForcingExtension(pi: ExtensionAPI) {
+	let enabled = true;
+
+	// Comando para ver status e toggle
+	pi.registerCommand("ollama-tools-info", {
+		description: "Mostra status do Ollama Tool-Forcing e permite toggle",
+		handler: async (_args, ctx) => {
+			enabled = !enabled;
+			const status = enabled ? "✅ ATIVADO" : "❌ DESATIVADO";
+			ctx.ui.notify(
+				`Ollama Tool-Forcing: ${status}\n\n` +
+				`Este modo força modelos abertos a chamar ferramentas antes de parar, ` +
+				`evitando gerações vazias que interrompem o loop autônomo do ASM Agent.`,
+				"info"
+			);
+		},
+	});
+
+	// Injetar instrução no system prompt antes de cada turno
+	pi.on("before_agent_start", async (event) => {
+		if (!enabled) {
+			return undefined;
+		}
+
+		// Instrução forte para forçar uso de ferramentas
+		const toolForceRule = \`
+
+## ⚠️ REGRA CRÍTICA: TOOL-FORCING PARA MODELOS LOCAIS
+
+Você está rodando num modelo aberto (Ollama/local). Para garantir que trabalhe autonomamente:
+
+1. **NUNCA pare sem chamar uma ferramenta**: Depois de pensar/raciocinar, você DEVE chamar
+   uma ferramenta (bash, edit, ipython, etc) para continuar o trabalho.
+
+2. **Sem gerações vazias**: Não é permitido apenas gerar um "thinking" e depois parar.
+   Se terminou um ciclo, chame uma ferramenta para validar ou avançar.
+
+3. **Ferramentas = Continuidade**: As ferramentas são como seus "pulmões". Use-as para:
+   - Verificar status (bash, ipython)
+   - Fazer alterações (edit, bash)
+   - Validar resultados (bash com testes)
+   - Avançar a tarefa passo a passo
+
+4. **Padrão de turno correto**:
+   a) Receber tarefa e pensar (thinking)
+   b) Chamar uma ferramenta para agir
+   c) Observar resultado
+   d) Voltar ao passo (a) se precisar avançar
+
+5. **Proibido**: Terminar turno com apenas:
+   - Uma seção de "thinking" vazia
+   - Sem nenhuma tool call
+   - Sem texto de resposta
+   
+   Se não tiver nada para fazer, ainda assim chame bash ou ipython para verificar status.
+
+ESSA REGRA SE APLICA SEMPRE. Sem exceções. Modelos menores têm tendência de "congelar"
+se deixados livres — use ferramentas constantemente para manter-se "vivo".
+\`;
+
+		return {
+			systemPrompt: event.systemPrompt + toolForceRule,
+		};
+	});
+}

package/dist/asm-agent-runtime/run_test.py

@@ -0,0 +1,19 @@
+import asyncio
+import os
+import sys
+import unittest
+import logging
+from test.test_bash import BashTest
+
+class CustomTestResult(unittest.TextTestResult):
+    def addFailure(self, test, err):
+        super().addFailure(test, err)
+        print("\n=== FAILURE DETAILS ===")
+        print(f"Failed test: {test.id()}")
+        print(f"Error: {err}")
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(BashTest("test_undelivered_kill_leaves_journal_record_active"))
+    runner = unittest.TextTestRunner(resultclass=CustomTestResult)
+    runner.run(suite)

package/dist/asm-agent-runtime/test/test_bash.py

@@ -1121,12 +1121,12 @@ class BashTest(unittest.IsolatedAsyncioTestCase):
             ):
                 handle = bash("sleep 30")
                 try:
-                    records = await _poll_journal(journal, count=1)
+                    records = await _poll_journal(journal, count=1, pid=handle.pid)
                     self.assertTrue(records[-1]["active"])
                     with mock.patch.object(bash_module, "_signal_group", return_value=False):
                         bash_module._kill_live_handles()
                     await asyncio.sleep(0.2)  # give any (wrong) inactive write time to land
-                    records = await _poll_journal(journal, count=1)
+                    records = await _poll_journal(journal, count=1, pid=handle.pid)
                     self.assertEqual(len(records), 1)
                     self.assertTrue(records[-1]["active"])
                 finally:
@@ -1260,12 +1260,14 @@ async def _poll_group_dead(pgid: int, timeout: float = 5.0) -> None:
     raise AssertionError(f"process group {pgid} still alive after {timeout}s")
 
 
-async def _poll_journal(path: str, count: int, timeout: float = 2.0) -> list[dict]:
+async def _poll_journal(path: str, count: int, timeout: float = 2.0, pid: int | None = None) -> list[dict]:
     deadline = asyncio.get_running_loop().time() + timeout
     records: list[dict] = []
     while asyncio.get_running_loop().time() < deadline:
         with open(path) as f:
             records = [json.loads(line) for line in f if line.strip()]
+        if pid is not None:
+            records = [r for r in records if r.get("pid") == pid]
         if len(records) >= count:
             return records
         await asyncio.sleep(0.05)

package/dist/bundle/{bundled-modules-ZKJOKVMT.js → bundled-modules-ABB56VC3.js}

@@ -52,7 +52,7 @@ import {
   oauth_exports,
   runPrintMode,
   runRpcMode
-} from "./chunk-IP6ZYRWR.js";
+} from "./chunk-GUPU2EEK.js";
 import {
   AgentSession,
   CURRENT_SESSION_VERSION,
@@ -136,7 +136,7 @@ import {
   withFileMutationQueue,
   wrapRegisteredTool,
   wrapRegisteredTools
-} from "./chunk-YWSYGTH7.js";
+} from "./chunk-NESKY6T7.js";
 import "./chunk-VWR3YFK5.js";
 import "./chunk-N2CSAETN.js";
 import "./chunk-5QCJ5DQU.js";

package/dist/bundle/{chunk-IP6ZYRWR.js → chunk-GUPU2EEK.js}

@@ -329,7 +329,7 @@ import {
   waitForPromptAdmission,
   watchWithErrorHandler,
   wrapTextWithAnsi
-} from "./chunk-YWSYGTH7.js";
+} from "./chunk-NESKY6T7.js";
 import {
   array,
   boolean,
@@ -10216,7 +10216,6 @@ __export(oauth_exports, {
 // dist/core/auth-storage.js
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
 import { dirname as dirname3, join as join3 } from "path";
 
 // dist/core/prime-inference-auth.js
@@ -10895,31 +10894,6 @@ var AuthStorage = class _AuthStorage {
       })
     };
   }
-  getAntigravityAuthCandidate(provider) {
-    if (provider !== "google" && provider !== "gemini") {
-      return void 0;
-    }
-    const credsPath = join3(homedir2(), ".gemini", "oauth_creds.json");
-    if (!existsSync2(credsPath)) {
-      return void 0;
-    }
-    try {
-      const data = JSON.parse(readFileSync2(credsPath, "utf-8"));
-      if (data && data.access_token) {
-        return {
-          label: "Antigravity CLI",
-          ...this.createAuthSourceCandidate({
-            configured: false,
-            source: "antigravity",
-            identityMaterial: provider,
-            valueMaterial: data.access_token
-          })
-        };
-      }
-    } catch {
-    }
-    return void 0;
-  }
   getStoredAuthCandidate(provider, options) {
     const credential = this.data[provider] ?? (provider === "google" ? this.data.gemini : provider === "gemini" ? this.data.google : void 0);
     if (!credential) {
@@ -11004,7 +10978,6 @@ var AuthStorage = class _AuthStorage {
       fallbackCandidate
     ] : [
       this.getRuntimeAuthCandidate(provider),
-      this.getAntigravityAuthCandidate(provider),
       this.getStoredAuthCandidate(provider),
       this.getEnvironmentAuthCandidate(provider),
       fallbackCandidate
@@ -11327,24 +11300,6 @@ var AuthStorage = class _AuthStorage {
         };
       }
     }
-    if (providerId === "google" || providerId === "gemini") {
-      const agyCandidate = this.getAntigravityAuthCandidate(providerId);
-      if (agyCandidate && !this.isAuthSourceStale(providerId, agyCandidate)) {
-        const credsPath = join3(homedir2(), ".gemini", "oauth_creds.json");
-        if (existsSync2(credsPath)) {
-          try {
-            const data = JSON.parse(readFileSync2(credsPath, "utf-8"));
-            if (data && data.access_token) {
-              return {
-                apiKey: data.access_token,
-                sourceToken: this.getAuthSourceTokenForCandidate(providerId, agyCandidate)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    }
     const cred = this.get(providerId);
     if (cred?.type === "api_key") {
       const storedCandidate = this.getStoredAuthCandidate(providerId);
@@ -11776,7 +11731,7 @@ function requireCount(args, count, usage) {
 // dist/core/settings-manager.js
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir2 } from "os";
 import { dirname as dirname4, join as join4 } from "path";
 var RECENT_MODELS_LIMIT = 20;
 var DEFAULT_IDLE_EVICTION_MINUTES = 90;
@@ -12141,10 +12096,10 @@ var SettingsManager = class _SettingsManager {
       return sessionDir;
     }
     if (sessionDir === "~") {
-      return homedir3();
+      return homedir2();
     }
     if (sessionDir.startsWith("~/")) {
-      return join4(homedir3(), sessionDir.slice(2));
+      return join4(homedir2(), sessionDir.slice(2));
     }
     return sessionDir;
   }
@@ -13542,7 +13497,7 @@ async function launchDaemonUpdateRestartCoordinator(options) {
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync5, rmSync as rmSync3, statSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir4, tmpdir } from "node:os";
+import { homedir as homedir3, tmpdir } from "node:os";
 import { basename as basename3, dirname as dirname6, join as join6, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 
 // ../../node_modules/glob/dist/esm/index.min.js
@@ -18495,7 +18450,7 @@ function toPosixPath(p) {
   return p.split(sep2).join("/");
 }
 function getHomeDir() {
-  return process.env.HOME || homedir4();
+  return process.env.HOME || homedir3();
 }
 function prefixIgnorePattern(line, prefix) {
   const trimmed = line.trim();
@@ -20320,7 +20275,7 @@ var DefaultPackageManager = class {
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync2, readFileSync as readFileSync6, realpathSync, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { basename as basename4, dirname as dirname7, join as join7, resolve as resolve4 } from "node:path";
 var DAEMON_SUPERVISOR_REGISTRY_DIR_ENV = "ASM_AGENT_INTERNAL_DAEMON_SUPERVISOR_REGISTRY_DIR";
 var OWNER_VERSION = 1;
@@ -20509,7 +20464,7 @@ var DaemonShutdownAdmission = class {
   }
 };
 function defaultDaemonSupervisorRegistryDir(environment = process.env) {
-  return environment[DAEMON_SUPERVISOR_REGISTRY_DIR_ENV] ?? join7(homedir5(), ".asm-agent", "supervisor-owners");
+  return environment[DAEMON_SUPERVISOR_REGISTRY_DIR_ENV] ?? join7(homedir4(), ".asm-agent", "supervisor-owners");
 }
 function legacyDaemonSupervisorRegistryDir(environment = process.env) {
   return environment[DAEMON_SUPERVISOR_REGISTRY_DIR_ENV] ? void 0 : resolve4(defaultDaemonSocketDir(), "supervisor-owners");
@@ -26930,7 +26885,7 @@ File: ${modelsJsonPath}`);
 
 // dist/core/resource-loader.js
 import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { join as join10, resolve as resolve8, sep as sep4 } from "node:path";
 function resolvePromptInput(input, description) {
   if (!input) {
@@ -27406,11 +27361,11 @@ var DefaultResourceLoader = class {
     const trimmed = p.trim();
     let expanded = trimmed;
     if (trimmed === "~") {
-      expanded = homedir6();
+      expanded = homedir5();
     } else if (trimmed.startsWith("~/")) {
-      expanded = join10(homedir6(), trimmed.slice(2));
+      expanded = join10(homedir5(), trimmed.slice(2));
     } else if (trimmed.startsWith("~")) {
-      expanded = join10(homedir6(), trimmed.slice(1));
+      expanded = join10(homedir5(), trimmed.slice(1));
     }
     return resolve8(this.cwd, expanded);
   }
@@ -40328,7 +40283,7 @@ var PrimeTeamSelectorComponent = class extends Container {
 
 // dist/modes/interactive/auth-flows.js
 var BEDROCK_PROVIDER_ID = "amazon-bedrock";
-var ASM_AGENT_LOGIN_PROVIDER_IDS = /* @__PURE__ */ new Set(["openai-codex", "anthropic", "google", "gemini"]);
+var ASM_AGENT_LOGIN_PROVIDER_IDS = /* @__PURE__ */ new Set(["openai-codex", "anthropic"]);
 var ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
 function isAnthropicSubscriptionAuthKey(apiKey) {
   return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");