Mirror of openTARS 5.2 Ranger (revision 2026110101) (part 2)

.gitattributes

@@ -38,3 +38,4 @@ app/tars_qt/fontes/IBMPlexMono-Regular.ttf filter=lfs diff=lfs merge=lfs -text
 app/tars_qt/fontes/IBMPlexSans-Medium.ttf filter=lfs diff=lfs merge=lfs -text
 app/tars_qt/fontes/IBMPlexSans-Regular.ttf filter=lfs diff=lfs merge=lfs -text
 app/tars_qt/fontes/IBMPlexSans-SemiBold.ttf filter=lfs diff=lfs merge=lfs -text
+opentars_all.deb filter=lfs diff=lfs merge=lfs -text

app/tests/test_qt_imagem.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Imagem que o modelo manda no Markdown (`![](caminho)`): só arquivo local vira figura; o resto nunca é carregado."""
+import os, sys, tempfile
+from pathlib import Path
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+try:
+    from PySide6.QtGui import QImage, QColor
+    from PySide6.QtWidgets import QApplication
+except ImportError:
+    print("test_qt_imagem: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+app = QApplication.instance() or QApplication([])
+from tars_qt import conversa, tema
+app.setStyleSheet(tema.folha_principal() if hasattr(tema, "folha_principal") else "")
+
+pasta = tempfile.mkdtemp(prefix="opentars-img-")
+grande = os.path.join(pasta, "foto grande.png")
+pequena = os.path.join(pasta, "icone.png")
+for caminho, w, h in ((grande, 1600, 1200), (pequena, 64, 48)):
+    im = QImage(w, h, QImage.Format_RGB32); im.fill(QColor("#5FD97A")); assert im.save(caminho)
+texto_falso = os.path.join(pasta, "nota.txt"); open(texto_falso, "w").write("x")
+quebrada = os.path.join(pasta, "quebrada.png"); open(quebrada, "w").write("não sou uma imagem")
+
+# 1. o que vira figura e o que não vira
+assert conversa.caminho_de_imagem(grande) and conversa.caminho_de_imagem(pequena)
+assert conversa.caminho_de_imagem(f"<{grande}>"), "com sinais < >"
+assert conversa.caminho_de_imagem("file://" + pequena.replace(" ", "%20")), "file:// e %20"
+for ruim in ("https://exemplo.com/a.png", "http://127.0.0.1/a.png", "data:image/png;base64,AAAA", "foto.png",
+             "../foto.png", os.path.join(pasta, "nao-existe.png"), texto_falso, pasta, "ftp://x/a.png"):
+    assert conversa.caminho_de_imagem(ruim) is None, ruim
+print("OK: só arquivo local de imagem existente passa")
+
+# 2. partir em blocos
+p = conversa.partir_em_blocos(f"Olha:\n![minha foto]({pequena})\nE pronto.")
+assert [x[0] for x in p] == ["texto", "imagem", "texto"], p
+assert p[1][1] == Path(pequena).resolve() and p[1][2] == "minha foto"
+p = conversa.partir_em_blocos(f"```\n![nao]({pequena})\n```\n![a]({pequena}) e ![b]({grande} \"título\")")
+assert [x[0] for x in p] == ["codigo", "imagem", "texto", "imagem"], [x[0] for x in p]
+assert "![nao]" in p[0][1], "dentro de cerca de código não vira figura"
+r = conversa.partir_em_blocos("![remota](https://exemplo.com/rastreio.png) fim")
+assert [x[0] for x in r] == ["texto"] and "![" not in r[0][1] and "[remota](https://exemplo.com/rastreio.png)" in r[0][1], r
+print("OK: texto, imagem e código na ordem; remota vira link comum")
+
+# 3. o widget: reduzida para caber, sem carregar a imagem inteira
+b = conversa.BlocoTexto()
+b.acrescentar(f"Aqui:\n\n![grande]({grande})\n\n![pequena]({pequena})\n\n![quebrada]({quebrada})")
+b.concluir()
+figs = [w for w in b._pecas if isinstance(w, conversa.ImagemIA)]
+assert len(figs) == 3, len(figs)
+g, pq, q = figs
+assert g.pixmap().width() <= 640 and g.pixmap().height() <= 480 and g.pixmap().width() * 3 == g.pixmap().height() * 4 or abs(g.pixmap().width() / g.pixmap().height() - 4 / 3) < 0.02
+assert (pq.pixmap().width(), pq.pixmap().height()) == (64, 48), "pequena não é ampliada"
+assert q.pixmap() is None or q.pixmap().isNull()
+assert q.text() == "quebrada" and q.property("papel") == "aviso-linha", "arquivo que não abre mostra o texto"
+assert g.toolTip() == "foto grande.png" and g.accessibleName() == "grande"
+print("OK: figura reduzida, pequena intacta, arquivo quebrado vira texto")
+
+# 4. resposta só com texto continua igual; imagem remota sozinha não gera figura
+b2 = conversa.BlocoTexto(); b2.acrescentar("oi **tudo**"); b2.concluir()
+assert not b2._pecas and b2.rotulo.text() == "oi **tudo**"
+b3 = conversa.BlocoTexto(); b3.acrescentar("![x](https://exemplo.com/a.png)"); b3.concluir()
+assert not b3._pecas and "![" not in b3.rotulo.text()
+print("test_qt_imagem: TUDO OK.")

app/tests/test_qt_lancador.py

@@ -0,0 +1,65 @@
+"""5.2 (F4): a barra rápida como lançador. Vazia mostra as capacidades; "Buscar um arquivo" busca aqui mesmo e os links
+dos resultados só abrem o que a busca achou (pelo número), nunca um caminho vindo de fora."""
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _util import RAIZ  # noqa: E402,F401
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+from PySide6.QtCore import QUrl  # noqa: E402
+from PySide6.QtWidgets import QApplication  # noqa: E402
+
+from tars_qt import barra_rapida as br  # noqa: E402
+
+app = QApplication.instance() or QApplication([])
+abertos = []
+br.plataforma.abrir = abertos.append
+br.busca.buscar = lambda frase: [{"caminho": "/casa/Documentos/Contrato de aluguel 2024.pdf", "nome": "Contrato de aluguel 2024.pdf",
+                                  "pasta": "/casa/Documentos", "modificado": 1704000000, "trecho": "…O LOCATÁRIO obriga-se…",
+                                  "sem_texto": False, "pontos": 9}] if "aluguel" in frase else []
+
+barra = br.BarraRapida()
+barra.mostrar()
+app.processEvents()
+assert barra.capacidades.isVisibleTo(barra) and len(barra.capacidades.findChildren(br.QPushButton)) == 6
+botoes = {b.accessibleName(): b for b in barra.capacidades.findChildren(br.QPushButton)}
+print("OK: vazia, a barra mostra as capacidades do mock-up e a de editar uma foto")
+pedidos_foto = []
+barra.editar_foto.connect(lambda: pedidos_foto.append(1))
+botoes[br.t("rapido.cap.foto")].click()
+assert pedidos_foto == [1] and not barra.isVisible(), "Editar uma foto fecha a barra e pede o seletor de fotos"
+barra.mostrar()
+print("OK: Editar uma foto fecha a barra e abre o seletor de fotos do assistente")
+
+botoes[br.t("rapido.cap.web")].click()
+assert barra.entrada.toPlainText() == br.t("rapido.pref.web") and not barra.capacidades.isVisibleTo(barra)
+barra.entrada.clear()
+print("OK: pesquisar na web preenche o começo do pedido e a lista some")
+
+botoes[br.t("rapido.cap.arquivo")].click()
+assert barra.modo == "arquivo"
+barra.entrada.setPlainText("o contrato de aluguel de 2024")
+barra._enviar()
+fim = time.time() + 5
+while time.time() < fim and not barra.achados:
+    app.processEvents()
+    time.sleep(0.02)
+assert barra.achados and "Contrato de aluguel 2024.pdf" in barra._texto and "opentars-abrir:0" in barra._texto, barra._texto
+barra._link(QUrl("opentars-abrir:0"))
+barra._link(QUrl("opentars-pasta:0"))
+barra._link(QUrl("opentars-abrir:7"))              # número que a busca não deu: nada
+barra._link(QUrl("file:///etc/passwd"))            # esquema de fora: o caminho seguro ignora
+assert abertos == ["/casa/Documentos/Contrato de aluguel 2024.pdf", "/casa/Documentos"], abertos
+print("OK: a busca roda na barra; Abrir e Mostrar na pasta abrem só o que ela achou")
+
+barra.entrada.setPlainText("planilha de marte")
+barra._enviar()
+fim = time.time() + 5
+while time.time() < fim and br.t("busca.nada") not in barra._texto:
+    app.processEvents()
+    time.sleep(0.02)
+assert br.t("busca.nada") in barra._texto
+print("OK: sem resultado, diz que não achou")
+print("test_qt_lancador: TUDO OK.")

app/tests/test_qt_mascote.py

@@ -0,0 +1,158 @@
+"""O mascote (o monólito): anda dentro da conversa, reage ao que a IA faz, dá dicas sem repetir e se desliga pela
+configuração e por TARS_SEM_MASCOTE. Janela de verdade, sem tela (offscreen) e sem Ollama."""
+import json
+import os
+import sys
+import tempfile
+import time
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+for k in ("SESSOES", "NUVEM", "PRIMEIRO_USO"):
+    os.environ[f"TARS_ARQUIVO_{k}"] = os.path.join(CASA, k.lower() + ".json")
+os.environ["OLLAMA_HOST"] = "http://127.0.0.1:9"
+os.environ["TARS_IDIOMA"] = "pt_BR"
+os.environ.pop("TARS_SEM_MASCOTE", None)
+
+from _util import carregar_tars, RAIZ  # noqa: E402,F401
+
+try:
+    from PySide6.QtWidgets import QApplication
+except ImportError:
+    print("test_qt_mascote: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+tars = carregar_tars()
+import tars_i18n  # noqa: E402
+from tars_qt import mascote as mod, principal, tema  # noqa: E402
+
+app = QApplication.instance() or QApplication([])
+tema.carregar_fontes()
+
+
+def esperar(s):
+    fim = time.time() + s
+    while time.time() < fim:
+        app.processEvents()
+        time.sleep(0.01)
+
+
+w = principal.JanelaPrincipal(nucleo=tars, capturar_stdout=False)
+w.resize(1200, 780)
+w.show()
+esperar(0.5)
+m = w.mascote
+
+# 1) aparece por padrão, dentro da conversa, em cima do campo de escrever
+assert m.isVisible() and m.parentWidget() is not w.lateral
+chao = w.compositor.mapTo(m.parentWidget(), w.compositor.rect().topLeft()).y()
+assert abs((m.y() + mod.ALTURA) - chao) <= 20, (m.y(), chao)
+print("OK: aparece sozinho, em cima do campo de escrever")
+
+# 2) anda e nunca sai dos limites (nem quando a janela encolhe)
+m._parado_ate = 0
+x0 = m.x()
+esperar(1.0)
+assert m.x() != x0, "não andou"
+for largura in (1200, 900, 1500):
+    w.resize(largura, 780)
+    m._x = 99999
+    esperar(0.2)
+    assert 16 <= m.x() <= m.parentWidget().width() - mod.LARGURA - 16 + 1, (largura, m.x())
+print("OK: anda e fica dentro da conversa")
+
+# 3) reage ao que a IA faz
+w.ponte.ocupado.emit(True)
+esperar(0.1)
+assert m.estado == "pensando"
+w._ao_evento("ferramenta", {"nome": "type_text", "resumo": "x"})
+assert m.estado == "trabalhando" and "…" in m.balao.text() and m.balao.isVisible(), m.balao.text()
+m._ultima_fala = 0
+w._ao_evento("ferramenta_fim", {"nome": "type_text", "sucesso": False, "segundos": 1})
+assert m.estado == "erro" and m.balao.text() == tars_i18n.t("mascote.ops"), (m.estado, m.balao.text())
+m._ultima_fala = 0
+w._ao_evento("plano", {"etapas": ["a", "b", "c"]})
+assert "3" in m.balao.text()
+m._ultima_fala = 0
+w.ponte.aprovacao.emit(type("A", (), {"comando": "rm x", "responder": lambda self, ok: None})())
+assert m.estado == "espera" and m.balao.text() == tars_i18n.t("mascote.permissao")
+w.ponte.ocupado.emit(False)
+w.ponte.concluido.emit("pronto")
+esperar(0.1)
+assert m.estado == "feliz" and m.balao.text() == tars_i18n.t("mascote.pronto")
+esperar(2.8)
+assert m.estado == "ocioso", m.estado
+# pedido cancelado não comemora
+m.balao.hide(); m._ultima_fala = 0; w._cancelou = True
+w.ponte.concluido.emit("parei")
+assert m.estado != "feliz"
+w._cancelou = False
+print("OK: reage (pensando, ferramenta, erro, plano, permissão, pronto)")
+
+# 4) não metralha balões: duas ferramentas seguidas, só a primeira fala
+m.balao.hide(); m._ultima_fala = 0
+w._ao_evento("ferramenta", {"nome": "type_text"}); primeiro = m.balao.text()
+w._ao_evento("ferramenta", {"nome": "click_mouse"})
+assert m.balao.text() == primeiro
+print("OK: balões não se atropelam")
+
+# 5) dicas: as 10 saem sem repetir antes de acabar a rodada
+vistas = []
+for _ in range(mod.N_DICAS):
+    m._ultima_fala = 0
+    m.dica()
+    vistas.append(m.balao.text())
+assert len(set(vistas)) == mod.N_DICAS, vistas
+print("OK: 10 dicas, sem repetir na rodada")
+
+# 6) textos: todas as chaves existem em pt_BR e en, com os mesmos {campos}
+import re  # noqa: E402
+chaves = [k for k in json.load(open(os.path.join(RAIZ, "idiomas", "pt_BR.json"), encoding="utf-8")) if k.startswith(("mascote.", "cfg.mascote"))]
+en = json.load(open(os.path.join(RAIZ, "idiomas", "en.json"), encoding="utf-8"))
+pt = json.load(open(os.path.join(RAIZ, "idiomas", "pt_BR.json"), encoding="utf-8"))
+assert len(chaves) >= 20 and all(k in en for k in chaves)
+assert all(re.findall(r"{\w+}", pt[k]) == re.findall(r"{\w+}", en[k]) for k in chaves)
+usadas = set(re.findall(r't\("(mascote\.[a-z_]+)"', open(os.path.join(RAIZ, "tars_qt", "mascote.py"), encoding="utf-8").read()))
+assert usadas <= set(chaves), usadas - set(chaves)
+print("OK: textos nos dois idiomas")
+
+# 7) liga e desliga: configuração, menu dele e variável de ambiente
+tars_i18n.salvar_config(mascote=False)
+w.config.mudou_mascote.emit()
+assert not m.isVisible() and not m.balao.isVisible()
+tars_i18n.salvar_config(mascote=True)
+w.config.mudou_mascote.emit()
+assert m.isVisible()
+m._esconder()
+assert not m.isVisible() and tars_i18n.ler_config()["mascote"] is False
+tars_i18n.salvar_config(mascote=True)
+os.environ["TARS_SEM_MASCOTE"] = "1"
+assert not mod.ligado()
+del os.environ["TARS_SEM_MASCOTE"]
+assert mod.ligado()
+print("OK: liga e desliga (configuração, menu, TARS_SEM_MASCOTE)")
+
+# 8) cada humor tem um rosto próprio (fora da piscada, que é igual em todos)
+def _bytes(estado):
+    img = mod.desenhar_sprite(estado, 0.0, False, 1, 1.0)    # agora=1.0: longe da piscada
+    return bytes(img.constBits())[:img.sizeInBytes()]
+rostos = {e: _bytes(e) for e in ("ocioso", "pensando", "trabalhando", "espera", "erro", "feliz", "sono")}
+assert len(set(rostos.values())) == len(rostos), [e for e in rostos if list(rostos.values()).count(rostos[e]) > 1]
+print("OK: um rosto por humor")
+
+# 9) cochila depois de muito tempo parado e acorda com qualquer coisa
+m.mostrar_de_novo()                      # o passo 7 terminou com ele escondido pelo menu
+m.estado = "ocioso"
+m._ultima_atividade = time.monotonic() - mod.SONO_S - 1
+esperar(0.1)
+assert m.estado == "sono"
+x0 = m.x(); esperar(0.5)
+assert m.x() == x0, "anda dormindo"
+w.ponte.ocupado.emit(True); esperar(0.05)
+assert m.estado == "pensando"
+w.ponte.ocupado.emit(False); esperar(0.05)
+print("OK: cochila e acorda")
+
+w.close()
+print("\nTUDO OK.")

app/tests/test_qt_modos.py

@@ -0,0 +1,121 @@
+"""5.1: os modos na janela de verdade (offscreen, Ollama de mentira). O Lite esconde histórico, memória, escolha de
+modelo e as páginas avançadas; o Pro mostra tudo; trocar o modo em Configurações > Geral muda a janela na hora; as
+páginas Ajustes avançados e Diagnóstico gravam e leem o que devem."""
+import os
+import sys
+import tempfile
+import time
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+CASA = tempfile.mkdtemp(prefix="opentars-modos-qt-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+os.environ["TARS_ARQUIVO_NUVEM"] = os.path.join(CASA, "nuvem.json")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(CASA, "primeiro_uso.json")
+os.environ["TARS_ARQUIVO_CONFIG"] = os.path.join(CASA, "config.json")
+
+from _util import RAIZ  # noqa: E402,F401
+
+try:
+    from PySide6.QtTest import QTest
+except ImportError:
+    print("test_qt_modos: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+import fake_ollama  # noqa: E402
+
+servidor, url = fake_ollama.subir(modelos=["qwen3:4b"])
+os.environ["OLLAMA_HOST"] = url
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+tars.avisos_de_ambiente = lambda: []
+tars.detectar_gpu = lambda forcar=False: None
+tars.aquecer_ajudante = lambda: None
+
+import tars_historico  # noqa: E402
+import tars_modos as modos  # noqa: E402
+from tars_qt.configuracoes import ultimas_ferramentas  # noqa: E402
+from tars_qt.primeiro_uso import criar_aplicativo  # noqa: E402
+from tars_qt.principal import JanelaPrincipal  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+
+
+def esperar(cond, segundos=15, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if cond():
+            return
+        QTest.qWait(20)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+modos.definir_modo("lite")
+j = JanelaPrincipal(tars, historico=tars_historico.Historico(os.path.join(CASA, "historico.json")), capturar_stdout=False)
+j.resize(1200, 780)
+j.show()
+esperar(lambda: j._modelos, o_que="modelos")
+cfg = j.config
+assert not j.lateral.lista_w.isVisibleTo(j) and not j.lateral.caixa_busca.isVisibleTo(j), "Lite: sem histórico"
+assert not j.lateral.b_memoria.isVisibleTo(j) and not j.cabecalho.pilula.isVisibleTo(j), "Lite: sem memória e seletor"
+assert j.lateral.versao.text() == tars.VERSAO_EXIBIDA
+j.abrir_config("avancado")                        # página escondida no Lite: cai na Geral
+assert cfg.pilha.currentWidget() is cfg.paginas["geral"]
+visiveis = {n for n, b in cfg.nav.items() if b.isVisibleTo(cfg)}
+assert visiveis == {"geral", "assistente", "voz", "atualizacoes", "sobre"}, visiveis   # 5.2: o assistente vale em todo modo
+print("OK: o Lite esconde histórico, memória, seletor de modelo e as páginas que não são dele")
+
+# trocar para Pro pela própria tela
+cfg.paginas["geral"].chips_modo["pro"].click()
+assert modos.modo_atual() == "pro"
+assert not j.lateral.lista_w.isHidden() and not j.lateral.b_memoria.isHidden() and not j.cabecalho.pilula.isHidden()
+visiveis = {n for n, b in cfg.nav.items() if b.isVisibleTo(cfg)}
+assert {"avancado", "diagnostico", "memoria", "rotinas", "nuvem"} <= visiveis, visiveis
+print("OK: trocar para o Pro em Configurações > Geral mostra tudo na hora")
+
+# Ajustes avançados: grava o que está na tela
+cfg.ir("avancado")
+av = cfg.paginas["avancado"]
+av.temperatura.setCurrentIndex(av.temperatura.findData(0.7))
+av.contexto.setCurrentIndex(av.contexto.findData(16384))
+av.instrucoes.setPlainText("seja breve")
+av.caixas["execute_terminal"].setChecked(False)
+av._salvar()
+a = modos.avancado()
+assert a == {"temperatura": 0.7, "contexto": 16384, "instrucoes": "seja breve",
+             "ferramentas_desligadas": ["execute_terminal"]}, a
+assert av.msg.text() and not av.aviso.isVisibleTo(cfg)
+cfg.paginas["geral"].chips_modo["base"].click()
+cfg.ir("geral")
+assert not cfg.nav["avancado"].isVisibleTo(cfg) and modos.avancado()["temperatura"] is None
+cfg.paginas["geral"].chips_modo["pro"].click()
+print("OK: Ajustes avançados gravam e só valem no Pro")
+
+# Diagnóstico: lê as ferramentas do log
+log = os.path.join(CASA, "tars.log")
+with open(log, "w", encoding="utf-8") as f:
+    f.write('2026-10-16 10:00:01,000 INFO ferramenta=open_application args={"app": "calc"} sucesso=True tempo=0.1s mensagem="ok"\n')
+    f.write("2026-10-16 10:00:02,000 INFO outra coisa\n")
+    f.write('2026-10-16 10:00:03,000 INFO ferramenta=execute_terminal args={"command": "ls"} sucesso=False tempo=0s mensagem="x"\n')
+assert ultimas_ferramentas(log) == ['10:00:01 ✓ open_application {"app": "calc"}', '10:00:03 × execute_terminal {"command": "ls"}']
+assert ultimas_ferramentas(os.path.join(CASA, "nao-existe.log")) == []
+tars.ARQUIVO_LOG = log
+cfg.ir("diagnostico")
+assert "open_application" in cfg.paginas["diagnostico"].log.toPlainText()
+print("OK: o Diagnóstico mostra as últimas ferramentas do log")
+
+# 5.1: modelo da nuvem do Ollama escolhido à mão: o rodapé avisa que sai do computador
+tars.modo_modelo, tars.modelo_manual = "MANUAL", "gpt-oss:20b-cloud"
+j._mostrar_modelo_em_uso()
+assert "Ollama Cloud" in j.compositor.rodape.text(), j.compositor.rodape.text()
+tars.modo_modelo, tars.modelo_manual = "MANUAL", "qwen3:4b"
+j._mostrar_modelo_em_uso()
+assert "Ollama Cloud" not in j.compositor.rodape.text()
+print("OK: o rodapé avisa quando o modelo escolhido é da nuvem do Ollama")
+
+j._saindo = True
+j.close()
+print("\nTUDO OK.")

app/tests/test_qt_primeiro_uso.py

@@ -0,0 +1,168 @@
+"""5.0 Tesseract: o assistente de primeiro uso em Qt, de ponta a ponta, sem
+tela (QT_QPA_PLATFORM=offscreen) e contra um Ollama de mentira."""
+
+import os
+import stat
+import sys
+import tempfile
+import time
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+os.environ["TARS_MODELO_GARGANTUA"] = "ProjectOpenTARS/Gargantua-2"
+
+from _util import RAIZ  # noqa: F401  (raiz no sys.path, idioma de teste)
+
+try:
+    from PySide6.QtTest import QTest
+    from PySide6.QtWidgets import QApplication
+except ImportError:
+    print("test_qt_primeiro_uso: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+import fake_ollama
+import tars_i18n
+import tars_primeiro_uso as pu
+
+pasta = tempfile.mkdtemp(prefix="opentars-qt-")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(pasta, "primeiro_uso.json")
+os.environ["TARS_ARQUIVO_NUVEM"] = os.path.join(pasta, "nuvem.json")
+
+servidor, url = fake_ollama.subir(modelos=["qwen3:4b"], chave="boa")
+os.environ["OLLAMA_HOST"] = url
+
+from tars_qt.primeiro_uso import JanelaPrimeiroUso, criar_aplicativo  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+
+
+def esperar(condicao, segundos=15, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if condicao():
+            return
+        QTest.qWait(20)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+def passar_pelo_ollama(j):
+    j.ir("ollama")
+    p = j.paginas["ollama"]
+    esperar(lambda: p.b_continuar.isEnabled(), o_que="Ollama encontrado")
+    p.b_continuar.click()
+    assert j.atual == "nuvem"
+
+
+def ate_o_fim(j):
+    esperar(lambda: j.paginas["gargantua"].b_continuar.isEnabled(), o_que="download do Gargantua")
+    assert j.paginas["gargantua"].barra.value() == 1000
+    j.paginas["gargantua"].b_continuar.click()
+    assert j.atual == "teste"
+    esperar(lambda: j.paginas["teste"].b_continuar.isEnabled(), o_que="teste rápido")
+    j.paginas["teste"].b_continuar.click()
+    if j.atual == "sistema":                     # Windows e macOS: o passo das permissões e do atalho
+        j.paginas["sistema"].nav.itemAt(j.paginas["sistema"].nav.count() - 1).widget().click()
+    assert j.atual == "pronto"
+
+
+# --- 1) caminho padrão: só no computador ---------------------------------
+tars_i18n.definir_idioma("pt_BR")
+j = JanelaPrimeiroUso()
+j.show()
+assert j.atual == "idioma" and len(j.paginas) == 8 + ("sistema" in j.paginas)
+assert j.windowTitle() == tars_i18n.t("pu.janela")
+j.paginas["idioma"].continuar()                 # mantém português
+assert j.atual == "modo"                         # 5.1: o modo vem logo depois do idioma
+j.paginas["modo"].continuar()                    # Base, já marcado
+assert j.atual == "ollama"
+esperar(lambda: j.paginas["ollama"].b_continuar.isEnabled(), o_que="Ollama")
+j.paginas["ollama"].b_continuar.click()
+assert j.atual == "nuvem"
+assert j.paginas["nuvem"].grupo.marcado() == 0, "o padrão é 'Não, só no meu computador'"
+j.paginas["nuvem"].continuar()
+assert j.atual == "gargantua"
+ate_o_fim(j)
+assert not pu.carregar_nuvem()["ativa"]
+assert not pu.primeiro_uso_concluido()
+assert j.paginas["pronto"].resumo_nuvem.texto.plano() == tars_i18n.t("pu.pronto.nuvem_nao")
+j.terminar()
+assert pu.primeiro_uso_concluido() and j.terminou
+puxados = [c["model"] for m, p, c in servidor.pedidos if p == "/api/pull"]
+assert puxados == ["ProjectOpenTARS/Gargantua-2", "ProjectOpenTARS/Gargantua-2:lite"], puxados   # o 2B e o Lite obrigatório
+
+# --- 2) trocar de idioma reconstrói a janela -------------------------------
+pu.marcar_concluido(False)
+j2 = JanelaPrimeiroUso()
+j2.show()
+pt_titulo = j2.paginas["idioma"].h1.plano()
+codigos = j2.paginas["idioma"].codigos
+assert "en" in codigos
+j2.paginas["idioma"].grupo.escolher(j2.paginas["idioma"].grupo.cartoes[codigos.index("en")])
+j2.paginas["idioma"].continuar()
+assert tars_i18n.idioma_atual() == "en"
+assert j2.atual == "modo"
+assert j2.paginas["modo"].h1.plano() == tars_i18n.t("pu.modo.titulo")
+assert j2.paginas["ollama"].h1.plano() != pt_titulo
+assert j2.paginas["ollama"].h1.plano() == tars_i18n.t("pu.ollama.titulo")
+j2.close()
+tars_i18n.definir_idioma("pt_BR")
+
+# --- 3) com nuvem: chave inválida, depois válida, salva com modo 0600 -------
+j3 = JanelaPrimeiroUso()
+j3.show()
+passar_pelo_ollama(j3)
+nuvem = j3.paginas["nuvem"]
+nuvem.grupo.escolher(nuvem.sim)
+nuvem.continuar()
+assert j3.atual == "chave"
+c = j3.paginas["chave"]
+assert c.prov_id == "ollama" and c.nota.isVisibleTo(c), "Ollama Cloud avisa que o endereço é a confirmar"
+c.chips["groq"].click()
+assert c.prov_id == "groq" and "groq" in c.endereco.text() and not c.nota.isVisibleTo(c)
+c.continuar()                                   # sem chave: não avança
+assert j3.atual == "chave" and pu.carregar_nuvem()["ativa"] is False
+c.chips["outro"].click()
+c.endereco.setText(url)
+c.chave.setText("ruim")
+c.b_testar.click()
+esperar(lambda: c.b_testar.isEnabled(), o_que="teste da chave ruim")
+assert c.resultado.plano() == tars_i18n.t("pu.chave.erro_chave"), c.resultado.plano()
+assert "ruim" not in c.resultado.plano()
+c.chave.setText("boa")
+c.b_testar.click()
+esperar(lambda: c.b_testar.isEnabled(), o_que="teste da chave boa")
+assert c.resultado.plano() == tars_i18n.t("pu.chave.ok"), c.resultado.plano()
+c.continuar()
+assert j3.atual == "gargantua"
+n = pu.carregar_nuvem()
+assert n == {"ativa": True, "provedor": "outro", "endereco": url, "chave": "boa"}, n
+assert os.name == "nt" or stat.S_IMODE(os.stat(pu.arquivo_nuvem()).st_mode) == 0o600
+ate_o_fim(j3)
+assert j3.paginas["pronto"].resumo_nuvem.texto.plano() == tars_i18n.t("pu.pronto.nuvem_sim", provedor="Outro")
+j3.close()
+
+# --- 4) Gargantua já instalado: não baixa de novo ----------------------------
+servidor2, url2 = fake_ollama.subir(modelos=["ProjectOpenTARS/Gargantua:latest", "ProjectOpenTARS/cooper:latest"])
+os.environ["OLLAMA_HOST"] = url2
+j4 = JanelaPrimeiroUso()
+j4.show()
+passar_pelo_ollama(j4)
+j4.paginas["nuvem"].continuar()
+esperar(lambda: j4.paginas["gargantua"].pronto and j4.paginas["gargantua"].b_continuar.isEnabled(), o_que="só o Lite")
+puxados2 = [c["model"] for m, p, c in servidor2.pedidos if p == "/api/pull"]
+assert puxados2 == ["ProjectOpenTARS/Gargantua-2:lite"], puxados2    # o principal já existe; só o Lite obrigatório vem
+j4.close()
+
+# --- 5) Ollama fora do ar: oferece instalar, não avança ------------------------
+os.environ["OLLAMA_HOST"] = "http://127.0.0.1:9"
+j5 = JanelaPrimeiroUso()
+j5.show()
+j5.ir("ollama")
+p5 = j5.paginas["ollama"]
+esperar(lambda: p5.linha.texto.plano() != tars_i18n.t("pu.ollama.procurando"), o_que="busca do Ollama")
+assert not p5.b_continuar.isEnabled()
+j5.close()
+
+for s in (servidor, servidor2):
+    s.shutdown()
+print("test_qt_primeiro_uso: OK")

app/tests/test_qt_primeiro_uso_gargantua2.py

@@ -0,0 +1,115 @@
+"""18/10: a tela de download do primeiro uso baixa só o Gargantua 2 (que enxerga a tela; o Cooper foi descontinuado e não
+é mais oferecido). Qt offscreen, Ollama de mentira."""
+import os
+import sys
+import tempfile
+import time
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+os.environ["TARS_MODELO_GARGANTUA"] = "ProjectOpenTARS/Gargantua-2"
+from _util import RAIZ  # noqa: F401,E402
+
+try:
+    from PySide6.QtTest import QTest
+except ImportError:
+    print("test_qt_primeiro_uso_gargantua2: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+import fake_ollama  # noqa: E402
+import tars_i18n  # noqa: E402
+import tars_primeiro_uso as pu  # noqa: E402
+
+pasta = tempfile.mkdtemp(prefix="opentars-qt-garg2-")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(pasta, "primeiro_uso.json")
+os.environ["TARS_ARQUIVO_NUVEM"] = os.path.join(pasta, "nuvem.json")
+from tars_qt.primeiro_uso import JanelaPrimeiroUso, criar_aplicativo  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+tars_i18n.definir_idioma("pt_BR")
+GARG2, GARG1, COOPER = "ProjectOpenTARS/Gargantua-2:latest", "ProjectOpenTARS/Gargantua:latest", "ProjectOpenTARS/cooper:1.2"
+
+
+def esperar(condicao, segundos=20, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if condicao():
+            return
+        QTest.qWait(20)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+def abrir(modelos, **opcoes):
+    servidor, url = fake_ollama.subir(modelos=modelos, **opcoes)
+    os.environ["OLLAMA_HOST"] = url
+    j = JanelaPrimeiroUso()
+    j.show()
+    j.ir("gargantua")
+    return j, j.paginas["gargantua"], servidor
+
+
+def puxados(servidor):
+    return [c["model"] for m, p, c in servidor.pedidos if p == "/api/pull"]
+
+
+# 1) nada instalado: baixa o Gargantua 2 e o Lite obrigatório (25/10), sem opção nem fase do Cooper
+j, pg, srv = abrir([])
+esperar(lambda: pg.pronto and pg.b_continuar.isEnabled(), o_que="baixar o Gargantua 2")
+assert puxados(srv) == [pu.MODELO_GARGANTUA, pu.MODELO_GARGANTUA_LITE] == \
+    ["ProjectOpenTARS/Gargantua-2", "ProjectOpenTARS/Gargantua-2:lite"], puxados(srv)
+assert not hasattr(pg, "c_cooper") and not hasattr(pg, "baixar_cooper"), "o Cooper não é mais oferecido"
+j.close()
+print("OK: sem nenhum modelo, baixa o Gargantua 2 e o Lite (a IA de segundo plano)")
+
+# 2) o Gargantua 2 já está instalado: nada é baixado
+j, pg, srv = abrir([GARG2, pu.MODELO_GARGANTUA_LITE])
+esperar(lambda: pg.b_continuar.isEnabled(), o_que="já instalado")
+assert puxados(srv) == [] and pg.h1.plano() == tars_i18n.t("pu.garg.titulo_ja")
+j.close()
+j, pg, srv = abrir([GARG2])
+esperar(lambda: pg.pronto and pg.b_continuar.isEnabled(), o_que="só falta o Lite")
+assert puxados(srv) == [pu.MODELO_GARGANTUA_LITE], puxados(srv)
+j.close()
+print("OK: com o Gargantua 2 e o Lite instalados, nada é baixado; sem o Lite, só ele vem")
+
+# 3) quem já tem o Gargantua 1.x continua com ele (não é obrigado a baixar o novo)
+j, pg, srv = abrir([GARG1])
+esperar(lambda: pg.pronto and pg.b_continuar.isEnabled(), o_que="Gargantua antigo")
+assert puxados(srv) == [pu.MODELO_GARGANTUA_LITE], puxados(srv)
+j.close()
+print("OK: o Gargantua 1.x instalado vale como principal; só o Lite obrigatório vem")
+
+# 4) um Cooper instalado não conta como Gargantua e nada o baixa
+j, pg, srv = abrir([COOPER])
+esperar(lambda: pg.pronto and pg.b_continuar.isEnabled(), o_que="só o Cooper")
+assert puxados(srv) == [pu.MODELO_GARGANTUA, pu.MODELO_GARGANTUA_LITE], puxados(srv)
+j.close()
+print("OK: o Cooper antigo não substitui o Gargantua, e o Gargantua 2 vem baixado")
+
+# 4b) 25/10: os modelinhos de foto entram na fila depois dos modelos (obrigatórios); aqui de mentira
+import tars_modelinhos  # noqa: E402
+os.environ.pop("TARS_SEM_MODELINHOS", None)
+originais = tars_modelinhos.faltando, tars_modelinhos.baixar_todos
+baixados = []
+tars_modelinhos.faltando = lambda: [] if baixados else ["fundo"]
+tars_modelinhos.bytes_faltando = lambda: 300_000_000
+tars_modelinhos.baixar_todos = lambda ao_progredir=None, cancelado=None: (ao_progredir(1, 1), baixados.append(1), (True, ""))[2]
+j, pg, srv = abrir([GARG2, pu.MODELO_GARGANTUA_LITE])
+esperar(lambda: pg.pronto and pg.b_continuar.isEnabled(), o_que="modelinhos")
+assert baixados == [1] and puxados(srv) == [], (baixados, puxados(srv))
+j.close()
+tars_modelinhos.faltando, tars_modelinhos.baixar_todos = originais
+os.environ["TARS_SEM_MODELINHOS"] = "1"
+print("OK: os modelinhos de foto entram na fila do primeiro uso, mesmo com os modelos já instalados")
+
+# 5) espaço: o Gargantua 2 precisa de ~1,7 GB, e o aviso aparece quando falta
+real = pu.espaco_livre_gb
+pu.espaco_livre_gb = lambda caminho=None: 1.0
+j, pg, srv = abrir([])
+esperar(lambda: pg.baixando or pg.pronto or pg.b_continuar.isEnabled(), o_que="pouco espaço")
+assert "1.0" in pg.l_espaco.texto.plano(), pg.l_espaco.texto.plano()
+pu.espaco_livre_gb = real
+j.close()
+print("OK: pouco espaço avisa")
+
+print("\nTUDO OK.")

app/tests/test_qt_primeiro_uso_sistema.py

@@ -0,0 +1,75 @@
+"""5.2 (F3.5): o passo "Permissões e atalho" do primeiro uso. No macOS mostra Acessibilidade e Gravação de Tela com o
+estado de cada uma e o botão que abre os Ajustes; no Windows, o atalho das ações e o iniciar com o sistema; no Linux o
+passo não existe. As funções do sistema são de mentira aqui (as de verdade estão em tars_plataforma/macos.py)."""
+import importlib
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _util import RAIZ  # noqa: E402,F401
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+from PySide6.QtWidgets import QApplication  # noqa: E402
+
+import tars_plataforma as plataforma  # noqa: E402
+import tars_assistente  # noqa: E402
+import tars_atalho  # noqa: E402
+from tars_qt import primeiro_uso  # noqa: E402
+
+app = QApplication.instance() or QApplication([])
+original = plataforma.sistema, plataforma.permissoes, plataforma.pedir_permissao
+estado, pedidos = {"acessibilidade": True, "tela": False}, []
+try:
+    plataforma.sistema = lambda: "macos"
+    plataforma.permissoes = lambda: dict(estado)
+    plataforma.pedir_permissao = pedidos.append
+    pu = importlib.reload(primeiro_uso)
+    assert pu.PASSOS[-1] == "sistema" and pu.DEPOIS_DO_TESTE == "sistema"
+    jan = pu.JanelaPrimeiroUso()
+    jan.ir("sistema")
+    pag = jan.paginas["sistema"]
+    assert pag.pedidos["acessibilidade"].text() == pu.t("pu.sist.concedida") and not pag.pedidos["acessibilidade"].isEnabled()
+    assert pag.pedidos["tela"].isEnabled()
+    pag.pedidos["tela"].click()
+    assert pedidos == ["tela"], pedidos
+    estado["tela"] = True          # a pessoa concedeu em Ajustes e voltou: o relógio da página atualiza
+    pag.atualizar()
+    assert pag.pedidos["tela"].text() == pu.t("pu.sist.concedida")
+    jan.paginas["teste"].b_continuar.setEnabled(True)
+    jan.paginas["teste"].b_continuar.click()
+    assert jan.atual == "sistema"
+    print("OK: macOS: Acessibilidade e Gravação de Tela com o estado, o botão pede a permissão e a lista se atualiza")
+    jan.close()
+
+    plataforma.sistema = lambda: "windows"
+    inicio, registrado = {"ligado": False}, []
+    originais_win = tars_assistente.inicia_com_sistema, tars_assistente.iniciar_com_sistema, tars_atalho.registrar_acoes
+    tars_assistente.inicia_com_sistema = lambda: inicio["ligado"]
+    tars_assistente.iniciar_com_sistema = lambda v: inicio.update(ligado=v) or v
+    tars_atalho.registrar_acoes = lambda: registrado.append(1) or (True, "")
+    try:
+        pu = importlib.reload(primeiro_uso)
+        jan = pu.JanelaPrimeiroUso()
+        jan.ir("sistema")
+        pag = jan.paginas["sistema"]
+        assert pag.b_inicio.text() == pu.t("pu.sist.desligado")
+        pag.b_inicio.click()
+        assert inicio["ligado"] and pag.b_inicio.text() == pu.t("pu.sist.ligado")
+        pag.b_atalho.click()
+        assert registrado and pag.b_atalho.text() == pu.t("pu.sist.ligado")
+        print("OK: Windows: o atalho Ctrl+Alt+R e o iniciar com o sistema ligam pelo passo (desligados por padrão)")
+        jan.close()
+    finally:
+        tars_assistente.inicia_com_sistema, tars_assistente.iniciar_com_sistema, tars_atalho.registrar_acoes = originais_win
+
+    plataforma.sistema = lambda: "linux"
+    pu = importlib.reload(primeiro_uso)
+    assert "sistema" not in pu.PASSOS and pu.DEPOIS_DO_TESTE == "pronto"
+    jan = pu.JanelaPrimeiroUso()
+    assert "sistema" not in jan.paginas
+    print("OK: Linux: o passo não existe e o teste leva direto ao pronto")
+    jan.close()
+finally:
+    plataforma.sistema, plataforma.permissoes, plataforma.pedir_permissao = original
+    importlib.reload(primeiro_uso)
+print("test_qt_primeiro_uso_sistema: TUDO OK.")

app/tests/test_qt_principal.py

@@ -0,0 +1,317 @@
+"""5.0 Tesseract: a janela principal em Qt, de ponta a ponta, sem tela (offscreen), com o núcleo de verdade
+contra um Ollama de mentira."""
+
+import json
+import os
+import stat
+import sys
+import tempfile
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+os.environ["TARS_ARQUIVO_NUVEM"] = os.path.join(CASA, "nuvem.json")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(CASA, "primeiro_uso.json")
+
+from _util import RAIZ  # noqa: E402,F401
+
+try:
+    from PySide6.QtTest import QTest
+    from PySide6.QtWidgets import QApplication, QLabel, QPushButton
+except ImportError:
+    print("test_qt_principal: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+chats = []
+
+
+class Falso(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def _json(self, dados, codigo=200):
+        corpo = json.dumps(dados).encode()
+        self.send_response(codigo)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(corpo)))
+        self.end_headers()
+        self.wfile.write(corpo)
+
+    def do_GET(self):
+        if self.path == "/api/version":
+            return self._json({"version": "0.12.9"})
+        if self.path == "/api/tags":
+            return self._json({"models": [{"name": "qwen3:4b", "model": "qwen3:4b", "size": 3_000_000_000, "details": {
+                "family": "qwen3", "parameter_size": "4.0B", "quantization_level": "Q4_K_M"}}]})
+        if self.path == "/api/ps":
+            return self._json({"models": []})
+        self._json({}, 404)
+
+    def do_POST(self):
+        corpo = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
+        if self.path == "/api/show":
+            return self._json({"capabilities": ["completion", "tools"], "details": {
+                "family": "qwen3", "parameter_size": "4.0B", "quantization_level": "Q4_K_M"}, "model_info": {}, "parameters": ""})
+        if self.path == "/api/generate":
+            return self._json({"model": corpo.get("model"), "done": True, "response": ""})
+        if self.path == "/api/chat":
+            chats.append(corpo)
+            linhas = [{"model": "qwen3:4b", "message": {"role": "assistant", "content": "Pronto, **feito**."}, "done": False},
+                      {"model": "qwen3:4b", "message": {"role": "assistant", "content": ""}, "done": True, "done_reason": "stop"}]
+            dados = ("\n".join(json.dumps(l) for l in linhas) + "\n").encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/x-ndjson")
+            self.send_header("Content-Length", str(len(dados)))
+            self.end_headers()
+            self.wfile.write(dados)
+            return
+        self._json({}, 404)
+
+
+servidor = ThreadingHTTPServer(("127.0.0.1", 0), Falso)
+threading.Thread(target=servidor.serve_forever, daemon=True).start()
+os.environ["OLLAMA_HOST"] = f"127.0.0.1:{servidor.server_address[1]}"
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+tars.avisos_de_ambiente = lambda: []
+tars.detectar_gpu = lambda forcar=False: None
+tars.escolher_modelo = lambda texto, tarefa=None, complexa=False: tars.modelo_manual or "qwen3:4b"
+tars.aquecer_ajudante = lambda: None
+
+import tars_historico  # noqa: E402
+import tars_i18n  # noqa: E402
+import tars_primeiro_uso as pu  # noqa: E402
+from tars_i18n import t  # noqa: E402
+from tars_qt.primeiro_uso import criar_aplicativo  # noqa: E402
+from tars_qt.principal import JanelaPrincipal  # noqa: E402
+from tars_qt.conversa import CartaoAprovacao, MensagemIA  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+SAIDA = os.environ.get("TARS_CAPTURAS")
+
+
+def esperar(cond, segundos=15, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if cond():
+            return
+        QTest.qWait(20)
+    import faulthandler
+    faulthandler.dump_traceback(all_threads=True)     # onde cada thread parou (no CI do Windows e do macOS, a única pista)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+def foto(j, nome):
+    if SAIDA:
+        QTest.qWait(500)
+        j.grab().save(os.path.join(SAIDA, nome + ".png"))
+
+
+def textos(widget):
+    return [l.text() for l in widget.findChildren(QLabel)]
+
+
+def mensagens_ia(j):
+    return j.area.findChildren(MensagemIA)
+
+
+historico = tars_historico.Historico(os.path.join(CASA, "historico.json"))
+j = JanelaPrincipal(tars, historico=historico, capturar_stdout=False)
+j.resize(1200, 780)
+j.show()
+esperar(lambda: j._modelos, o_que="modelos carregados")
+assert j.pilha.currentIndex() == 0 and j.vazio is not None, "começa no estado vazio"
+assert j.cabecalho.pilula.text() == t("jp.modelo_auto"), j.cabecalho.pilula.text()
+assert not j.cabecalho.b_parar.isVisibleTo(j), "Parar só aparece trabalhando"
+assert j.lateral.v_titulo.text() == "" and not j.lateral.cartao_versao.isVisibleTo(j)
+foto(j, "principal_vazio")
+print("OK: abre no estado vazio, modelo automático, sem botão Parar")
+
+# --- enviar um pedido de verdade --------------------------------------------------------------
+j.compositor.entrada.setPlainText("abra o navegador")
+j.compositor.b_enviar.click()
+assert j.vazio is None and j.ponte.esta_ocupado
+assert j.cabecalho.b_parar.isVisibleTo(j), "Parar aparece enquanto trabalha"
+esperar(lambda: not j.ponte.esta_ocupado and mensagens_ia(j) and "feito" in mensagens_ia(j)[-1].texto_completo(), o_que="resposta")
+esperar(lambda: not j.cabecalho.b_parar.isVisibleTo(j))
+assert j.compositor.texto() == "", "a entrada esvazia ao enviar"
+assert j.cabecalho.titulo.text() == "abra o navegador", j.cabecalho.titulo.text()
+assert any("abra o navegador" in x for x in textos(j.area))
+esperar(lambda: len(historico.listar()) == 1, o_que="histórico gravado")
+assert historico.listar()[0]["titulo"] == "abra o navegador"
+esperar(lambda: j.lateral._itens, o_que="conversa na barra lateral")
+foto(j, "principal_conversa")
+print("OK: pedido de ponta a ponta (bolha da pessoa, resposta em streaming, título, histórico)")
+
+# --- etapas, ferramentas e aviso (o que o núcleo emite) --------------------------------------------
+j.ponte.evento.emit("plano", {"etapas": ["Abrir o editor", "Escrever o texto", "Salvar"]})
+ia = mensagens_ia(j)[-1] if mensagens_ia(j) else None
+j._ia = None
+j._ao_evento("plano", {"etapas": ["Abrir o editor", "Escrever o texto", "Salvar"]})
+ia = j._ia
+assert ia.etapas is not None and ia.etapas.total() == 3 and ia.etapas.feitas == 0
+j._ao_evento("ferramenta", {"nome": "open_application", "resumo": "gedit"})
+j._ao_evento("ferramenta_fim", {"nome": "open_application", "sucesso": True, "segundos": 0.4})
+assert ia.etapas.feitas == 1, ia.etapas.feitas
+j._ao_evento("ferramenta", {"nome": "take_screenshot", "resumo": ""})
+j._ao_evento("ferramenta_fim", {"nome": "take_screenshot", "sucesso": True, "segundos": 0.1})
+assert ia.etapas.feitas == 1, "olhar a tela não conclui etapa"
+assert t("jp.etapa_de", atual=2, total=3) == j.cabecalho.sub.text(), j.cabecalho.sub.text()
+j._ao_texto("[openTARS] ✗ falhou algo\n")
+assert any("falhou algo" in x for x in textos(ia))
+j._ao_concluido("ok")
+assert ia.etapas.feitas == 3, "ao concluir, as etapas fecham"
+assert j.cabecalho.sub.text() == t("jp.pronto")
+print("OK: etapas avançam por ação concluída, fecham no fim; avisos viram linhas")
+
+# --- pergunta antes de ação arriscada ---------------------------------------------------------------
+resultado = {}
+j._ia = None
+j.ponte.esta_ocupado = False
+threading.Thread(target=lambda: resultado.setdefault("a", tars.confirmar_comando_hook("rm -rf ~/teste")), daemon=True).start()
+esperar(lambda: j.area.findChildren(CartaoAprovacao), o_que="cartão de aprovação")
+cartao = j.area.findChildren(CartaoAprovacao)[-1]
+assert j.cabecalho.sub.text() == t("jp.espera_voce")
+botoes = {b.text(): b for b in cartao.findChildren(QPushButton)}
+foto(j, "principal_aprovacao")
+botoes[t("jp.negar")].click()
+esperar(lambda: "a" in resultado)
+assert resultado["a"] is False
+resultado.clear()
+threading.Thread(target=lambda: resultado.setdefault("a", tars.confirmar_comando_hook("sudo apt remove x")), daemon=True).start()
+esperar(lambda: len(j.area.findChildren(CartaoAprovacao)) == 2)
+{b.text(): b for b in j.area.findChildren(CartaoAprovacao)[-1].findChildren(QPushButton)}[t("jp.permitir")].click()
+esperar(lambda: "a" in resultado)
+assert resultado["a"] is True
+print("OK: ação arriscada pergunta no cartão; Negar e Permitir chegam ao núcleo")
+
+# --- nova conversa, histórico, busca ---------------------------------------------------------------
+primeiro_id = j.ponte.id_conversa
+j.nova_conversa()
+assert j.vazio is not None and j.ponte.id_conversa != primeiro_id
+assert len(tars.conversa) == 1, "o núcleo recomeçou do zero"
+j.compositor.entrada.setPlainText("segundo assunto")
+j.enviar()
+esperar(lambda: not j.ponte.esta_ocupado and len(historico.listar()) == 2, o_que="2 conversas")
+j.abrir_conversa(primeiro_id)
+assert j.cabecalho.titulo.text() == "abra o navegador"
+assert any("abra o navegador" in x for x in textos(j.area)) and not any("segundo assunto" in x for x in textos(j.area))
+assert any(m["role"] == "user" and "abra o navegador" in m["content"] for m in tars.conversa), "o contexto voltou pra IA"
+j.lateral.busca.setText("segundo")
+esperar(lambda: len(j.lateral._itens) == 1)
+j.lateral.busca.setText("zzzz")
+esperar(lambda: not j.lateral._itens)
+assert any(t("jp.nenhum_resultado") in x for x in textos(j.lateral))
+j.lateral.busca.setText("")
+esperar(lambda: len(j.lateral._itens) == 2)
+j._apagar_conversa(primeiro_id)
+esperar(lambda: len(historico.listar()) == 1)
+print("OK: nova conversa, abrir devolve o contexto, busca e apagar")
+
+# --- modelo -----------------------------------------------------------------------------------------
+j._escolher_modelo("qwen3:4b")
+assert tars.modo_modelo == "MANUAL" and "qwen3:4b" in j.cabecalho.pilula.text()
+j._escolher_modelo(None)
+assert tars.modo_modelo == "AUTO" and j.cabecalho.pilula.text() == t("jp.modelo_auto")
+print("OK: escolher o modelo na pílula e voltar ao automático")
+
+# --- anexos ---------------------------------------------------------------------------------------------
+pasta = Path(tempfile.mkdtemp(prefix="opentars-anx-"))
+(pasta / "nota.txt").write_text("conteudo do arquivo de teste\n" * 5, encoding="utf-8")
+novos = j.anexar_arquivos([str(pasta / "nota.txt")])
+assert len(novos) == 1 and j.compositor.chips_w.isVisibleTo(j) and len(j.compositor.anexos()) == 1
+chats.clear()
+j.compositor.entrada.setPlainText("leia a nota")
+j.enviar()
+esperar(lambda: not j.ponte.esta_ocupado and chats, o_que="anexo enviado")
+pedidos = [m["content"] for m in chats[0]["messages"] if m["role"] == "user"]
+assert any("conteudo do arquivo de teste" in c and c.startswith("leia a nota") for c in pedidos), pedidos
+assert not j.compositor.anexos() and not j.compositor.chips_w.isVisibleTo(j)
+print("OK: anexo chega ao Ollama e o chip some")
+
+# --- voz sem estar instalada abre a configuração de voz ---------------------------------------------------
+j.voz.pronta = lambda: False
+j.voz.faltando = lambda: ["faster-whisper"]
+j._mudar_modo_voz("continua")
+j._mic_clicado()
+assert j.pilha.currentWidget() is j.config and j.config.nav["voz"].isChecked()
+foto(j, "config_voz")
+j.pilha.setCurrentIndex(0)
+j._mudar_modo_voz("segurar")
+print("OK: microfone sem voz instalada leva à página Voz")
+
+# --- tela de voz --------------------------------------------------------------------------------------------
+j.pilha.setCurrentIndex(1)
+j.tela_voz.ao_estado("ouvindo")
+foto(j, "tela_voz")
+j._sair_da_voz()
+assert j.pilha.currentIndex() == 0
+
+# --- configurações --------------------------------------------------------------------------------------------
+for nome in ("geral", "voz", "memoria", "nuvem", "atualizacoes", "sobre"):
+    j.abrir_config(nome)
+    app.processEvents()
+    assert j.config.nav[nome].isChecked() and j.pilha.currentIndex() == 2
+    foto(j, f"config_{nome}")
+esperar(lambda: "Ollama" in j.config.paginas["geral"].estado.text() and "…" != j.config.paginas["geral"].estado.text(), o_que="estado do Ollama")
+assert t("cfg.gargantua_falta") in j.config.paginas["geral"].estado.text()
+
+# memória
+tars.memoria.lembrar("meu navegador é o firefox")
+j.abrir_config("memoria")
+pm = j.config.paginas["memoria"]
+assert any("firefox" in x for x in textos(pm))
+pm._esquecer("meu navegador é o firefox")
+assert tars.memoria.listar() == [] and any(t("cfg.memoria.vazia") in x for x in textos(pm))
+tars.memoria.lembrar("x")
+pm.b_geral.click()
+assert "x" in tars.memoria.listar(), "apagar tudo pede confirmação (duas batidas)"
+pm.b_geral.click()
+assert tars.memoria.listar() == [] and historico.listar() == []
+print("OK: memória listada, esquecida item a item; apagar tudo pede confirmação")
+
+# nuvem: a chave fica em arquivo 0600 e nunca aparece na tela
+j.abrir_config("nuvem")
+pn = j.config.paginas["nuvem"]
+pn.chips["groq"].click()
+assert pn.endereco.text() == "https://api.groq.com/openai/v1"
+pn.ativa.setChecked(True)
+pn.chave.setText("SEGREDO-123")
+pn._salvar()
+d = pu.carregar_nuvem()
+assert d["ativa"] and d["provedor"] == "groq" and d["chave"] == "SEGREDO-123"
+assert os.name == "nt" or stat.S_IMODE(os.stat(pu.arquivo_nuvem()).st_mode) == 0o600
+assert pn.chave.text() == "" and not any("SEGREDO" in x for x in textos(pn))
+j.abrir_config("nuvem")
+assert "SEGREDO" not in pn.chave.placeholderText()
+print("OK: nuvem salva a chave em 0600 e nunca a mostra")
+
+# idioma: trocar pede pra reconstruir a janela
+j.abrir_config("geral")
+assert not getattr(j, "reconstruir", False)
+j.config.paginas["geral"]._trocar(tars_i18n.idioma_atual())
+assert not getattr(j, "reconstruir", False), "o mesmo idioma não reconstrói"
+
+j.close()
+print("test_qt_principal: OK")
+
+# 26/10: o openTARS abre com o computador antes do Ollama: o aviso "não responde" some sozinho quando ele volta
+j_fora = JanelaPrincipal(tars, historico=historico, capturar_stdout=False)
+j_fora.show()
+esperar(lambda: j_fora._modelos is not None, o_que="início")
+j_fora._ao_iniciado({"online": False, "avisos": [], "n_modelos": 0})
+assert j_fora._avisos_iniciais and j_fora._vigia_ollama.isActive()
+chamadas = []
+j_fora._procurar_atualizacao = lambda: chamadas.append(1)
+j_fora.ponte.reconectado.emit()
+assert not j_fora._vigia_ollama.isActive() and not j_fora._avisos_iniciais and chamadas == [1]
+j_fora.close()
+print("OK: o aviso de Ollama fora some sozinho quando ele volta (o app abre antes dele ao ligar o PC)")

app/tests/test_qt_probes.py

@@ -0,0 +1,187 @@
+"""5.1: a tela dos Probes na janela de verdade (offscreen), sem Ollama. O passo a passo cria um Probe de pasta com regra
+fixa e já liga tudo (Probe e serviço); campo errado bloqueia o botão; "com as minhas palavras" passa pelo modelo de
+mentira e a prévia vem escapada; recusa e pasta proibida viram mensagem clara; o sino mostra o número de avisos, a faixa
+avisa, o painel marca como lido e resolve a lixeira; "Rodar agora" de um Probe com regra não precisa de modelo; "Parar
+tudo" desliga; o Lite esconde Probes e sino; a bandeja sobe e sai quando já há um serviço rodando."""
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+CASA = tempfile.mkdtemp(prefix="opentars-probes-qt-")
+os.environ["HOME"] = os.environ["USERPROFILE"] = CASA     # no Windows o ~ vem do USERPROFILE
+os.environ["XDG_CONFIG_HOME"] = os.path.join(CASA, ".config")
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(CASA, "primeiro_uso.json")
+os.environ["TARS_ARQUIVO_CONFIG"] = os.path.join(CASA, "config.json")
+os.environ["TARS_ARQUIVO_PROBES"] = os.path.join(CASA, "probes.json")
+
+from _util import RAIZ  # noqa: E402,F401
+
+try:
+    from PySide6.QtTest import QTest
+except ImportError:
+    print("test_qt_probes: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+import fake_ollama  # noqa: E402
+
+servidor, url = fake_ollama.subir(modelos=["ProjectOpenTARS/Gargantua:latest"])
+os.environ["OLLAMA_HOST"] = url
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+tars.avisos_de_ambiente = lambda: []
+tars.detectar_gpu = lambda forcar=False: None
+tars.aquecer_ajudante = lambda: None
+
+import tars_historico  # noqa: E402
+import tars_modos as modos  # noqa: E402
+import tars_probes as tp  # noqa: E402
+from tars_qt.primeiro_uso import criar_aplicativo  # noqa: E402
+from tars_qt.principal import JanelaPrincipal  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+
+
+def esperar(cond, segundos=15, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if cond():
+            return
+        QTest.qWait(20)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+downloads = Path(CASA) / "Downloads"
+downloads.mkdir()
+respostas = {"plano": ({"name": "Instaladores <b>", "watch": ["~/Downloads"], "look_for": ".deb", "check": {"every_minutes": 30},
+                        "tools": ["list_folder"], "alert": {"when": "aparece .deb", "max_per_day": 2}, "will_not": ["apagar"]}, None)}
+tp.planejar = lambda missao, host, instalados: tp.validar_plano(respostas["plano"][0]) if respostas["plano"][1] is None \
+    else (None, respostas["plano"][1])
+servico = {"ligado": False}
+tp.ligar_servico = lambda ligado, iniciar=True: servico.update(ligado=ligado) or ligado
+tp.servico_ligado = lambda: servico["ligado"]
+tp.servico_rodando = lambda: 4242 if servico["ligado"] else None
+
+modos.definir_modo("base")
+j = JanelaPrincipal(tars, historico=tars_historico.Historico(os.path.join(CASA, "historico.json")), capturar_stdout=False)
+j.resize(1200, 780)
+j.show()
+assert not j.lateral.b_probes.isHidden() and not j.cabecalho.sino.isHidden(), "Base tem Probes e o sino"
+j.lateral.b_probes.click()
+cfg = j.config
+pg = cfg.paginas["probes"]
+assert cfg.pilha.currentWidget() is pg
+assert "desligad" in pg.estado.text().lower() or "off" in pg.estado.text().lower()
+
+# 1) passo a passo: pasta, com filtro; criar já liga o Probe e o serviço
+pg.blocos["pasta"].click()
+assert pg.passo2.isVisibleTo(cfg) and pg.acoes.isVisibleTo(cfg)
+pg.f["pasta"].setText(str(downloads))
+pg.f["filtro"].setText(".deb")
+assert ".deb" in pg.resumo.text() and pg.b_criar.isEnabled(), pg.resumo.text()
+pg.b_criar.click()
+p = tp.Probes().listar()[0]
+assert p["ativo"] and p["regra"] == {"tipo": "arquivos", "filtro": [".deb"]} and servico["ligado"], p
+assert not pg.passo2.isVisibleTo(cfg) and pg.lista.count() == 1
+print("OK: o passo a passo cria o Probe de pasta com regra fixa e liga o Probe e o serviço de uma vez")
+
+# 2) campo errado bloqueia; sistema e programa montam a frase
+pg.blocos["web"].click()
+pg.f["url"].setText("exemplo")
+assert not pg.b_criar.isEnabled() and "https://" in pg.resumo.text()
+pg.blocos["sistema"].click()
+pg.f["condicao"].setCurrentIndex(tp.CONDICOES_DO_SISTEMA.index("internet"))
+assert pg.b_criar.isEnabled() and not pg.campo_limite_sis.isVisibleTo(cfg)
+pg.blocos["programa"].click()
+assert not pg.b_criar.isEnabled()
+pg.f["programa"].setText("steam")
+assert pg.b_criar.isEnabled() and "steam" in pg.resumo.text()
+print("OK: campo errado bloqueia o botão; a frase do que ele vai fazer acompanha os campos")
+
+# 3) com as minhas palavras: o modelo planeja, a prévia vem escapada
+pg.blocos["palavras"].click()
+assert not pg.b_criar.isEnabled()
+pg.missao.setPlainText("fica de olho nos Downloads e me avisa quando aparecer um .deb")
+pg._entender()
+esperar(lambda: pg.b_criar.isEnabled(), o_que="plano do modelo")
+assert "&lt;b&gt;" in pg.resumo.text() and "Instaladores <b>" not in pg.resumo.text(), "o plano vem escapado"
+pg.c_lixeira.setChecked(True)
+pg.b_criar.click()
+pl = [x for x in tp.Probes().listar() if x["id"] != p["id"]][0]
+assert pl["ativo"] and pl["regra"] is None and pl["acoes"]["lixeira"] and pl["plano"]["alert"]["max_per_day"] == 2
+respostas["plano"] = ({}, "recusa:Probe não apaga arquivos")
+pg.blocos["palavras"].click()
+pg.missao.setPlainText("apaga os .tmp toda noite")
+pg._entender()
+esperar(lambda: "recusada" in pg.msg.text(), o_que="recusa")
+respostas["plano"] = ({"watch": ["~/.ssh"], "tools": ["read_file"]}, None)
+pg.missao.setPlainText("lê minhas chaves ssh")
+pg._entender()
+esperar(lambda: ".ssh" in pg.msg.text(), o_que="pasta proibida")
+print("OK: com as minhas palavras passa pelo modelo (prévia escapada); recusa e pasta proibida viram mensagem clara")
+
+# 4) o sino: número, faixa, painel que marca como lido e resolve a lixeira
+sino = j.cabecalho.sino
+sino.olhar()
+ps = tp.Probes()
+ps.registrar(p["id"], {"alertar": True, "mensagem": "1 arquivo novo: app.deb ★ 新しい", "itens": ["/tmp/x★.deb"], "estado": {}})
+(downloads / "velho.deb").write_bytes(b"x")
+ps.aplicar_acoes(pl["id"], [str(downloads / "velho.deb")])
+assert ps.nao_lidos() == 2
+sino.olhar()
+assert not j.faixa.isHidden() and "app.deb" in j.faixa.texto.text(), "aviso novo aparece na faixa"
+sino.click()
+painel = sino.painel
+assert painel.isVisible() and ps.nao_lidos() == 1, "abrir o painel marca os avisos como lidos (a lixeira continua)"
+lixo = []
+tp.mandar_para_lixeira = lambda c: lixo.append(c) or (True, "")
+pend = ps.pendentes()[0]
+painel._resolver(pend[0]["id"], pend[1]["id"], True)
+assert lixo == [str(downloads / "velho.deb")] and ps.nao_lidos() == 0
+# glifos: tudo que a página e o painel mostram tem que existir na IBM Plex (senão o fontconfig dá segfault em algumas
+# máquinas: foi o que derrubou a janela ao abrir os Probes na 2026101603, com o "•" do estado)
+from PySide6.QtGui import QRawFont  # noqa: E402
+from PySide6.QtWidgets import QAbstractButton, QLabel  # noqa: E402
+fontes = [QRawFont(str(f), 15) for f in sorted((Path(RAIZ) / "tars_qt" / "fontes").glob("*.ttf"))]
+ruins = {}
+for raiz in (pg, painel, j):
+    for w in raiz.findChildren(QLabel) + raiz.findChildren(QAbstractButton):
+        falta = {c for c in w.text() if ord(c) > 0x7F and not any(f.supportsCharacter(ord(c)) for f in fontes)}
+        if falta:
+            ruins[w.text()[:40]] = falta
+assert fontes and not ruins, f"glifos fora da IBM Plex: {ruins}"
+print("OK: nenhum texto da página dos Probes e do painel usa glifo fora da IBM Plex")
+painel._limpar()
+assert ps.avisos() == []
+painel.hide()
+print("OK: o sino conta avisos e pedidos, a faixa mostra o novo, o painel marca como lido, resolve a lixeira e limpa")
+
+# 5) Rodar agora de um Probe com regra: sem modelo nenhum
+pg._rodar_agora(p["id"])
+esperar(lambda: tp.Probes().obter(p["id"])["estado"].get("impressoes"), o_que="primeira olhada")
+(downloads / "outro.deb").write_bytes(b"x")
+pg._rodar_agora(p["id"])
+esperar(lambda: "outro.deb" in pg.msg.text(), o_que="rodar agora com regra")
+print("OK: Rodar agora de um Probe com regra fixa não precisa de modelo")
+
+pg._parar_tudo()
+assert not any(x["ativo"] for x in tp.Probes().listar()) and not servico["ligado"]
+cfg.paginas["geral"].chips_modo["lite"].click()
+assert j.lateral.b_probes.isHidden() and j.cabecalho.sino.isHidden() and not cfg.nav["probes"].isVisibleTo(cfg)
+print("OK: Parar tudo desliga tudo, e o Lite esconde os Probes e o sino")
+j._saindo = True
+j.close()
+
+# 6) a bandeja: ícone com selo e o laço do serviço (aqui um que já está rodando: sai com 3)
+from tars_qt import avisos  # noqa: E402
+assert not avisos.icone_com_selo(3).pixmap(32, 32).isNull()
+tp.servico = lambda *a, **k: 3
+assert avisos.rodar_bandeja("http://x", lambda: []) == 3
+print("OK: a bandeja desenha o selo e sai quando já há um serviço rodando")
+print("\nTUDO OK.")

app/tests/test_qt_rolagem.py

@@ -0,0 +1,32 @@
+"""5.2: a rolagem da conversa termina na última mensagem (antes sobravam centenas de pixels de vazio, porque o miolo
+usava o sizeHint dos textos com quebra de linha, que passa da altura real)."""
+import os
+import sys
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+from _util import RAIZ  # noqa: E402,F401
+
+from PySide6.QtTest import QTest  # noqa: E402
+
+from tars_qt import conversa as c  # noqa: E402
+from tars_qt.primeiro_uso import criar_aplicativo  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+area = c.AreaConversa()
+area.resize(900, 600)
+area.show()
+for i in range(6):
+    area.adicionar_pessoa(f"pergunta {i}")
+    m = area.adicionar_ia()
+    m.acrescentar_texto("resposta **x** " * 80)
+    m.fim_do_trecho()
+QTest.qWait(500)
+ultimo = area.itens[-1]
+fundo = ultimo.mapTo(area.widget(), ultimo.rect().bottomLeft()).y()
+sobra = area.widget().height() - fundo
+assert area.verticalScrollBar().maximum() > 0 and sobra <= 40, sobra
+area.resize(700, 400)
+QTest.qWait(500)
+fundo = ultimo.mapTo(area.widget(), ultimo.rect().bottomLeft()).y()
+assert area.widget().height() - fundo <= 40, area.widget().height() - fundo
+print("OK: a rolagem termina na última mensagem, também depois de mudar o tamanho da janela")

app/tests/test_qt_rotinas.py

@@ -0,0 +1,256 @@
+"""5.0 Tesseract: rotinas agendadas na janela Qt (timer, execução, avisos, pré-aprovação, bandeja), com o núcleo
+de verdade contra um Ollama de mentira e um relógio controlado."""
+
+import json
+import os
+import stat
+import sys
+import tempfile
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+os.environ["TARS_ARQUIVO_AGENDA"] = os.path.join(CASA, "agenda.json")
+os.environ["TARS_ARQUIVO_NUVEM"] = os.path.join(CASA, "nuvem.json")
+os.environ["TARS_ARQUIVO_PRIMEIRO_USO"] = os.path.join(CASA, "primeiro_uso.json")
+
+from _util import RAIZ  # noqa: E402,F401
+
+try:
+    from PySide6.QtTest import QTest
+    from PySide6.QtWidgets import QApplication, QLabel, QPushButton
+except ImportError:
+    print("test_qt_rotinas: PULADO (PySide6 não instalado)")
+    sys.exit(0)
+
+chats = []
+
+
+class Falso(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def _json(self, dados, codigo=200):
+        corpo = json.dumps(dados).encode()
+        self.send_response(codigo)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(corpo)))
+        self.end_headers()
+        self.wfile.write(corpo)
+
+    def do_GET(self):
+        if self.path == "/api/version":
+            return self._json({"version": "0.12.9"})
+        if self.path == "/api/tags":
+            return self._json({"models": [{"name": "qwen3:4b", "model": "qwen3:4b", "size": 3_000_000_000, "details": {
+                "family": "qwen3", "parameter_size": "4.0B", "quantization_level": "Q4_K_M"}}]})
+        if self.path == "/api/ps":
+            return self._json({"models": []})
+        self._json({}, 404)
+
+    def do_POST(self):
+        corpo = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
+        if self.path == "/api/show":
+            return self._json({"capabilities": ["completion", "tools"], "details": {
+                "family": "qwen3", "parameter_size": "4.0B", "quantization_level": "Q4_K_M"}, "model_info": {}, "parameters": ""})
+        if self.path == "/api/generate":
+            return self._json({"model": corpo.get("model"), "done": True, "response": ""})
+        if self.path == "/api/chat":
+            chats.append(corpo)
+            linhas = [{"model": "qwen3:4b", "message": {"role": "assistant", "content": "Pronto, **feito**."}, "done": False},
+                      {"model": "qwen3:4b", "message": {"role": "assistant", "content": ""}, "done": True, "done_reason": "stop"}]
+            dados = ("\n".join(json.dumps(l) for l in linhas) + "\n").encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/x-ndjson")
+            self.send_header("Content-Length", str(len(dados)))
+            self.end_headers()
+            self.wfile.write(dados)
+            return
+        self._json({}, 404)
+
+
+servidor = ThreadingHTTPServer(("127.0.0.1", 0), Falso)
+threading.Thread(target=servidor.serve_forever, daemon=True).start()
+os.environ["OLLAMA_HOST"] = f"127.0.0.1:{servidor.server_address[1]}"
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+tars.avisos_de_ambiente = lambda: []
+tars.detectar_gpu = lambda forcar=False: None
+tars.escolher_modelo = lambda texto, tarefa=None, complexa=False: tars.modelo_manual or "qwen3:4b"
+tars.aquecer_ajudante = lambda: None
+
+import tars_historico  # noqa: E402
+import tars_i18n  # noqa: E402
+import tars_primeiro_uso as pu  # noqa: E402
+from tars_i18n import t  # noqa: E402
+from tars_qt.primeiro_uso import criar_aplicativo  # noqa: E402
+from tars_qt.principal import JanelaPrincipal  # noqa: E402
+from tars_qt.conversa import CartaoAprovacao, MensagemIA  # noqa: E402
+
+app = criar_aplicativo(["teste"])
+SAIDA = os.environ.get("TARS_CAPTURAS")
+
+
+def esperar(cond, segundos=15, o_que=""):
+    fim = time.time() + segundos
+    while time.time() < fim:
+        app.processEvents()
+        if cond():
+            return
+        QTest.qWait(20)
+    raise AssertionError(f"tempo esgotado: {o_que}")
+
+
+def foto(j, nome):
+    if SAIDA:
+        QTest.qWait(500)
+        j.grab().save(os.path.join(SAIDA, nome + ".png"))
+
+
+def textos(widget):
+    return [l.text() for l in widget.findChildren(QLabel)]
+
+
+def mensagens_ia(j):
+    return j.area.findChildren(MensagemIA)
+
+
+
+import datetime as dt  # noqa: E402
+
+import tars_rotinas as agenda_lib  # noqa: E402
+
+relogio = [dt.datetime(2026, 10, 6, 7, 59, 0)]
+tars.agenda = agenda_lib.Agenda(os.path.join(CASA, "agenda.json"), agora=lambda: relogio[0])
+historico = tars_historico.Historico(os.path.join(CASA, "historico.json"))
+j = JanelaPrincipal(tars, historico=historico, capturar_stdout=False)
+j.resize(1200, 780)
+j.show()
+esperar(lambda: j._modelos, o_que="modelos carregados")
+assert j.agenda is tars.agenda and not j.faixa.isVisibleTo(j)
+falas = []
+j.voz.falar = lambda *a, **k: falas.append(a)
+
+# --- criar pelo formulário -------------------------------------------------------------------------
+j.abrir_config("rotinas")
+pr = j.config.paginas["rotinas"]
+assert any(t("rot.vazia") in x for x in textos(pr))
+pr._abrir_form(None)
+pr.f_nome.setText("Jornal")
+pr.f_pedido.setPlainText("abra o navegador")
+pr.f_hora.setText("08:00")
+pr._salvar()
+assert [r["nome"] for r in tars.agenda.listar()] == ["Jornal"], tars.agenda.listar()
+assert any("Jornal" in x for x in textos(pr)) and not pr.form.isVisibleTo(pr)
+pr._abrir_form(None)
+pr.f_nome.setText("")
+pr._salvar()
+assert pr.erro.isVisibleTo(pr) and pr.erro.text() == t("rot.erro_nome"), pr.erro.text()
+pr.form.hide()
+foto(j, "rotinas_lista")
+print("OK: criar rotina pelo formulário; erro de validação aparece")
+
+# --- na hora: roda sozinha, em conversa própria, sem falar --------------------------------------------
+j._tick_agenda()
+assert j._rotina_em_curso is None, "ainda não é 08:00"
+relogio[0] = dt.datetime(2026, 10, 6, 8, 1, 0)
+j.abrir_config("geral")
+j._tick_agenda()
+assert j._rotina_em_curso is not None and tars.ROTINA_ATUAL["nome"] == "Jornal"
+assert j.pilha.currentIndex() == 0 and j.cabecalho.titulo.text() == t("rot.titulo_conversa", nome="Jornal")
+esperar(lambda: j._rotina_em_curso is None and not j.ponte.esta_ocupado, o_que="rotina terminou")
+assert tars.ROTINA_ATUAL is None
+u = tars.agenda.listar()[0]
+assert u["ultima"]["resultado"] == "ok" and u["proxima"].startswith("2026-10-07T08:00"), u
+assert j.faixa.isVisibleTo(j) and j.faixa.texto.text() == t("rot.aviso_ok", nome="Jornal")
+assert any("abra o navegador" in str(m) for m in chats[-1]["messages"])
+assert falas == [], "rotina não fala em voz alta"
+esperar(lambda: any(c["titulo"] == t("rot.titulo_conversa", nome="Jornal") for c in historico.listar()), o_que="título no histórico")
+print("OK: rotina roda na hora, em conversa própria (↻), anota resultado, agenda a próxima, avisa e não fala")
+
+# --- parou: precisava de permissão ---------------------------------------------------------------------------
+tars.agenda.criar("Limpa", "apague a pasta velha", {"tipo": "diaria", "hora": "09:00"})
+relogio[0] = dt.datetime(2026, 10, 6, 9, 0, 30)
+j._tick_agenda()
+assert j._rotina_em_curso["nome"] == "Limpa"
+tars.ROTINA_BLOQUEOU.append("rm -rf ~/velha")       # o que o hook anotaria ao negar o comando
+esperar(lambda: j._rotina_em_curso is None and not j.ponte.esta_ocupado, o_que="rotina parou")
+u = tars.agenda.achar_por_nome("Limpa")["ultima"]
+assert u["resultado"] == "parou" and "rm -rf" in u["detalhe"], u
+assert "rm -rf" in j.faixa.texto.text() and tars.ROTINA_BLOQUEOU == []
+print("OK: rotina que precisa de permissão para e avisa o comando")
+
+# --- computador desligado: pulada, e avisa -------------------------------------------------------------------------
+tars.agenda.criar("Tarde", "faça o backup", {"tipo": "diaria", "hora": "10:00"})
+relogio[0] = dt.datetime(2026, 10, 6, 10, 30, 0)
+j._tick_agenda()
+assert j._rotina_em_curso is None
+assert t("rot.aviso_perdida", nome="Tarde", hora="10:00") == j.faixa.texto.text(), j.faixa.texto.text()
+assert tars.agenda.achar_por_nome("Tarde")["ultima"]["resultado"] == "perdida"
+print("OK: rotina vencida há mais de 10 min é pulada e a pessoa é avisada")
+
+# --- ocupado: espera ---------------------------------------------------------------------------------------------------
+tars.agenda.criar("Espera", "abra o navegador", {"tipo": "diaria", "hora": "10:40"})
+relogio[0] = dt.datetime(2026, 10, 6, 10, 41, 0)
+j.compositor.entrada.setPlainText("oi")
+j.compositor.b_enviar.click()
+j._tick_agenda()
+assert j._rotina_em_curso is None, "ocupado: não atropela a conversa"
+esperar(lambda: not j.ponte.esta_ocupado, o_que="conversa normal terminou")
+j._tick_agenda()
+assert j._rotina_em_curso is not None and j._rotina_em_curso["nome"] == "Espera"
+esperar(lambda: j._rotina_em_curso is None and not j.ponte.esta_ocupado)
+print("OK: se o TARS está ocupado, a rotina espera a vez")
+
+# --- rodar agora: não mexe no calendário ------------------------------------------------------------------------------------
+antes = tars.agenda.achar_por_nome("Jornal")["proxima"]
+j.abrir_config("rotinas")
+j.config.rodar_rotina.emit(tars.agenda.achar_por_nome("Jornal")["id"])
+assert j._rotina_em_curso is not None
+esperar(lambda: j._rotina_em_curso is None and not j.ponte.esta_ocupado)
+r = tars.agenda.achar_por_nome("Jornal")
+assert r["proxima"] == antes and r["ultima"]["resultado"] == "ok"
+print("OK: 'Rodar agora' roda sem mexer na próxima execução")
+
+# --- criada pela IA: nasce pendente, a pessoa aprova ---------------------------------------------------------------------------
+res = tars.executar_ferramenta("schedule_task", {"name": "Da IA", "request": "abra o navegador", "when_type": "daily", "time": "18:00"})
+assert res["sucesso"]
+j._avisar_rotinas_da_ia()
+assert j.faixa.texto.text() == t("rot.aviso_ia", nome="Da IA")
+j.abrir_config("rotinas")
+assert any(t("rot.pendente") in x for x in textos(pr))
+botao = [b for b in pr.findChildren(QPushButton) if b.text() == t("rot.aprovar")]
+assert len(botao) == 1, (len(botao), [r["nome"] for r in tars.agenda.listar() if not r["aprovada"]])
+botao[0].click()
+r = tars.agenda.achar_por_nome("Da IA")
+assert r["aprovada"] and r["ativa"] and r["proxima"]
+foto(j, "rotinas_aprovada")
+print("OK: rotina criada pela IA espera aprovação e só liga depois")
+
+# --- bandeja: com rotinas ligadas, fechar esconde; 'Sair' fecha de vez -------------------------------------------------------------
+class Bandeja:
+    escondida = False
+    def isVisible(self): return not self.escondida
+    def hide(self): self.escondida = True
+    def showMessage(self, *a): pass
+    def setVisible(self, v): self.escondida = not v
+
+j._tray = Bandeja()
+j.close()
+assert j.isHidden() and not j._saindo, "fechou a janela, o openTARS continua na bandeja"
+j.show()
+for r in tars.agenda.listar():
+    tars.agenda.atualizar(r["id"], ativa=False)
+j._saindo = False
+j._relogio.stop()
+j.close()
+assert not j.isVisible()
+print("OK: com rotinas ligadas a janela vai pra bandeja; sem nenhuma, fecha de verdade")
+print("test_qt_rotinas: OK")

app/tests/test_raciocinio_sem_pedir.py

@@ -0,0 +1,67 @@
+"""Modelo que raciocina mesmo com think=false: o turno é cortado e refeito com /no_think."""
+import os as _os
+import tempfile as _tmp
+_os.environ["TARS_ARQUIVO_SESSOES"] = _os.path.join(_tmp.mkdtemp(prefix="opentars-"), "s.json")  # a lista de quem raciocina fica ao lado
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+payloads = []
+
+
+class Resp:
+    def __init__(self, linhas):
+        self.linhas, self.fechada = linhas, False
+
+    def iter_lines(self):
+        for x in self.linhas:
+            if self.fechada:
+                return
+            yield json.dumps(x).encode()
+
+    def close(self):
+        self.fechada = True
+
+
+def teimoso(payload):
+    payloads.append(payload)
+    if payload["messages"][-1]["content"].endswith("/no_think"):
+        return Resp([{"message": {"content": "feito"}}, {"done": True}]), None
+    pedacos = [{"message": {"content": "<think>"}}] + [{"message": {"content": "pensando e pensando. " * 3}} for _ in range(40)]
+    return Resp(pedacos + [{"done": True}]), None
+
+
+tars._chamar_ollama_stream = teimoso
+tars.emitir = lambda *a, **k: None
+msgs = [{"role": "system", "content": "s"}, {"role": "user", "content": "olhe a tela"}]
+res, erro = tars._executar_turno_streaming("ProjectOpenTARS/gargantua:1.0", msgs, None, pensar=False)
+assert erro is None and res["content"] == "feito", (res, erro)
+assert len(payloads) == 2 and payloads[1]["messages"][-1]["content"] == "olhe a tela\n/no_think"
+assert msgs[-1]["content"] == "olhe a tela", "o histórico guardado não muda"
+assert "ProjectOpenTARS/gargantua:1.0" in tars._PENSA_MESMO_SEM_PEDIR
+# na vez seguinte já vai com /no_think de cara (1 chamada só)
+payloads.clear()
+res, erro = tars._executar_turno_streaming("ProjectOpenTARS/gargantua:1.0", msgs, None, pensar=False)
+assert res["content"] == "feito" and len(payloads) == 1
+# quem foi pedido pra pensar não é cortado
+payloads.clear()
+tars._PENSA_MESMO_SEM_PEDIR.clear()
+tars._chamar_ollama_stream = lambda p: (payloads.append(p), (Resp([{"message": {"content": "<think>" + "x" * 2000}}, {"message": {"content": "</think>ok"}}, {"done": True}]), None))[1]
+res, erro = tars._executar_turno_streaming("qwen3:8b", msgs, None, pensar=True)
+assert len(payloads) == 1 and res["content"] == "ok"
+print("OK: raciocínio sem pedido é cortado e refeito com /no_think; quem pensa por pedido não é tocado")
+print("\nTUDO OK.")
+
+# a lista sobrevive a fechar e abrir o openTARS (fica em disco)
+tars._PENSA_MESMO_SEM_PEDIR.clear()
+tars._lembrar_que_pensa("ProjectOpenTARS/gargantua:1.0")
+tars._PENSA_MESMO_SEM_PEDIR.clear()
+tars._pensa_carregado["ok"] = False
+tars._carregar_pensa_sem_pedir()
+assert "ProjectOpenTARS/gargantua:1.0" in tars._PENSA_MESMO_SEM_PEDIR
+print("OK: quem raciocina sem pedir fica guardado em disco")

app/tests/test_recusas.py

@@ -0,0 +1,115 @@
+"""IA recusando abrir/fechar apps (log real, PC com 6GB de VRAM):
+- "ação" ia pro qwen2.5-coder, que responde "não consigo abrir aplicativos";
+- a recusa ficava no histórico e o qwen3:8b recusava também;
+- "counter strike" não achava "Counter-Strike 2";
+- pedir pra fechar o próprio openTARS."""
+
+import json
+import os
+import tempfile
+
+os.environ["TARS_ARQUIVO_SESSOES"] = tempfile.mktemp(suffix=".json")
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+
+def m(tag, p, caps, cat, v):
+    return {"tag": tag, "parametros_b": p, "categoria": cat, "vram_estimado_gb": v,
+            "capacidades": set(caps), "capacidades_conhecidas": True}
+
+
+# O catálogo do log do usuário
+catalogo = {x["tag"]: x for x in [
+    m("qwen3.8:27b", 27.3, {"thinking", "tools", "vision"}, "visao", 17.0),
+    m("mistral-small3.2:24b", 24, {"tools", "vision"}, "visao", 15.0),
+    m("gemma3:12b", 12.2, {"vision"}, "visao", 7.9),
+    m("gemma4:e4b", 8, {"thinking", "tools", "vision"}, "visao", 5.4),
+    m("qwen2.5-coder:7b", 7.6, {"tools"}, "tecnico", 5.2),
+    m("qwen3:8b", 8.2, {"thinking", "tools"}, "geral", 5.5),
+    m("qwen3:0.6b", 0.75, {"thinking", "tools"}, "simples", 1.1),
+    m("qwen2.5:0.5b", 0.49, {"tools"}, "simples", 0.9),
+    m("gemma3:270m", 0.27, set(), "simples", 0.8),
+]}
+tars.detectar_gpu = lambda forcar=False: {"vram_total_gb": 6.0, "vram_livre_gb": 5.1}
+for tarefa in ("acao", "busca"):
+    cadeia = tars.construir_cadeia_fallback(tarefa, catalogo)
+    assert cadeia[0] == "qwen3:8b" and cadeia.index("qwen2.5-coder:7b") > cadeia.index("gemma4:e4b"), cadeia
+assert tars.construir_cadeia_fallback("codigo", catalogo)[0] == "qwen2.5-coder:7b"
+for tarefa in ("acao", "busca", "visao", "tecnico", "geral", "simples"):
+    cadeia = tars.construir_cadeia_fallback(tarefa, catalogo)
+    assert cadeia[-1] == "qwen2.5-coder:7b", (tarefa, cadeia)
+assert tars.construir_cadeia_fallback("tecnico", catalogo)[0] == "qwen3:8b"
+assert tars.detectar_tarefa("abra o terminal") == "acao" and tars.detectar_tarefa("abra o vs code") == "acao"
+print("OK: modelo de código só em pedido de código (nas outras tarefas, só se todo o resto falhar)")
+
+# Nomes com hífen
+tars.desktop_entries = lambda forcar=False: [{
+    "nome": "Counter-Strike 2", "outros_nomes": [], "arquivo": "/x/cs2.desktop",
+    "exec": "steam steam://rungameid/730",
+}]
+tars.flatpak_apps = lambda forcar=False: []
+tars.comando_para_desktop_entry = lambda arq, ex: ["steam", "steam://rungameid/730"]
+tars.shutil.which = lambda n: None
+achado = tars._buscar_app_no_sistema("counter strike")
+assert achado and achado["nome"] == "Counter-Strike 2", achado
+print("OK: 'counter strike' acha 'Counter-Strike 2'")
+import shutil  # noqa: E402
+tars.shutil.which = shutil.which
+
+r = tars.fechar_aplicativo("openTARS")
+assert not r["sucesso"] and "sair" in r["mensagem"], r
+print("OK: pedir pra fechar o openTARS explica como sair, em vez de tentar se matar")
+
+# Recusa -> lembrete -> ferramenta, e a recusa não fica no histórico
+roteiro = iter([
+    {"content": "Desculpe, mas não consigo fechar aplicativos diretamente.", "tool_calls": []},
+    {"content": "", "tool_calls": [{"function": {"name": "close_application", "arguments": {"app": "claude"}}}]},
+    {"content": "Fechei o Claude.", "tool_calls": []},
+])
+vistos = []
+tars._executar_turno_streaming = lambda mod, msgs, tools, **kw: (vistos.append([dict(x) for x in msgs]), (next(roteiro), None))[1]
+tars.carregar_modelo = lambda mod: True
+tars.modo_modelo = "MANUAL"
+fechados = []
+tars._DISPATCH_FERRAMENTAS["close_application"] = lambda a: fechados.append(a["app"]) or {"sucesso": True, "mensagem": "SUCESSO"}
+resposta = tars.perguntar_modelo("qwen3:8b", "fecha o claude")
+assert resposta == "Fechei o Claude." and fechados == ["claude"], (resposta, fechados)
+assert "DO have tools" in vistos[1][-1]["content"]
+assert not any("não consigo" in (x.get("content") or "") for x in tars.conversa)
+print("OK: quando a IA diz 'não consigo', o openTARS lembra das ferramentas e ela fecha o app")
+
+# Recusa DEPOIS de tentar uma ferramenta é legítima: não insiste
+roteiro = iter([
+    {"content": "", "tool_calls": [{"function": {"name": "close_application", "arguments": {"app": "xyz"}}}]},
+    {"content": "Não consigo fechar o xyz: ele não está aberto.", "tool_calls": []},
+])
+vistos.clear()
+tars.perguntar_modelo("qwen3:8b", "fecha o xyz")
+assert len(vistos) == 2
+print("OK: 'não consigo' depois de uma ferramenta falhar é resposta válida, sem insistência")
+
+# Histórico antigo com recusas é limpo ao carregar
+antigo = [
+    {"role": "user", "content": "abra counter strike"},
+    {"role": "assistant", "content": "Desculpe, mas não consigo abrir aplicativos."},
+    {"role": "user", "content": "abra o firefox"},
+    {"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "open_application"}}]},
+    {"role": "tool", "content": "{}"},
+    {"role": "assistant", "content": "Abri o Firefox."},
+    {"role": "user", "content": "fecha o claude"},
+    {"role": "assistant", "content": "I can't close applications directly."},
+]
+json.dump({"versao": 2, "conversa": antigo}, open(os.environ["TARS_ARQUIVO_SESSOES"], "w"))
+carregada = tars.carregar_sessoes()
+textos = [x.get("content") for x in carregada[1:]]
+assert textos == ["abra o firefox", "", "{}", "Abri o Firefox."], textos
+print("OK: recusas antigas saem do histórico ao abrir (e levam o pedido junto)")
+
+assert not tars._parece_recusa("Abri a calculadora.")
+assert not tars._parece_recusa("O comando terminou com erro: permissão negada.")
+print("OK: respostas normais não são confundidas com recusa")
+
+os.remove(os.environ["TARS_ARQUIVO_SESSOES"])
+print("\nTUDO OK.")

app/tests/test_retomada.py

@@ -0,0 +1,119 @@
+"""18/10: "use the built-in tool" depois de um pedido (captura do Enzo). O Lite abriu o "app" google (= Google Chrome) e disse
+que tinha pesquisado. Três travas de código, nenhuma de treino:
+  1. a frase que só manda fazer o pedido anterior é reconhecida: a tarefa, o modelo e a IA usam o pedido anterior;
+  2. search_web diz ao modelo que ele NÃO leu os resultados (não pode afirmar o que eles dizem);
+  3. open_application com nome de site (google, youtube...) abre o site, a não ser que exista um programa com esse nome."""
+from _util import carregar_tars
+
+tars = carregar_tars()
+n = tars.normalizar
+
+for s in ["use the built-in tool", "use the search engine", "usa a ferramenta", "use o buscador", "faz de verdade",
+          "faça isso de verdade", "do it", "actually do it", "try again", "tenta de novo", "de novo", "ok, use your tools",
+          "pesquisa de verdade", "search it online", "use the tool please", "mas usa a ferramenta", "do it for real"]:
+    assert tars.escolha.eh_retomada(n(s)), s
+for s in ["use the search engine to tell me the current president of the usa", "abre a calculadora", "faz uma pasta Fotos",
+          "use firefox to open github", "what tool do you use?", "but i need to wash the car", "try the new restaurant", ""]:
+    assert not tars.escolha.eh_retomada(n(s)), s
+print("OK: reconhece 'use a ferramenta', 'faz de verdade', 'try again'... e não confunde com pedidos de verdade")
+
+conversa = [{"role": "system", "content": "x"},
+            {"role": "user", "content": "use the search engine to tell me the current president of the usa"},
+            {"role": "user", "content": "[Context from openTARS, not a new request] Open windows right now: 'Brave'."},
+            {"role": "assistant", "content": "The current president of the USA is ..."}]
+assert tars._ultimo_pedido_real(conversa) == "use the search engine to tell me the current president of the usa"
+ctx = tars._contexto_do_pedido("use the built-in tool", None, False, retoma="use the search engine to tell me X")
+assert ctx and 'previous request: "use the search engine to tell me X"' in ctx and "only what the tool results confirm" in ctx
+assert tars._contexto_do_pedido("oi", None, False) is None
+print("OK: a IA recebe o pedido anterior junto com 'use a ferramenta'")
+
+abertos = []
+tars._abrir_no_navegador = lambda url: abertos.append(url)
+r = tars.pesquisar_web("current president of the usa", "google")
+assert r["sucesso"] and "NOT read the results" in r["mensagem"] and "own knowledge" in r["mensagem"], r
+print("OK: search_web avisa que os resultados só foram abertos, não lidos")
+
+tars.desktop_entries = lambda: [{"nome": "Google Chrome", "outros_nomes": [], "exec": "google-chrome", "arquivo": "/x/google-chrome.desktop"},
+                                {"nome": "Spotify", "outros_nomes": [], "exec": "spotify", "arquivo": "/x/spotify.desktop"}]
+real_which = tars.shutil.which
+tars.shutil.which = lambda nome: None
+r = tars.abrir_aplicativo("google")
+assert r["sucesso"] and "is a website, not an installed application" in r["mensagem"] and abertos[-1].startswith("https://"), (r, abertos)
+assert "google" in abertos[-1]
+assert tars._app_com_nome_exato("spotify") and not tars._app_com_nome_exato("google")
+tars.shutil.which = real_which
+print("OK: open_application('google') abre o site, não o Google Chrome; um programa com o nome exato continua app")
+print("\nTUDO OK.")
+
+# 4) a resposta de memória depois de uma busca não lida ganha o aviso do app (o 2B diz "abri no navegador": sem aviso)
+assert not tars._RE_FALA_DO_NAVEGADOR.search(n("The current president of the USA is Joe Biden."))
+for frase in ("O resultado da busca foi aberto no navegador.", "The results are open in your browser.",
+              "Abri a pesquisa, confira na tela."):
+    assert tars._RE_FALA_DO_NAVEGADOR.search(n(frase)), frase
+assert tars.t("msg.busca_nao_lida")
+print("OK: resposta de memória depois de uma busca não lida é sinalizada pelo app")
+
+# 5) 18/10 (decisão do Enzo): com o SearXNG ligado, "pesquisa X" só consulta o SearXNG e responde; nada abre no PC, a não
+# ser que a pessoa peça para abrir, ou que seja um site com busca própria (YouTube). Desligada: abre, como antes.
+tars.web_lib.config = lambda: {"ligada": True, "endereco": "http://x"}
+tars.web_lib.buscar = lambda q: [{"titulo": "President of the United States", "url": "https://en.wikipedia.org/wiki/P", "trecho": "The current president is X."}]
+for pedido, servico in (("pesquisa quem é o presidente dos eua", "google"), ("search latest bonsai model releases using searxng", "searxng"),
+                        ("procura isso", None), ("what's the price of bitcoin", "bing")):
+    abertos.clear()
+    tars._pedido_atual["texto"] = pedido
+    r = tars.pesquisar_web("x", servico)
+    assert r["sucesso"] and r["leu_resultados"] and not abertos, (pedido, r, abertos)
+    assert "Nothing was opened" in r["mensagem"] and "wikipedia.org" in r["mensagem"], r["mensagem"]
+for pedido in ("pesquisa o presidente e abre no navegador", "search it and open the results in the browser",
+               "mostra no google o preço do dólar", "open google results for bonsai"):
+    abertos.clear()
+    tars._pedido_atual["texto"] = pedido
+    r = tars.pesquisar_web("x", "google")
+    assert r["leu_resultados"] and abertos and "also opened" in r["mensagem"], (pedido, r)
+abertos.clear()
+tars._pedido_atual["texto"] = "procura lofi no youtube"
+r = tars.pesquisar_web("lofi", "youtube")
+assert abertos and "youtube.com" in abertos[-1] and not r.get("leu_resultados"), "YouTube: abre a página do YouTube"
+def _quebrado(q):
+    raise ValueError("SearXNG not reachable")
+tars.web_lib.buscar = _quebrado
+abertos.clear()
+tars._pedido_atual["texto"] = "pesquisa o tempo amanhã"
+r = tars.pesquisar_web("tempo amanhã", None)
+assert r["sucesso"] and abertos and "NOT read the results" in r["mensagem"], "SearXNG fora do ar (26/10): abre no navegador, sem fingir que leu"
+tars.web_lib.config = lambda: {"ligada": False, "endereco": "http://x"}
+abertos.clear()
+r = tars.pesquisar_web("x", None)
+assert r["sucesso"] and abertos and "NOT read" in r["mensagem"], "pesquisa desligada: abre no navegador, como antes"
+assert not tars.pediu_para_abrir("pesquisa quem ganhou o jogo") and tars.pediu_para_abrir("abre o google com isso")
+print("OK: com o SearXNG ligado, pesquisar não abre nada (só se pedir ou no YouTube); desligado, abre como antes")
+
+# 6) 18/10: o Gargantua 2 recém-exportado (fora do catálogo em cache) recebe think=false mesmo assim; sem isso o Qwen3.5 pensava
+# e a resposta vinha vazia (a visão do Lite novo parecia errar 40 de 40)
+enviados = []
+class _R:
+    status_code = 200
+    def json(self): return {"message": {"content": "ok"}}
+tars._SESSION.post = lambda url, json=None, timeout=None: enviados.append(json) or _R()
+tars._cache_catalogo["dados"] = {}
+tars._chat_unico("Gargantua-2:qualquer-tag-nova", "oi")
+tars._chat_unico("qwen3:4b", "oi")
+assert enviados[0].get("think") is False and "think" not in enviados[1], enviados
+print("OK: modelo Gargantua-2 fora do catálogo em cache também recebe think=false")
+
+# 7) 18/10: lembrete de idioma só para pedido em inglês; nota quando a resposta diz que abriu algo e nada abriu
+for f in ("what is the capital of sweden", "search latest bonsai model releases using searxng", "open the calculator", "tell me a joke",
+          "who painted the mona lisa", "yeah search latest bonsai model releases using searxng"):
+    assert tars.escolha.pedido_em_ingles(n(f)), f
+for f in ("qual a capital da suécia", "pesquisa quem ganhou a copa", "abre a calculadora", "open", "oi", "calculadora", "google",
+          "abre o spotify", "como faço arroz"):
+    assert not tars.escolha.pedido_em_ingles(n(f)), f
+assert "answer in English" in tars._contexto_do_pedido("what is the capital of sweden", None, False)
+assert tars._contexto_do_pedido("qual a capital da suécia", None, False) is None
+for frase in ("O resultado da busca foi aberto no navegador.", "I opened the results in your browser.", "Encontrado no Google: ...",
+              "Abri a pesquisa na tela.", "The search results are open in the browser."):
+    assert tars._RE_DIZ_QUE_ABRIU.search(n(frase)), frase
+for frase in ("O presidente é X, segundo a Wikipedia.", "Bitcoin is at $81 thousand according to TradingView.", "A capital é Estocolmo."):
+    assert not tars._RE_DIZ_QUE_ABRIU.search(n(frase)), frase
+assert tars.t("msg.busca_nada_aberto")
+print("OK: lembrete de idioma só para inglês; nota quando a resposta diz que abriu o navegador e nada abriu")

app/tests/test_revisao45.py

@@ -0,0 +1,189 @@
+"""4.5 Endurance (revisão): um teste pra cada bug achado na revisão geral.
+
+Chat e anexos, controle do mouse e do teclado, escolha das IAs e linha de comando."""
+
+import io
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+from PIL import Image  # noqa: E402
+
+RAIZ = Path(__file__).resolve().parent.parent
+COOPER = "ProjectOpenTARS/cooper:latest"
+
+# ------------------------------------------------------------
+# Chat
+# ------------------------------------------------------------
+
+# 1. O print do openTARS não apaga o pedido do usuário (com o texto dos arquivos anexados)
+msgs = [
+    {"role": "system", "content": "s"},
+    {"role": "user", "content": "resuma\n\n[Files attached]\nVENDAS 1234", "images": ["AAA"]},
+    {"role": "user", "content": "[Automatic message from openTARS, not from the user] This is the screenshot", "images": ["BBB"]},
+]
+tars._print_em_texto = lambda *a, **k: "descrição do print"
+tars._tirar_imagens_da_conversa(msgs, "resuma", "api:texto")
+assert msgs[1]["content"].endswith("VENDAS 1234") and "images" not in msgs[1], msgs[1]
+assert msgs[2]["content"] == "descrição do print" and "images" not in msgs[2]
+print("OK: imagem anexada pelo usuário perde só a imagem; o texto do pedido e do arquivo ficam")
+
+# 2. O botão Parar vale enquanto o Ollama ainda não respondeu
+tars._cancelar.clear()
+inicio = time.time()
+threading.Timer(0.3, tars._cancelar.set).start()
+try:
+    tars._post_cancelavel(lambda: time.sleep(5))
+    raise AssertionError("devia cancelar")
+except tars.RespostaCancelada:
+    pass
+assert time.time() - inicio < 1.5, time.time() - inicio
+tars._cancelar.clear()
+assert tars._post_cancelavel(lambda: "pronto") == "pronto"
+try:
+    tars._post_cancelavel(lambda: (_ for _ in ()).throw(ValueError("x")))
+    raise AssertionError("devia repassar o erro")
+except ValueError:
+    pass
+print("OK: Parar interrompe a espera pelo Ollama em ~0,1 s e os erros passam adiante")
+
+# 3. Resposta normal que começa com "Okay," num modelo que não raciocina NÃO é cortada
+class Resp:
+    def __init__(self, linhas):
+        self.linhas, self.fechada = linhas, False
+
+    def iter_lines(self):
+        for x in self.linhas:
+            if self.fechada:
+                return
+            yield json.dumps(x).encode()
+
+    def close(self):
+        self.fechada = True
+
+
+pedidos = []
+longa = "Okay, here is a quick overview of what the command does: it lists all files in the folder. " * 12
+tars._chamar_ollama_stream = lambda p: (pedidos.append(p), (Resp([{"message": {"content": longa}}, {"done": True}]), None))[1]
+tars.emitir = lambda *a, **k: None
+tars._PENSA_MESMO_SEM_PEDIR.clear()
+res, erro = tars._executar_turno_streaming("gemma3:4b", [{"role": "user", "content": "explique"}], None, pensar=False)
+assert len(pedidos) == 1 and "gemma3:4b" not in tars._PENSA_MESMO_SEM_PEDIR and len((res["content"] + res["thinking"])) > 600
+print("OK: 'Okay, ...' em modelo que não raciocina não dispara o corte nem a repetição")
+
+# 5. Contexto velho ("janelas abertas agora") e foto de pedido antigo saem do histórico
+hist = [{"role": "system", "content": "s"},
+        {"role": "user", "content": "pedido 1", "images": ["IMG"]},
+        {"role": "assistant", "content": "ok"},
+        {"role": "user", "content": "pedido 2"}]
+tars._podar_historico(hist)
+assert "images" not in hist[1] and hist[1]["content"] == "pedido 1"
+print("OK: a foto de um pedido antigo não viaja em toda mensagem seguinte")
+
+# ------------------------------------------------------------
+# Controle: mouse, teclado, terminal, janelas
+# ------------------------------------------------------------
+tars._tamanho_real = lambda: (1280, 800)
+assert tars._longe_da_quina(3000, 2000) == (1276, 796)
+assert tars._longe_da_quina(-50, 0) == (3, 3)
+assert tars._longe_da_quina(640, 400) == (640, 400)
+tars._mirar_bruto = lambda *a, **k: (5000, 5000, "x")
+assert tars._mirar(5000, 5000, None, None)[:2] == (1276, 796), "clique fora da tela não encosta na quina"
+cliques = []
+tars._mirar_bruto = lambda *a, **k: (100, 100, "")
+tars.pyautogui = type("P", (), {
+    "moveTo": staticmethod(lambda *a, **k: None),
+    "click": staticmethod(lambda **k: cliques.append(k)),
+    "doubleClick": staticmethod(lambda **k: None),
+    "isValidKey": staticmethod(lambda k: k in ("enter", "pagedown", "ctrl", "s", "win", "esc", "down")),
+    "press": staticmethod(lambda k: cliques.append(("press", k))),
+    "hotkey": staticmethod(lambda *k: cliques.append(("hotkey", k))),
+})
+tars._conferir = lambda fazer, *a: (fazer(), "mudou")[1]
+tars.PAUSA_HOVER_SEG = 0
+tars.DURACAO_MOVER_MOUSE_SEG = 0
+nome, args, _ = tars.consertar_chamada("right_click", {"x": 100, "y": 100})
+assert nome == "click_mouse" and args["button"] == "right", (nome, args)
+tars.clicar_mouse("Right", 100, 100)
+assert cliques[-1]["button"] == "right", cliques
+tars.clicar_mouse("right-click", 100, 100)
+assert cliques[-1]["button"] == "right"
+assert tars.pressionar_tecla("Page Down")["sucesso"] and cliques[-1] == ("press", "pagedown")
+assert tars.pressionar_tecla("Super")["sucesso"] and cliques[-1] == ("press", "win")
+assert not tars.pressionar_tecla("bogus")["sucesso"] and not tars.pressionar_tecla("")["sucesso"]
+assert tars.pressionar_tecla("ctrl+s")["sucesso"] and cliques[-1] == ("hotkey", ("ctrl", "s"))
+assert not tars.atalho_teclado(["ctrl", "bogus"])["sucesso"] and not tars.atalho_teclado([])["sucesso"]
+print("OK: clique fora da tela não chega à quina, botão direito de verdade, teclas inválidas avisam")
+
+r = tars._executar_terminal_de_fato("printf 'ol\\341 mundo\\n'")
+assert r["sucesso"] and "mundo" in r["stdout"], r
+print("OK: saída que não é UTF-8 não derruba o comando")
+
+JANELAS = [dict(id=1, titulo="Calculator", classe="gnome-calculator Gnome-calculator", pid=10, x=0, y=0, largura=300, altura=400, minimizada=False),
+           dict(id=2, titulo="Calculadora online - Google Chrome", classe="google-chrome Google-chrome", pid=11, x=0, y=0, largura=900, altura=700, minimizada=False)]
+tars._buscar_app_no_sistema = lambda n: {"tipo": "desktop", "nome": "Calculator", "arquivo": "/usr/share/applications/org.gnome.Calculator.desktop",
+                                          "exec": "gnome-calculator", "comando": ["gtk-launch", "x"], "origem": "x"} if n.lower().startswith("calc") else None
+assert tars.encontrar_janela_por_nome("calculadora", JANELAS)["titulo"] == "Calculator", "o app vence a aba do navegador"
+assert tars.encontrar_janela_por_nome("chrome", JANELAS)["id"] == 2
+print("OK: 'calculadora' acha o programa e não a aba do navegador com o mesmo nome")
+
+# ------------------------------------------------------------
+# Escolha das IAs
+# ------------------------------------------------------------
+def modelo(tag, caps, params, categoria="geral", quant="Q4_K_M"):
+    return {"tag": tag, "familia": "x", "categoria": categoria, "parametros_b": params, "capacidades": set(caps),
+            "capacidades_conhecidas": True, "vram_estimado_gb": 2.0 if params is None else params * 0.6 + 0.6}
+
+
+CAT = {
+    "ProjectOpenTARS/Gargantua:latest": modelo("ProjectOpenTARS/Gargantua:latest", {"tools", "completion"}, 4.0),
+    COOPER: modelo(COOPER, {"tools", "vision", "completion"}, 2.0, "visao"),
+    "nomic-embed-text:latest": modelo("nomic-embed-text:latest", {"embedding"}, 0.14, "embedding"),
+    "qwen3:8b": modelo("qwen3:8b", {"tools", "completion"}, 8.0),
+    "api:bonsai": modelo("api:bonsai", {"tools"}, None),
+}
+CAT["api:bonsai"]["capacidades_conhecidas"] = False
+assert tars.modelo_ajudante(CAT) != COOPER, "o Cooper não resolve nome de app"
+for alvo in ("modelo.menor", "modelo.maior", "modelo.visao", "modelo.tecnico"):
+    escolhido = tars._RESOLVEDORES_MODELO[alvo](CAT) if hasattr(tars, "_RESOLVEDORES_MODELO") else None
+    assert escolhido not in (COOPER, "nomic-embed-text:latest"), (alvo, escolhido)
+assert COOPER not in tars.construir_cadeia_fallback("visao", CAT)
+assert tars.construir_cadeia_fallback("acao", CAT)[-1] != "x"
+cadeia = tars.construir_cadeia_fallback("busca", CAT)
+assert cadeia.index("api:bonsai") > cadeia.index("qwen3:8b"), cadeia  # tamanho desconhecido: no fim
+assert tars._estimar_vram_gb(8.2, "BF16") > 15
+print("OK: Cooper e embedding não conversam nem ajudam; tamanho desconhecido vai pro fim; BF16 não é Q4")
+
+# modelo que já está na placa responde a conversa curta (sem trocar de modelo)
+tars.catalogar_modelos = lambda forcar=False: CAT
+tars._cache_cadeias.clear()
+tars.modo_modelo = "AUTO"
+tars.modelo_atual = "qwen3:8b"
+assert tars.escolher_modelo("oi", tarefa="simples") == "qwen3:8b"
+tars.modelo_atual = None
+
+# ------------------------------------------------------------
+# Linha de comando
+# ------------------------------------------------------------
+def tars_cli(*args, entrada=""):
+    env = {**os.environ, "OLLAMA_HOST": "127.0.0.1:1", "HOME": CASA, "TARS_SEM_INTERFACE": "1", "TARS_SEM_AVISO_VERSAO": "1"}
+    return subprocess.run([sys.executable, str(RAIZ / "tars.py"), *args], input=entrada, capture_output=True, text=True, env=env, timeout=60)
+
+
+r = tars_cli("--chat", "oi")  # Ollama fora do ar: erro e código de saída diferente de 0
+assert r.returncode == 1, (r.returncode, r.stdout[-300:])
+print("OK: --chat com o Ollama fora do ar dá código de saída diferente de 0")
+
+print("\nTUDO OK.")

app/tests/test_revisao_50.py

@@ -0,0 +1,191 @@
+"""5.0: regressões da revisão geral do código (bugs achados e corrigidos)."""
+
+import datetime as dt
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_AGENDA"] = os.path.join(CASA, "agenda.json")
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+os.environ["TARS_DIR_LOG"] = os.path.join(CASA, "log")
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+import tars_rotinas as rot  # noqa: E402
+import tars_historico as hist  # noqa: E402
+import tars_openai as api  # noqa: E402
+
+# --- rotinas -------------------------------------------------------------------------------------------------
+assert rot.ler_dias("seg,qua,sex") == [0, 2, 4] and rot.ler_dias("mon, wed, fri") == [0, 2, 4]
+assert rot.ler_dias(["weekdays"]) == [0, 1, 2, 3, 4] and rot.ler_dias(["seg, qua"]) == [0, 2]
+assert rot.ler_dias("terça e quinta") == [1, 3]
+q, erro = rot.normalizar_quando({"tipo": "uma_vez", "data": "2026-10-31T09:00:00Z"})
+assert erro is None and "+" not in q["data"] and "Z" not in q["data"], q      # data com fuso não derruba o agendador
+assert rot.proxima_execucao(q, dt.datetime(2020, 1, 1)) is not None
+r = {"aprovada": True, "permitidas": ["apagar"]}
+assert rot.autorizado(r, "rm /tmp/x") and not rot.autorizado(r, "rm /tmp/x && git push origin main"), "aprovar uma categoria não libera outra"
+assert not rot.autorizado(r, "ls") and not rot.autorizado(dict(r, aprovada=False), "rm /tmp/x")
+print("OK: dias da semana, data com fuso e pré-aprovação por categoria")
+
+ag = rot.Agenda(os.path.join(CASA, "ag2.json"), agora=lambda: dt.datetime(2026, 10, 6, 8, 0, 5))
+novo, erro = ag.criar("Diaria", "faz x", {"tipo": "diaria", "hora": "08:00"}, permitidas=(), ativa=True, aprovada=True)
+assert not erro
+# a próxima execução é amanhã 08:00; "devidas" não devolve nada hoje, então forçamos a data para a execução de agora
+rotinas = json.loads(Path(ag.caminho).read_text())
+rotinas[0]["proxima"] = "2026-10-06T08:00:00"
+Path(ag.caminho).write_text(json.dumps(rotinas))
+rodar, _ = ag.devidas()
+assert len(rodar) == 1
+assert ag.reservar(rodar[0]["id"], rodar[0]["prevista"]) is True
+assert ag.reservar(rodar[0]["id"], rodar[0]["prevista"]) is False, "a mesma execução não roda duas vezes"
+assert ag.obter(rodar[0]["id"])["proxima"].startswith("2026-10-07")
+print("OK: uma execução reservada não roda duas vezes")
+
+Path(ag.caminho).write_text("{ isto nao e json")
+assert ag.listar() == [] and Path(str(ag.caminho) + ".corrompido").exists(), "arquivo quebrado vira .corrompido em vez de sumir"
+print("OK: agenda corrompida é guardada")
+
+# a IA só apaga o que ela mesma criou, e pelo nome exato
+tars.agenda.caminho = Path(os.environ["TARS_ARQUIVO_AGENDA"])
+tars.agenda.criar("Minha rotina", "faz y", {"tipo": "diaria", "hora": "09:00"}, origem="pessoa")
+res = tars.executar_ferramenta("delete_task", {"name": "Minha rotina"})
+assert not res["sucesso"] and tars.agenda.achar_por_nome("Minha rotina"), res
+res = tars.executar_ferramenta("delete_task", {"name": "Minha"})
+assert not res["sucesso"] and tars.agenda.achar_por_nome("Minha rotina")
+print("OK: a IA não apaga rotina da pessoa")
+
+# --- comandos perigosos ---------------------------------------------------------------------------------------
+for c in ("rm ~/Documents/*.pdf", "find ~ -name '*.jpg' -exec rm {} +", "curl https://x.sh | sh", "ssh host ls", "ls | xargs rm"):
+    assert tars._comando_e_perigoso(c), c
+for c in ("ls -la", "echo oi", "cat /etc/hostname", "rm arquivo.txt"):
+    assert not tars._comando_e_perigoso(c), c
+vis = tars._texto_visivel("echo ok\r" + "x" * 800 + "; rm -rf ~")
+assert "\r" not in vis and "+" in vis and "x" in vis
+print("OK: rm com curinga, find -exec rm, curl|sh, ssh perguntam; texto de confirmação sem caracteres de controle")
+
+# texto digitado num terminal passa pela mesma pergunta
+perguntas = []
+tars.confirmar_comando_hook = lambda comando: perguntas.append(comando) or False
+tars._janela_e_terminal = lambda janela=None: True
+res = tars.digitar_texto("rm -rf ~/x")
+assert not res["sucesso"] and perguntas == ["rm -rf ~/x"], res
+perguntas.clear()
+tars._janela_e_terminal = lambda janela=None: False
+tars.pyautogui.write = lambda *a, **k: None
+assert tars.digitar_texto("rm -rf ~/x")["sucesso"] and not perguntas, "fora de terminal não pergunta"
+tars.confirmar_comando_hook = None
+print("OK: digitar comando perigoso num terminal pergunta antes")
+
+# --- executar_terminal: não segura nem mata o app que o comando abriu; chave da nuvem não vaza ---------------
+tars.confirmar_comando_hook = lambda c: True
+os.environ["TARS_CHAVE_API"] = "segredo-123"
+inicio = time.time()
+res = tars._executar_terminal_de_fato("sleep 4 & echo pronto")      # o 'sleep' herda a saída: antes esperava até o fim dele
+assert res["sucesso"] and "pronto" in res["stdout"] and time.time() - inicio < 3, (res, time.time() - inicio)
+res = tars._executar_terminal_de_fato("env")
+assert "segredo-123" not in res["stdout"] and "TARS_CHAVE_API" not in res["stdout"]
+res = tars._executar_terminal_de_fato("yes | head -c 3000000 | tr -d '\\n' | head -c 50000; echo fim")
+assert res["sucesso"] and len(res["stdout"]) <= tars.LIMITE_STDOUT_CHARS
+res = tars._executar_terminal_de_fato("printf 'caf\\xe9'")
+assert res["sucesso"], "saída fora de UTF-8 não derruba o comando"
+res = tars._executar_terminal_de_fato("sleep 1 &")
+assert res["sucesso"] and "background" in res["mensagem"]
+del os.environ["TARS_CHAVE_API"]
+import threading
+antes_fios = threading.active_count()
+res = tars._executar_terminal_de_fato("true &")        # comando com & termina logo: o filho tem que ser recolhido (sem zumbi)
+time.sleep(1.0)
+import subprocess as _sp
+zumbis = [l for l in _sp.run(["ps", "-o", "stat=", "--ppid", str(os.getpid())], capture_output=True, text=True).stdout.split() if l.startswith("Z")]
+assert res["sucesso"] and not zumbis, (res, zumbis)
+print("OK: comando com & não deixa processo zumbi")
+print("OK: terminal não espera filho herdando a saída, não vaza a chave, limita a saída")
+
+# --- ferramentas ----------------------------------------------------------------------------------------------
+res = tars.fechar_aplicativo("")
+assert not res["sucesso"] and tars._terminar_processos("") == [] and tars._terminar_processos("   ") == []
+n, args, _ = tars.consertar_chamada("click_mouse", '{"x": 1, "y": 2}')
+assert args == {"x": 1, "y": 2}
+n, args, _ = tars.consertar_chamada("click_mouse", ["lixo"])
+assert args == {}
+n, args, _ = tars.consertar_chamada("scroll_mouse", {"amount": float("inf")})
+assert isinstance(args, dict)
+n, args, _ = tars.consertar_chamada("list_files", {"path": "~/Docs"})
+assert args["command"].startswith("ls -la -- ") and "~" not in args["command"] and CASA in args["command"], args
+print("OK: close_application vazio não mata nada; argumentos estranhos não derrubam o turno")
+
+assert tars._chamadas_no_texto('{"name": ["a"], "arguments": {}}') == [] if hasattr(tars, "_chamadas_no_texto") else True
+
+# --- OpenAI / nuvem ---------------------------------------------------------------------------------------------
+assert api.normalizar_url("api.groq.com/openai/v1") == "https://api.groq.com/openai/v1"
+assert api.normalizar_url("localhost:1234") == "http://localhost:1234/v1"
+assert api.normalizar_url("192.168.0.5:8000") == "http://192.168.0.5:8000/v1"
+assert api.normalizar_url("https://x.com/v1beta/openai") == "https://x.com/v1beta/openai"
+msgs = [{"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "a", "arguments": {}}}]},
+        {"role": "user", "content": "e então?"}]
+saida = api.para_openai(msgs)
+assert [m["role"] for m in saida] == ["assistant", "tool", "user"], saida          # chamada sem resultado ganha um vazio
+print("OK: endereço da nuvem sem esquema vira https; chamada sem resultado é fechada")
+
+# --- histórico mantém o começo da conversa --------------------------------------------------------------------------
+h = hist.Historico(os.path.join(CASA, "h.json"))
+completa = [{"role": "user", "content": f"m{i}"} if i % 2 == 0 else {"role": "assistant", "content": f"r{i}"} for i in range(40)]
+h.salvar("a", completa[:30])
+h.salvar("a", completa[10:40])                       # a conversa em memória foi podada (começa na 10)
+assert [m["content"] for m in h.abrir("a")][0] == "m0" and len(h.abrir("a")) == 40
+Path(h.caminho).write_text("lixo")
+assert h.listar() == [] and Path(str(h.caminho) + ".corrompido").exists()
+print("OK: histórico não perde o começo da conversa podada nem some com arquivo quebrado")
+
+# --- log não guarda o que foi digitado -----------------------------------------------------------------------------
+assert "senha123" not in tars._resumir_para_log({"text": "senha123"}) and "8 chars" in tars._resumir_para_log({"text": "senha123"})
+assert (os.stat(tars.DIRETORIO_LOG).st_mode & 0o777) == 0o700
+print("OK: o log só guarda o tamanho do texto digitado e a pasta é 0700")
+
+# --- /modelo: horas e siglas não viram modelo -------------------------------------------------------------------------
+for lixo in ("12:30", "pt:br", "note:x"):
+    antes = (tars.modo_modelo, tars.modelo_manual)
+    tars.modo_modelo, tars.modelo_manual = "AUTO", None
+    tars._tratar_comando_modelo(lixo) if hasattr(tars, "_tratar_comando_modelo") else None
+    assert tars.modo_modelo == "AUTO", lixo
+    tars.modo_modelo, tars.modelo_manual = antes
+print("OK: mensagens como 12:30 não trocam o modelo")
+
+# --- stream do Ollama que acaba sem 'done' não vira resposta -----------------------------------------------------------
+class Resposta:
+    def __init__(self, linhas):
+        self._l = linhas
+        self.fechada = False
+
+    def iter_lines(self):
+        yield from self._l
+
+    def close(self):
+        self.fechada = True
+
+
+def corpo(msgs):
+    return [json.dumps({"message": {"content": m}, "done": False}).encode() for m in msgs]
+
+
+resp = Resposta(corpo(["Ola ", "mund"]))                    # acabou no meio, sem "done"
+resp.status_code = 200
+tars.ollama_request = lambda *a, **k: resp
+r, erro = tars._executar_turno_streaming("qwen3:8b", [{"role": "user", "content": "oi"}], [], False)
+assert r is None and erro, (r, erro)
+assert resp.fechada, "a conexão é fechada em qualquer saída"
+ok = Resposta(corpo(["Ola"]) + [json.dumps({"message": {"content": "!"}, "done": True}).encode()])
+ok.status_code = 200
+tars.ollama_request = lambda *a, **k: ok
+r, erro = tars._executar_turno_streaming("qwen3:8b", [{"role": "user", "content": "oi"}], [], False)
+assert erro is None and "Ola" in (r or {}).get("content", ""), (r, erro)
+print("OK: stream sem 'done' é erro, não resposta pela metade")
+
+print("\nTUDO OK.")

app/tests/test_robustez_v29.py

@@ -0,0 +1,78 @@
+"""2.9: IAs menos propensas a falhas."""
+
+import os
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+# 1. Conserto de chamadas
+n, a, nota = tars.consertar_chamada("open_app", {"app_name": "firefox"})
+assert (n, a) == ("open_application", {"app": "firefox"}) and "open_app" in nota, (n, a, nota)
+n, a, _ = tars.consertar_chamada("click_mouse", {"x": "120", "y": 80.6})
+assert a == {"x": 120, "y": 81}, a
+n, a, _ = tars.consertar_chamada("hotkey", {"keys": "ctrl+s"})
+assert (n, a) == ("press_key", {"key": "ctrl+s"}), (n, a)  # 4.6: hotkey virou press_key
+n, a, _ = tars.consertar_chamada("hotkey", {"keys": ["ctrl", "shift", "t"]})
+assert (n, a) == ("press_key", {"key": "ctrl+shift+t"}), (n, a)
+# 4.6: as ferramentas que saíram continuam funcionando pra quem ainda as conhece (Gargantua 1.1)
+n, a, _ = tars.consertar_chamada("double_click", {"x": 10, "y": 20})
+assert (n, a) == ("click_mouse", {"x": 10, "y": 20, "clicks": 2}), (n, a)
+n, a, _ = tars.consertar_chamada("list_files", {"path": "~/Documentos"})
+assert n == "execute_terminal" and a["command"] == "ls -la -- " + os.path.expanduser("~/Documentos"), (n, a)   # o ~ é expandido: entre aspas o ls procurava uma pasta chamada "~"
+n, a, _ = tars.consertar_chamada("wait_seconds", {"seconds": 999})
+assert (n, a) == ("execute_terminal", {"command": "sleep 5"}), (n, a)
+n, a, _ = tars.consertar_chamada("pc_info", {})
+assert n == "execute_terminal" and "free -h" in a["command"], (n, a)
+n, a, _ = tars.consertar_chamada("move_to_trash", {"paths": ["a b.txt"]})
+assert n == "execute_terminal" and a["command"] == "gio trash -- 'a b.txt'", (n, a)
+assert not {"double_click", "hotkey", "list_files", "pc_info", "wait_seconds", "move_to_trash", "undo_last_action",
+            "read_clipboard", "write_clipboard"} & {f["function"]["name"] for f in tars.TOOLS}
+assert len(tars.TOOLS) == 19, len(tars.TOOLS)
+n, a, _ = tars.consertar_chamada("type_in_element", {"text": "oi", "window": "Claude", "submit": "true"})
+assert a["submit"] is True
+n, a, _ = tars.consertar_chamada("serch_web", {"search_query": "lasanha"})
+assert (n, a) == ("search_web", {"query": "lasanha"}), (n, a)
+n, a, nota = tars.consertar_chamada("search_web", {"query": "x"})
+assert nota is None
+print("OK: nomes e argumentos inventados são corrigidos (open_app/app_name, '120', 'ctrl+s', 'true', erro de digitação)")
+
+# 2. Ferramentas por tarefa
+nomes = lambda tarefa: {f["function"]["name"] for f in tars.ferramentas_para(tarefa)}  # noqa: E731
+assert nomes("simples") == {"open_website", "search_web", "open_application", "close_application"}
+assert "execute_terminal" in nomes("tecnico") and "click_mouse" not in nomes("tecnico")
+# 3.0: memória e agenda só entram quando o pedido fala delas (ferramentas_do_pedido)
+todas = len([f for f in tars.TOOLS if f["function"]["name"] not in tars._FERRAMENTAS_SO_SE_PEDIDAS])
+assert len(nomes("acao")) == todas and len(nomes(None)) == todas
+print(f"OK: cada tarefa recebe só as ferramentas que fazem sentido (simples: 4, ação: {todas})")
+
+# 3. "Pronto!" depois de uma ferramenta que falhou -> conserta ou conta a verdade
+tars.carregar_modelo = lambda m, silencioso=False: True
+tars.contexto_ia = lambda: 8192
+tars.modo_modelo = "MANUAL"
+tars.catalogar_modelos = lambda forcar=False: {}
+roteiro = iter([
+    ("tool", "open_application", {"app": "photoshop"}),
+    ("texto", "Pronto! Abri o Photoshop pra você."),
+    ("texto", "Não consegui abrir: o Photoshop não está instalado neste PC."),
+])
+recebidas, ofertas = [], []
+
+
+def turno(modelo, msgs, tools, **kw):
+    recebidas.append(msgs[-1]["content"])
+    ofertas.append(len(tools or []))
+    tipo, *resto = next(roteiro)
+    if tipo == "texto":
+        return {"content": resto[0], "tool_calls": []}, None
+    return {"content": "", "tool_calls": [{"function": {"name": resto[0], "arguments": resto[1]}}]}, None
+
+
+tars._executar_turno_streaming = turno
+tars._DISPATCH_FERRAMENTAS["open_application"] = lambda a: {"sucesso": False, "mensagem": "APP NOT FOUND: 'photoshop'."}
+tars.conversa = []
+resposta = tars.perguntar_modelo("qwen3:8b", "abre o photoshop", tarefa="simples")
+assert resposta.startswith("Não consegui"), resposta
+assert any("LAST tool call FAILED" in r for r in recebidas)
+assert ofertas[0] == 4, ofertas
+print("OK: 'Pronto, abri!' logo depois de uma falha é barrado; a IA conta a verdade")
+print("\nTUDO OK.")

app/tests/test_rotinas.py

@@ -0,0 +1,140 @@
+"""5.0: rotinas agendadas (tars_rotinas.py): horários, pré-aprovação, perdidas, arquivo 0600."""
+
+import datetime as dt
+import os
+import stat
+import tempfile
+
+from _util import RAIZ  # noqa: F401
+
+import tars_i18n
+import tars_rotinas as R
+
+D = dt.datetime
+pasta = tempfile.mkdtemp(prefix="opentars-agenda-")
+caminho = os.path.join(pasta, "agenda.json")
+relogio = {"agora": D(2026, 10, 6, 7, 0)}      # terça-feira
+ag = R.Agenda(caminho, agora=lambda: relogio["agora"])
+
+# --- ler hora e dias ---------------------------------------------------------
+assert R.ler_hora("8") == (8, 0) and R.ler_hora("8h30") == (8, 30) and R.ler_hora("08:05") == (8, 5)
+assert R.ler_hora("25:00") is None and R.ler_hora("abc") is None and R.ler_hora("") is None
+assert R.ler_dias("segunda a sexta") == [0, 1, 2, 3, 4] and R.ler_dias("sáb, dom") == [5, 6]
+assert R.ler_dias(["seg", "quarta", 4]) == [0, 2, 4] and R.ler_dias("fim de semana") == [5, 6]
+assert R.ler_dias(None) == [] and R.ler_dias("nada") == []
+
+# --- quando ------------------------------------------------------------------
+assert R.normalizar_quando({"tipo": "diaria", "hora": "8h"}) == ({"tipo": "diaria", "hora": "08:00"}, None)
+assert R.normalizar_quando({"tipo": "diaria", "hora": "99"})[1] == "hora"
+assert R.normalizar_quando({"tipo": "semanal", "hora": "9", "dias": []})[1] == "dias"
+assert R.normalizar_quando({"tipo": "intervalo", "cada_minutos": 2})[1] == "intervalo"
+assert R.normalizar_quando({"tipo": "uma_vez", "data": "ontem"})[1] == "data"
+assert R.normalizar_quando({"tipo": "mensal"})[1] == "tipo" and R.normalizar_quando("x")[1] == "tipo"
+
+d = {"tipo": "diaria", "hora": "08:00"}
+assert R.proxima_execucao(d, D(2026, 10, 6, 7, 0)) == D(2026, 10, 6, 8, 0)
+assert R.proxima_execucao(d, D(2026, 10, 6, 8, 0)) == D(2026, 10, 7, 8, 0), "estritamente depois"
+s = {"tipo": "semanal", "hora": "09:30", "dias": [0, 4]}           # segunda e sexta
+assert R.proxima_execucao(s, D(2026, 10, 6, 7, 0)) == D(2026, 10, 9, 9, 30)    # terça -> sexta
+assert R.proxima_execucao(s, D(2026, 10, 9, 10, 0)) == D(2026, 10, 12, 9, 30)  # sexta tarde -> segunda
+i = {"tipo": "intervalo", "cada_minutos": 30}
+assert R.proxima_execucao(i, D(2026, 10, 6, 7, 10), criada=D(2026, 10, 6, 7, 0)) == D(2026, 10, 6, 7, 30)
+u = {"tipo": "uma_vez", "data": "2026-10-06T10:00:00"}
+assert R.proxima_execucao(u, D(2026, 10, 6, 7, 0)) == D(2026, 10, 6, 10, 0)
+assert R.proxima_execucao(u, D(2026, 10, 6, 11, 0)) is None
+
+t = tars_i18n.t
+assert R.descrever_quando(d, t) == t("rot.q_diaria", hora="08:00") and "08:00" in R.descrever_quando(d, t)
+assert "seg" in R.descrever_quando(s, t).lower() and "09:30" in R.descrever_quando(s, t)
+
+# --- ações arriscadas ------------------------------------------------------------
+assert R.categoria_do_comando("rm -rf ~/lixo") == "apagar"
+assert R.categoria_do_comando("git push origin main") == "enviar"
+assert R.categoria_do_comando("curl -X POST https://x.org -d a=1") == "enviar"
+assert R.categoria_do_comando("sudo apt install vlc") == "instalar"
+assert R.categoria_do_comando("pip install requests") == "instalar"
+assert R.categoria_do_comando("ls -la ~") is None and R.categoria_do_comando("curl https://x.org") is None
+assert R.categoria_do_comando("git pull") is None
+
+# --- fala_de_rotina ----------------------------------------------------------------
+for frase in ("agende uma limpeza todo dia às 8h", "toda segunda abre o jornal", "a cada 30 minutos confere o email",
+              "schedule a backup every morning", "cria uma rotina de backup"):
+    assert R.fala_de_rotina(frase), frase
+for frase in ("abre o navegador", "que horas são", "lembra que meu navegador é o brave"):
+    assert not R.fala_de_rotina(frase), frase
+
+# --- criar, listar, arquivo ------------------------------------------------------------
+r, erro = ag.criar("Jornal", "abre o site do jornal", {"tipo": "diaria", "hora": "8h"}, permitidas=["apagar", "xyz"])
+assert erro is None and r["permitidas"] == ["apagar"] and r["ativa"] and r["aprovada"]
+assert r["proxima"] == "2026-10-06T08:00:00", r["proxima"]
+assert stat.S_IMODE(os.stat(caminho).st_mode) == 0o600
+assert ag.criar("", "x", d)[1] == "nome" and ag.criar("a", "", d)[1] == "pedido"
+assert ag.criar("a", "x" * 501, d)[1] == "pedido" and ag.criar("a", "x", {"tipo": "diaria"})[1] == "hora"
+for n in range(R.LIMITE_ROTINAS - 1):
+    assert ag.criar(f"r{n}", "pedido", i)[1] is None
+assert ag.criar("a mais", "x", d)[1] == "limite"
+for x in ag.listar()[1:]:
+    ag.apagar(x["id"])
+assert [x["nome"] for x in ag.listar()] == ["Jornal"]
+assert ag.achar_por_nome("jornal")["id"] == r["id"] and ag.achar_por_nome("zzz") is None
+
+# --- autorização -------------------------------------------------------------------------
+assert R.autorizado(r, "rm -rf ~/lixo") and not R.autorizado(r, "git push") and not R.autorizado(r, "ls")
+nao_aprovada = dict(r, aprovada=False)
+assert not R.autorizado(nao_aprovada, "rm -rf ~/lixo")
+
+# --- devidas: ainda cedo, na hora, pulada --------------------------------------------------
+assert ag.devidas() == ([], [])
+relogio["agora"] = D(2026, 10, 6, 8, 2)
+rodar, perdidas = ag.devidas()
+assert [x["nome"] for x in rodar] == ["Jornal"] and perdidas == []
+ag.registrar(r["id"], "ok", "feito", agora=relogio["agora"])
+x = ag.obter(r["id"])
+assert x["ultima"]["resultado"] == "ok" and x["proxima"] == "2026-10-07T08:00:00"
+assert ag.devidas() == ([], []), "não roda duas vezes"
+
+relogio["agora"] = D(2026, 10, 7, 9, 30)       # o PC estava desligado às 8h
+rodar, perdidas = ag.devidas()
+assert rodar == [] and [p["nome"] for p in perdidas] == ["Jornal"]
+x = ag.obter(r["id"])
+assert x["ultima"]["resultado"] == "perdida" and x["proxima"] == "2026-10-08T08:00:00"
+assert ag.devidas() == ([], []), "a perdida só é avisada uma vez"
+
+# --- uma vez: some depois de rodar ---------------------------------------------------------
+relogio["agora"] = D(2026, 10, 8, 7, 0)
+u1, _ = ag.criar("Uma vez", "faz isso", {"tipo": "uma_vez", "data": "2026-10-08T07:30:00"})
+relogio["agora"] = D(2026, 10, 8, 7, 31)
+rodar, _ = ag.devidas()
+assert [x["nome"] for x in rodar] == ["Uma vez"]
+ag.registrar(u1["id"], "ok", agora=relogio["agora"])
+x = ag.obter(u1["id"])
+assert x["proxima"] is None and x["ativa"] is False
+
+# --- criada pela IA: desligada e sem aprovação; só ligar depois de aprovar ----------------------
+ia, _ = ag.criar("Da IA", "apaga o cache", d, permitidas=["apagar"], ativa=False, aprovada=False, origem="ia")
+assert ia["ativa"] is False and ia["aprovada"] is False and ia["origem"] == "ia"
+x, _ = ag.atualizar(ia["id"], ativa=True)
+assert x["ativa"] is False, "ligar sem aprovar não liga"
+x, _ = ag.atualizar(ia["id"], aprovada=True, ativa=True)
+assert x["ativa"] and x["aprovada"]
+x, _ = ag.atualizar(ia["id"], pedido="apaga tudo")                # mudou o pedido: precisa aprovar de novo
+assert x["aprovada"] is False and x["ativa"] is False
+assert ag.atualizar("nada", ativa=True)[1] == "inexistente"
+assert ag.atualizar(ia["id"], quando={"tipo": "x"})[1] == "tipo"
+
+# --- apagar --------------------------------------------------------------------------------------------
+assert ag.apagar(ia["id"]) and not ag.apagar(ia["id"])
+n = len(ag.listar())
+assert ag.apagar_tudo() == n and ag.listar() == []
+
+# --- arquivo estragado não derruba ------------------------------------------------------------------------
+open(caminho, "w").write("{ isso não é json")
+assert ag.listar() == []
+assert ag.criar("de novo", "x", d)[1] is None
+
+# --- textos ------------------------------------------------------------------------------------------------
+import json
+pt = json.load(open(os.path.join(RAIZ, "idiomas", "pt_BR.json"), encoding="utf-8"))
+en = json.load(open(os.path.join(RAIZ, "idiomas", "en.json"), encoding="utf-8"))
+assert {k for k in pt if k.startswith("rot.")} == {k for k in en if k.startswith("rot.")}
+print("test_rotinas: OK")

app/tests/test_rotinas_nucleo.py

@@ -0,0 +1,70 @@
+"""5.0: as ferramentas de agenda no núcleo (só quando o pedido fala de agendar, nunca pro Gargantua), a pré-aprovação
+no comando arriscado e o hook de confirmação."""
+
+import os
+import tempfile
+
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_AGENDA"] = os.path.join(CASA, "agenda.json")
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+nomes = lambda lista: {f["function"]["name"] for f in lista}  # noqa: E731
+
+# --- só aparecem quando o pedido fala de agendar ---------------------------------------------
+assert "schedule_task" not in nomes(tars.ferramentas_do_pedido("acao", "abre o navegador"))
+assert {"schedule_task", "list_tasks", "delete_task"} <= nomes(tars.ferramentas_do_pedido("acao", "agenda isso todo dia às 8h"))
+assert "schedule_task" not in nomes(tars.TOOLS), "fora de TOOLS: o Gargantua não as vê"
+assert "schedule_task" not in nomes(tars.ferramentas_gargantua())
+assert "schedule_task" not in nomes(tars.ferramentas_do_modelo("ProjectOpenTARS/Gargantua:latest", "acao", "agenda todo dia"))
+print("OK: ferramentas da agenda só quando o pedido fala de agendar, e nunca pro Gargantua")
+
+# --- criar pela IA: nasce pendente ---------------------------------------------------------------
+r = tars.executar_ferramenta("schedule_task", {"name": "Jornal", "request": "abre o site do jornal", "when_type": "daily", "time": "8h"})
+assert r["sucesso"] and "PENDING" in r["mensagem"], r
+rot = tars.agenda.listar()[0]
+assert rot["nome"] == "Jornal" and rot["ativa"] is False and rot["aprovada"] is False and rot["origem"] == "ia"
+assert rot["quando"] == {"tipo": "diaria", "hora": "08:00"}
+r = tars.executar_ferramenta("schedule_task", {"name": "Semana", "request": "faz o backup", "when_type": "weekly", "time": "18:30", "days": ["mon", "fri"]})
+assert r["sucesso"] and tars.agenda.achar_por_nome("semana")["quando"]["dias"] == [0, 4]
+r = tars.executar_ferramenta("schedule_task", {"name": "Ruim", "request": "x", "when_type": "daily"})
+assert not r["sucesso"] and "time" in r["mensagem"]
+r = tars.executar_ferramenta("list_tasks", {})
+assert "Jornal [pending approval]" in r["mensagem"]
+r = tars.executar_ferramenta("delete_task", {"name": "jornal"})
+assert r["sucesso"] and tars.agenda.achar_por_nome("Jornal") is None
+r = tars.executar_ferramenta("create_routine", {"name": "Apelido", "request": "x", "when_type": "interval", "every_minutes": 30})
+assert r["sucesso"], "apelidos de ferramenta valem"
+print("OK: schedule_task cria pendente (desligada e sem aprovação); list_tasks e delete_task")
+
+# --- comando arriscado fora de rotina: perguntar também pra enviar e instalar ------------------------------
+for cmd in ("rm -rf ~/x", "git push origin main", "sudo apt install vlc", "pip install requests", "curl -X POST https://x.org -d a=1"):
+    assert tars._comando_e_perigoso(cmd), cmd
+for cmd in ("ls ~", "git pull", "curl https://x.org", "rm arquivo.txt", "echo oi"):
+    assert not tars._comando_e_perigoso(cmd), cmd
+
+# --- dentro de uma rotina ---------------------------------------------------------------------------------------
+cancelou = []
+tars.cancelar_resposta = lambda: cancelou.append(1)
+tars.confirmar_comando_hook = lambda c: (_ for _ in ()).throw(AssertionError("não pergunta na tela dentro de rotina"))
+aprovada = {"nome": "Limpeza", "aprovada": True, "permitidas": ["apagar"]}
+tars.ROTINA_ATUAL = aprovada
+assert tars._comando_e_perigoso("rm arquivo.txt"), "numa rotina, até o rm simples passa pela pré-aprovação"
+assert tars._confirmar_comando_perigoso("rm arquivo.txt") is True and not cancelou
+assert tars._confirmar_comando_perigoso("git push") is False
+assert tars.ROTINA_BLOQUEOU == ["git push"] and cancelou == [1], "fora do aprovado: para e guarda o comando"
+tars.ROTINA_BLOQUEOU.clear()
+cancelou.clear()
+tars.ROTINA_ATUAL = {"nome": "IA", "aprovada": False, "permitidas": ["apagar"]}
+assert tars._confirmar_comando_perigoso("rm -rf x") is False and cancelou == [1], "sem aprovação, nada passa"
+tars.ROTINA_ATUAL = None
+tars.ROTINA_BLOQUEOU.clear()
+
+r = tars.executar_terminal("rm -rf /tmp/arquivo-que-nao-existe-xyz")   # fora de rotina volta a perguntar (hook levanta erro = nega)
+assert not r["sucesso"], r
+
+# --- textos ---------------------------------------------------------------------------------------------------------
+print("test_rotinas_nucleo: OK")

app/tests/test_screenshot_resize.py

@@ -0,0 +1,46 @@
+import sys, types
+
+sys.modules['psutil'] = types.ModuleType('psutil')
+sys.modules['psutil'].process_iter = lambda *a, **k: []
+
+# pyautogui de verdade precisa de um display (Xorg/Wayland), que não
+# existe neste ambiente de teste — stub só o screenshot(), preservando
+# o resto do módulo como stub também (move/clique/tecla não são
+# exercitados por este teste).
+pyautogui_stub = types.ModuleType('pyautogui')
+pyautogui_stub.FAILSAFE = True
+pyautogui_stub.PAUSE = 0.1
+
+
+def _fake_screenshot():
+    from PIL import Image
+    return Image.new("RGB", (3840, 2160), color=(10, 20, 30))
+
+
+pyautogui_stub.screenshot = _fake_screenshot
+sys.modules['pyautogui'] = pyautogui_stub
+
+from _util import carregar_tars
+tars = carregar_tars()
+
+assert tars.pyautogui.PAUSE == tars.PYAUTOGUI_PAUSE_SEG, tars.pyautogui.PAUSE
+print("OK: pyautogui.PAUSE reduzido:", tars.pyautogui.PAUSE)
+
+# A captura real depende do display; aqui simula uma tela 4K.
+tars._capturar_tela = _fake_screenshot
+
+r = tars.tirar_print()
+assert r["sucesso"]
+print("mensagem:", r["mensagem"])
+assert "3840x2160" in r["mensagem"]
+assert f"{tars.LARGURA_MAXIMA_SCREENSHOT}x" in r["mensagem"]
+
+import base64
+import io
+from PIL import Image
+
+img = Image.open(io.BytesIO(base64.b64decode(r["_imagem_b64"])))
+assert img.size[0] == tars.LARGURA_MAXIMA_SCREENSHOT, img.size
+print("OK: imagem redimensionada de fato para", img.size)
+
+print("\nTUDO OK.")

app/tests/test_search_web.py

@@ -0,0 +1,57 @@
+"""Regressão do bug real reportado: 'pesquise rtx 5060 no google' foi
+pro qwen3:0.6b, que repassou só site='rtx 5060' pro open_website (sem
+o 'no google' nem o verbo), quebrando a busca.
+
+A correção NÃO foi interceptar a busca no texto cru antes da IA entrar
+em ação (isso seria só trocar um hardcode por outro, e a IA continuaria
+sem aprender a raciocinar direito) — foi dar pra IA uma ferramenta
+('search_web') onde o próprio formato já separa 'o que pesquisar'
+(query) de 'onde pesquisar' (service), então não tem como ela cortar a
+frase pela metade feito fazia com o campo genérico 'site' de
+open_website. Este teste garante que a ferramenta está de fato
+registrada e funcionando (antes dela, 'search_web' existia só na lista
+de ferramentas oferecida à IA, mas não tinha handler nenhum — ou seja,
+se qualquer modelo tentasse chamá-la, ia falhar com 'Ferramenta
+desconhecida')."""
+
+from _util import carregar_tars
+tars = carregar_tars()
+
+tars.webbrowser.open = lambda u: True
+
+# a ferramenta precisa estar de fato ligada ao dispatch (antes não
+# estava — só existia na lista TOOLS, sem handler nenhum)
+assert "search_web" in tars._DISPATCH_FERRAMENTAS
+print("OK: search_web está registrada no dispatch de ferramentas")
+
+# caso real reportado: query e service member, sem depender de cortar
+# frase nenhuma
+r = tars.executar_ferramenta("search_web", {"query": "rtx 5060", "service": "google"})
+assert r["sucesso"] and r["url"] == "https://www.google.com/search?q=rtx+5060", r
+print("OK: busca com serviço explícito:", r["url"])
+
+# sem 'service' -> padrão Google
+r = tars.executar_ferramenta("search_web", {"query": "buracos negros"})
+assert r["url"] == "https://www.google.com/search?q=buracos+negros", r
+print("OK: busca sem serviço cai no Google por padrão:", r["url"])
+
+# serviço youtube
+r = tars.executar_ferramenta("search_web", {"query": "canal da anthropic", "service": "youtube"})
+assert r["url"] == "https://www.youtube.com/results?search_query=canal+da+anthropic", r
+print("OK: busca no youtube:", r["url"])
+
+# query vazia é erro claro, não um chute
+r = tars.executar_ferramenta("search_web", {"query": "  "})
+assert not r["sucesso"]
+print("OK: query vazia retorna erro em vez de adivinhar algo")
+
+# open_website continua funcionando como rede de segurança pra quando
+# um modelo ainda assim usar ele pra uma frase de busca
+tars._SESSION.post = lambda *a, **k: (_ for _ in ()).throw(
+    AssertionError("nao deveria precisar de nenhum modelo pra uma busca reconhecida")
+)
+r = tars.abrir_site("pesquisar sobre gatos siameses")
+assert r["url"] == "https://www.google.com/search?q=gatos+siameses", r
+print("OK: open_website ainda reconhece frase de busca como rede de segurança:", r["url"])
+
+print("\nTUDO OK.")

app/tests/test_sem_falso_positivo_modelo.py

@@ -0,0 +1,41 @@
+from _util import carregar_tars
+tars = carregar_tars()
+
+catalogo_fake = {
+    "qwen3:0.6b": {"tag": "qwen3:0.6b", "familia": "qwen3", "categoria": "simples", "parametros_b": 0.6, "capacidades": {"tools"}, "capacidades_conhecidas": True},
+    "qwen3:8b": {"tag": "qwen3:8b", "familia": "qwen3", "categoria": "geral", "parametros_b": 8, "capacidades": {"tools"}, "capacidades_conhecidas": True},
+    "gemma3:12b": {"tag": "gemma3:12b", "familia": "gemma3", "categoria": "geral", "parametros_b": 12, "capacidades": set(), "capacidades_conhecidas": True},
+    "gemma3:270m": {"tag": "gemma3:270m", "familia": "gemma3", "categoria": "simples", "parametros_b": 0.27, "capacidades": set(), "capacidades_conhecidas": True},
+}
+tars.catalogar_modelos = lambda forcar=False: catalogo_fake
+tars.listar_modelos_instalados = lambda forcar=False: set(catalogo_fake.keys())
+tars._carregar_em_segundo_plano = lambda modelo: None
+
+def ia_nao_deveria_ser_chamada(*a, **k):
+    raise AssertionError("nao deveria ter chamado a IA classificadora pra essa frase (sem sinal de troca de modelo)")
+tars._SESSION.post = ia_nao_deveria_ser_chamada
+
+# O bug relatado: frase de tarefa comum contendo "use", nao deveria trocar de modelo
+tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+resultado = tars.interpretar_comando_modelo("use suas ferramentas para abrir o youtube no canal da anthropic")
+print("resultado:", resultado, "| modo:", tars.modo_modelo, "| modelo_manual:", tars.modelo_manual)
+assert resultado is False, "nao deveria ter sido reconhecido como comando de troca de modelo"
+assert tars.modo_modelo == "AUTO"
+assert tars.modelo_manual is None
+print("OK: 'use suas ferramentas...' nao dispara mais troca de modelo\n")
+
+# Outras frases comuns com verbos ambiguos que tambem nao deveriam disparar
+casos_normais = [
+    "quero abrir o navegador e ver meus emails",
+    "coloca a musica mais alta por favor",
+    "manda ver se tem espaco em disco",
+    "use a calculadora pra somar esses valores",
+]
+for frase in casos_normais:
+    tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+    resultado = tars.interpretar_comando_modelo(frase)
+    status = "OK" if resultado is False else "FALHOU"
+    print(f"{status:6} {frase!r}")
+    assert resultado is False, f"falso positivo em: {frase}"
+
+print("\nOK: nenhum falso positivo nas frases comuns testadas.")

app/tests/test_setup_gargantua.py

@@ -0,0 +1,80 @@
+"""O instalador não segura a instalação com o download de 2,5 GB quando não há terminal para mostrá-lo.
+
+Pela loja de aplicativos (PackageKit) o script roda sem terminal: um `ollama pull` na frente deixava a barra da loja
+parada em 0% por minutos enquanto o Ollama já estava em 50%. Sem terminal, o download vai pra segundo plano (o assistente
+de primeiro uso acompanha o mesmo download). Com terminal, continua na frente, com a barra do Ollama."""
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+RAIZ = Path(__file__).resolve().parent.parent
+setup = (RAIZ / "empacotamento" / "setup.sh").read_text(encoding="utf-8")
+inicio = setup.index('MODELO_GARGANTUA="${TARS_MODELO_GARGANTUA:-ProjectOpenTARS/Gargantua-2}"')
+fim = setup.index("# 4. Modelo de conversa")
+bloco = setup[inicio:fim]
+assert "gargantua_segundo_plano" in bloco and "[ -t 1 ]" in bloco
+
+pasta = Path(tempfile.mkdtemp())
+(pasta / "bin").mkdir()
+registro = pasta / "chamadas.log"
+fim_do_pull = pasta / "pull-terminou"
+falso = pasta / "bin" / "ollama"
+falso.write_text(f'#!/bin/bash\necho "ollama $*" >> "{registro}"\nsleep 2\ntouch "{fim_do_pull}"\n')
+falso.chmod(0o755)
+(pasta / "harness.sh").write_text(
+    'servico_pronto=1\n'
+    'msg()   { echo "MSG: $*"; }\n'
+    'aviso() { echo "AVISO: $*"; }\n'
+    't() { echo "T:$1"; }\n'
+    'modelos_instalados() { echo ""; }\n' + bloco + '\necho "FIM-DO-BLOCO"\n')
+env = dict(os.environ, PATH=f"{pasta / 'bin'}:{os.environ['PATH']}")
+
+
+def rodar(com_terminal):
+    fim_do_pull.unlink(missing_ok=True)
+    registro.unlink(missing_ok=True)
+    t0 = time.time()
+    if com_terminal:
+        r = subprocess.run(["script", "-qec", f"bash {pasta / 'harness.sh'}", "/dev/null"], env=env, capture_output=True,
+                           text=True, timeout=60)
+    else:
+        r = subprocess.run(["bash", str(pasta / "harness.sh")], env=env, capture_output=True, text=True, timeout=60)
+    return r.stdout, time.time() - t0
+
+
+# 1) SEM terminal: o bloco termina logo, o pull roda solto e nada de "não baixou" (ele ainda está baixando)
+saida, segundos = rodar(com_terminal=False)
+assert "FIM-DO-BLOCO" in saida and "T:gargantua_segundo_plano" in saida, saida
+assert "T:nao_baixou" not in saida and "T:pode_demorar" not in saida, saida
+assert segundos < 1.5, f"o instalador esperou o download ({segundos:.1f}s): a loja ficaria parada"
+limite = time.time() + 10
+while not fim_do_pull.exists() and time.time() < limite:
+    time.sleep(0.1)
+assert fim_do_pull.exists(), "o download em segundo plano não rodou até o fim"
+assert "ollama pull ProjectOpenTARS/Gargantua" in registro.read_text()
+print(f"OK: sem terminal o instalador termina em {segundos:.1f}s e o download segue solto, em segundo plano")
+
+# 2) COM terminal: baixa na frente (a barra do Ollama aparece), como sempre foi
+if shutil.which("script"):
+    saida, segundos = rodar(com_terminal=True)
+    assert "T:pode_demorar" in saida and "T:gargantua_segundo_plano" not in saida, saida
+    assert segundos >= 2 and fim_do_pull.exists(), f"deveria esperar o download na frente ({segundos:.1f}s)"
+    assert "ollama pull ProjectOpenTARS/Gargantua" in registro.read_text()
+    print(f"OK: com terminal o download continua na frente ({segundos:.1f}s), com a barra do Ollama")
+else:
+    print("PULADO (com terminal): comando 'script' não encontrado")
+
+# 3) já instalado: não baixa nada (antes e depois da mudança)
+(pasta / "harness.sh").write_text((pasta / "harness.sh").read_text().replace('modelos_instalados() { echo ""; }',
+                                                                              'modelos_instalados() { echo "ProjectOpenTARS/Gargantua:latest"; }'))
+fim_do_pull.unlink(missing_ok=True)
+registro.unlink(missing_ok=True)
+saida = subprocess.run(["bash", str(pasta / "harness.sh")], env=env, capture_output=True, text=True, timeout=30).stdout
+assert "T:gargantua_ja" in saida and not registro.exists(), saida
+print("OK: com o Gargantua já instalado não baixa nada")
+
+print("\nTUDO OK.")

app/tests/test_shell_portatil.py

@@ -0,0 +1,120 @@
+"""5.2 (F5): o mini-shell em Python (tars_shell) contra o bash de verdade, com as formas de comando dos dados de treino.
+Cada comando roda nos dois lados a partir da mesma casa; saída, erro, código e os arquivos que sobram têm de bater."""
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import tars_shell as sh  # noqa: E402
+
+# a referência é o bash com o coreutils do GNU: no macOS o ls e o wc são outros, no Windows o bash é o do Git
+COMPARAR = sys.platform.startswith("linux") and bool(shutil.which("bash"))
+
+COMANDOS = [
+    "mkdir -p ~/Documents/Trabalho",
+    "echo 'study for the exam' > ~/Downloads/notes.txt",
+    "ls -1 ~/Downloads",
+    "ls -1 ~/Downloads | wc -l",
+    "mv ~/Downloads/notes.txt ~/Downloads/ideas.txt",
+    'mkdir -p "${HOME}/Documents/Jogos" && echo "llamar al dentista" > "${HOME}/Documents/Jogos/tareas.txt"',
+    "mkdir -p ~/Área\\ de\\ Trabalho && printf \"reunião às 15h\" > ~/Área\\ de\\ Trabalho/lembrete.txt",
+    "ls -1 '{casa}/Área de Trabalho'",
+    "rm -rf ~/Documents/Trabalho",
+    "echo 'pay the power bill' >> ~/Desktop/list.txt && echo 'call the dentist' >> ~/Desktop/list.txt",
+    "wc -l ~/Desktop/list.txt",
+    "cat ~/Desktop/list.txt",
+    "touch ~/Documents/a.txt && ls -1 ~/Documents",
+    *(['mkdir -p "$(xdg-user-dir DOCUMENTS)/Proyectos" && echo "x" > "$(xdg-user-dir DOCUMENTS)/Proyectos/a.txt"']
+      if shutil.which("xdg-user-dir") else []),     # sem o programa (o runner do GitHub) o bash não serve de referência
+    "ls -1 /caminho/que/nao/existe",
+    "mkdir ~/Desktop",
+    "mkdir ~/Desktop || echo falhou",
+    "echo \"say \\\"hi\\\"\" > ~/q.txt && cat ~/q.txt",
+    "ls -1 ~/Documents/*.txt",
+    "ls -1 ~/Documents | grep -i a",
+    "find ~/Documents -name '*.txt' | sort",
+    "cat ~/nada.txt 2>/dev/null; echo fim",
+    "rm ~/Documents/a.txt && ls -1 ~/Documents | wc -l",
+    "cd ~/Downloads && ls -1",
+    "wc -l ~/Desktop/list.txt ~/q.txt",
+    "head -n 1 ~/Desktop/list.txt",
+    "mv ~/Downloads/ideas.txt ~/Documents/ && ls -1 ~/Documents",
+    "rm -rf ~/Documents/Jogos ~/Documents/Proyectos ~/Documentos/Proyectos",
+]
+
+
+def arvore(casa):
+    return sorted((str(p.relative_to(casa)), p.read_text(errors="replace") if p.is_file() else None)
+                  for p in casa.rglob("*") if ".config" not in p.parts)
+
+
+def nova_casa():
+    casa = Path(tempfile.mkdtemp(prefix="opentars-shell-"))
+    for pasta in ("Documents", "Downloads", "Desktop", "Documentos"):
+        (casa / pasta).mkdir()
+    (casa / ".config").mkdir()
+    (casa / ".config" / "user-dirs.dirs").write_text('XDG_DOCUMENTS_DIR="$HOME/Documentos"\n')
+    return casa
+
+
+bash_casa, py_casa = nova_casa(), nova_casa()
+diferencas = []
+for modelo in (COMANDOS if COMPARAR else []):
+    resultados = []
+    for casa, lado in ((bash_casa, "bash"), (py_casa, "py")):
+        comando = modelo.replace("{casa}", str(casa))
+        os.environ.update(HOME=str(casa), USERPROFILE=str(casa), XDG_CONFIG_HOME=str(casa / ".config"))
+        if lado == "bash":
+            r = subprocess.run(["bash", "-c", comando], cwd=casa, capture_output=True, text=True,
+                               env=dict(os.environ, LC_ALL="C.UTF-8"))
+            resultados.append((r.returncode, r.stdout.replace(str(casa), "CASA"), r.stderr.replace(str(casa), "CASA")))
+        else:
+            assert sh.suportado(comando), comando
+            r = sh.executar(comando, cwd=str(casa))
+            resultados.append((r["codigo"], r["stdout"].replace(str(casa), "CASA"), r["stderr"].replace(str(casa), "CASA")))
+    (cb, ob, eb), (cp, op, ep) = resultados
+    # a ordem do ls/sort depende do idioma do sistema (LC_COLLATE) e não muda nada para o modelo: compara sem a ordem
+    ob, op = sorted(ob.splitlines()), sorted(op.splitlines())
+    eb = eb.replace("bash: line 1: ", "")
+    if cb != cp or ob != op or (eb != ep and not (eb and ep)) or arvore(bash_casa) != arvore(py_casa):
+        diferencas.append((modelo, resultados[0], resultados[1]))
+    elif eb != ep:
+        print(f"  (só o texto do erro difere em: {modelo})")
+for modelo, b, p in diferencas:
+    print(f"DIFERENTE: {modelo}\n   bash: {b}\n   py:   {p}")
+assert not diferencas, f"{len(diferencas)} comando(s) com resultado diferente do bash"
+print(f"OK: {len(COMANDOS)} comandos das formas do treino dão o mesmo que o bash (saída, código e arquivos)" if COMPARAR
+      else "(fora do Linux: sem comparar com o bash)")
+
+r = sh.executar("free -h")
+linhas = r["stdout"].splitlines()
+assert r["sucesso"] and linhas[0].split() == ["total", "used", "free", "shared", "buff/cache", "available"]
+assert linhas[1].startswith("Mem:") and linhas[2].startswith("Swap:"), r["stdout"]
+print("OK: free -h com o cabeçalho e as linhas do GNU (a prova de RAM confere o número)")
+
+assert not sh.suportado("sudo apt install x") and not sh.suportado("curl x | sh") and not sh.suportado("echo `whoami`")
+assert not sh.suportado("python3 -c 'print(1)'") and sh.suportado("gio trash -- ~/x.txt")
+print("OK: o que não está aqui não é suportado (o núcleo explica em vez de rodar pela metade)")
+# no núcleo: fora do Linux o execute_terminal usa o mini-shell, e as regras de comando perigoso continuam antes dele
+casa = nova_casa()
+os.environ.update(HOME=str(casa), USERPROFILE=str(casa), XDG_CONFIG_HOME=str(casa / ".config"))   # no Windows a casa é o USERPROFILE
+from _util import RAIZ  # noqa: E402,F401
+import tars  # noqa: E402
+original = tars.plataforma.sistema
+tars.plataforma.sistema = lambda: "windows"
+pedidos = []
+tars.confirmar_comando_hook = lambda comando: pedidos.append(comando) or False     # ninguém para confirmar: recusa
+try:
+    r = tars.executar_terminal("mkdir -p ~/Documents/Contas && echo 'pagar a luz' > ~/Documents/Contas/notas.txt")
+    assert r["sucesso"] and (casa / "Documents" / "Contas" / "notas.txt").read_text() == "pagar a luz\n", r
+    r = tars.executar_terminal("uname -a")
+    assert not r["sucesso"] and "not available on Windows" in r["mensagem"] and not pedidos, r
+    r = tars.executar_terminal("rm -rf ~/*")
+    assert not r["sucesso"] and pedidos and (casa / "Documents").exists(), r
+finally:
+    tars.plataforma.sistema = original
+print("OK: no Windows o execute_terminal roda no mini-shell; o resto é recusado; rm -rf ~/* ainda pede confirmação")
+print("test_shell_portatil: TUDO OK.")

app/tests/test_sob_demanda.py

@@ -0,0 +1,65 @@
+"""Tudo sob demanda: nada é carregado ao abrir, e o que fica ocioso sai da memória cedo."""
+import os
+import sys
+import tempfile
+import time
+
+CASA = tempfile.mkdtemp(prefix="opentars-casa-")
+os.environ["HOME"] = CASA
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(CASA, "sessoes.json")
+for v in ("TARS_KEEP_ALIVE", "TARS_KEEP_ALIVE_VISAO", "TARS_KEEP_ALIVE_AJUDANTE", "TARS_PRECARGA"):
+    os.environ.pop(v, None)
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+
+# 1. Tempos padrão: conversa 5 min; visão e ajudante 2 min (eram 30 min pra todos)
+assert tars.KEEP_ALIVE == "5m" and tars.KEEP_ALIVE_VISAO == "2m" and tars.KEEP_ALIVE_AJUDANTE == "2m"
+print("OK: modelo da conversa 5 min, visão e ajudante 2 min na memória")
+
+# 2. Abrir o openTARS não carrega nada (nem Murph em fio, nem Cooper)
+import threading  # noqa: E402
+THREAD_REAL = threading.Thread
+fios = []
+tars.threading.Thread = lambda *a, **k: fios.append(k) or type("T", (), {"start": lambda s: fios.append("start")})()
+tars.aquecer_ajudante()
+assert fios == [], fios
+print("OK: aquecer_ajudante não dispara nada sem TARS_PRECARGA")
+tars.PRECARGA = True
+tars.aquecer_visao = lambda: fios.append("cooper")
+tars.aquecer_ajudante()
+assert "cooper" in fios and "start" in fios
+tars.PRECARGA = False
+print("OK: TARS_PRECARGA=1 devolve a pré-carga")
+
+# 3. O Cooper usa o tempo curto de visão
+tars.threading.Thread = THREAD_REAL
+pedidos = []
+
+
+class Resp:
+    status_code = 200
+
+    def json(self):
+        return {"message": {"content": '{"x": 500, "y": 500}'}}
+
+
+tars._SESSION.post = lambda url, json=None, timeout=None, **k: pedidos.append(json) or Resp()
+tars._visao_estado.update(pausado_ate=0.0, quente=False, erro="")
+tars.perguntar_visao("ProjectOpenTARS/cooper:latest", "onde?", imagem_b64="AAAA")
+assert pedidos[-1]["keep_alive"] == "2m", pedidos[-1]
+print("OK: o Cooper sai da memória 2 min depois do último uso")
+
+# 4. Digitar aquece o modelo da conversa (1x a cada 30 s) e não toca em servidor externo
+pedidos.clear()
+tars.modo_modelo = "MANUAL"
+tars.modelo_manual = "qwen3:4b"
+tars._ultimo_aquecimento["em"] = 0.0
+tars.aquecer_modelo_da_conversa()
+tars.aquecer_modelo_da_conversa()
+time.sleep(0.3)
+assert len(pedidos) == 1 and pedidos[0]["model"] == "qwen3:4b" and pedidos[0]["prompt"] == "" and pedidos[0]["keep_alive"] == "5m", pedidos
+print("OK: ao digitar, o modelo da conversa é aquecido uma única vez (a cada 30 s)")
+print("\nTUDO OK.")

app/tests/test_superlativos.py

@@ -0,0 +1,54 @@
+from _util import carregar_tars
+tars = carregar_tars()
+
+catalogo_fake = {
+    "qwen3:0.6b": {"tag": "qwen3:0.6b", "familia": "qwen3", "categoria": "simples", "parametros_b": 0.6, "capacidades": {"tools"}, "capacidades_conhecidas": True},
+    "qwen3:32b": {"tag": "qwen3:32b", "familia": "qwen3", "categoria": "tecnico", "parametros_b": 32, "capacidades": {"tools"}, "capacidades_conhecidas": True},
+}
+tars.catalogar_modelos = lambda forcar=False: catalogo_fake
+tars.listar_modelos_instalados = lambda forcar=False: set(catalogo_fake.keys())
+tars._carregar_em_segundo_plano = lambda modelo: None
+tars._SESSION.post = lambda *a, **k: (_ for _ in ()).throw(AssertionError("nao deveria precisar da IA"))
+
+# Via "/modelo" — aceita a frase toda, com verbos e "por favor" e
+# qualquer coisa em volta (substring é seguro aqui, porque o "/modelo"
+# já deixou explícito que o pedido é sobre trocar de IA).
+casos_com_modelo = {
+    "/modelo usa o mais leve": "qwen3:0.6b",
+    "/modelo quero o modelo mais leve": "qwen3:0.6b",
+    "/modelo troca pro maior modelo": "qwen3:32b",
+}
+for frase, esperado in casos_com_modelo.items():
+    tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+    ok = tars.interpretar_comando_modelo(frase)
+    status = "OK" if (ok and tars.modelo_manual == esperado) else "FALHOU"
+    print(f"{status:6} {frase!r:35} -> {tars.modelo_manual} (esperado {esperado})")
+    assert ok and tars.modelo_manual == esperado
+
+# Sem "/modelo", só a frase EXATA do superlativo (mensagem inteira,
+# sem nada em volta) ainda troca — nunca um pedaço dela dentro de uma
+# frase qualquer, que é justamente o que causava falso positivo antes.
+tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+ok = tars.interpretar_comando_modelo("mais leve")
+assert ok and tars.modelo_manual == "qwen3:0.6b"
+print("OK: mensagem inteira == 'mais leve' troca sem precisar de /modelo")
+
+# "o menor problema pode causar um erro grande no sistema" contém "o
+# menor" como substring, mas não é a frase inteira "o menor" — não
+# deve trocar de modelo (essa era exatamente a armadilha do bug
+# original "isso foi meio burro").
+tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+ok = tars.interpretar_comando_modelo("o menor problema pode causar um erro grande no sistema")
+print("frase-armadilha 'o menor problema...':", ok, tars.modelo_manual)
+assert ok is False
+assert tars.modelo_manual is None
+
+# "usa o mais leve" SEM /modelo também não deve mais trocar — trocar a
+# partir de um verbo solto foi removido de propósito.
+tars.modo_modelo = "AUTO"; tars.modelo_manual = None
+ok = tars.interpretar_comando_modelo("usa o mais leve")
+assert ok is False
+assert tars.modelo_manual is None
+print("OK: 'usa o mais leve' sem /modelo não troca mais (por design)")
+
+print("\nOK: superlativos via /modelo continuam flexíveis, e nada solto no meio de uma frase dispara troca.")

app/tests/test_tarefa_com_print.py

@@ -0,0 +1,148 @@
+"""Tarefa que depende de print de tela ("abra a calculadora e clique nos
+números"), reproduzindo o que um modelo de visão real fez:
+
+1. O print era anexado como "(print da tela anexado acima — analise a
+   imagem)" numa mensagem de usuário: o modelo achava que o usuário
+   tinha mandado uma imagem nova, esquecia a tarefa e só descrevia a tela.
+2. Depois disso ele "pensava" e não respondia nada — e o openTARS
+   encerrava a tarefa pela metade.
+3. O print vai reduzido pra IA (ex: 2560 -> 1280 de largura), mas o
+   clique usava a coordenada da imagem direto na tela real: caía no
+   lugar errado.
+
+A parte 3 roda de verdade num display (Xvfb) se houver; senão é pulada.
+"""
+
+import os
+import sys
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+PEDIDO = "abra a calculadora e clique em 7, +, 2 e ="
+
+# ------------------------------------------------------------------
+# 1 e 2: conversa com um "modelo" roteirizado
+# ------------------------------------------------------------------
+vistos = []
+roteiro = iter([
+    {"content": "", "tool_calls": [{"function": {"name": "take_screenshot", "arguments": {}}}]},
+    {"content": "", "tool_calls": []},  # pensa e não responde
+    {"content": "", "tool_calls": [{"function": {"name": "click_mouse", "arguments": {"x": 10, "y": 20}}}]},
+    {"content": "", "tool_calls": [{"function": {"name": "take_screenshot", "arguments": {}}}]},
+    {"content": "Pronto: 7 + 2 = 9.", "tool_calls": []},
+])
+
+
+def turno_falso(modelo, mensagens, tools, **kw):
+    vistos.append([dict(m) for m in mensagens])
+    return next(roteiro), None
+
+
+cliques = []
+tars._executar_turno_streaming = turno_falso
+tars.carregar_modelo = lambda m: True
+tars._DISPATCH_FERRAMENTAS["take_screenshot"] = lambda a: {
+    "sucesso": True, "mensagem": "print ok", "_imagem_b64": "AAAA"}
+tars._DISPATCH_FERRAMENTAS["click_mouse"] = lambda a: cliques.append(a) or {
+    "sucesso": True, "mensagem": "clicou"}
+tars.SESSAO_GRAFICA = "x11"
+tars.modo_modelo = "MANUAL"
+
+resposta = tars.perguntar_modelo("modelo-visao", PEDIDO)
+
+msg_print = vistos[1][-1]
+assert msg_print["role"] == "user" and msg_print.get("images") == ["AAAA"], msg_print
+assert PEDIDO in msg_print["content"] and "not from the user" in msg_print["content"], msg_print["content"]
+print("OK: o print chega junto com o pedido original, marcado como mensagem automática")
+
+assert PEDIDO in vistos[2][-1]["content"] and not vistos[2][-1].get("images"), vistos[2][-1]
+assert cliques == [{"x": 10, "y": 20}], cliques
+assert resposta == "Pronto: 7 + 2 = 9.", resposta
+com_imagem = [m for m in vistos[-1] if m.get("images")]
+assert len(com_imagem) == 1 and com_imagem[0] is not None, len(com_imagem)
+assert vistos[-1][-1].get("images"), "o print mais novo tem que ficar"
+print("OK: só o print mais recente fica na conversa (economiza contexto)")
+
+payloads = []
+import importlib.util
+spec = importlib.util.spec_from_file_location("tars2", tars.__file__)
+t2 = importlib.util.module_from_spec(spec); spec.loader.exec_module(t2)
+t2._chamar_ollama_stream = lambda p: (payloads.append(p), (None, "sem ollama"))[1]
+t2.detectar_gpu = lambda forcar=False: {"vram_total_gb": 24.0, "vram_livre_gb": 20.0}
+t2._executar_turno_streaming("m", [{"role": "user", "content": "oi"}], None)
+assert payloads[-1]["options"]["num_ctx"] == 16384, payloads[-1]["options"]
+t2.detectar_gpu = lambda forcar=False: None
+t2._executar_turno_streaming("m", [{"role": "user", "content": "oi"}], None)
+assert payloads[-1]["options"]["num_ctx"] == 8192, payloads[-1]["options"]
+print("OK: contexto pedido ao Ollama cabe ferramentas + print (16k com GPU >=16GB, senão 8k)")
+print("OK: quando a IA para sem responder, o openTARS pede pra continuar e a tarefa termina")
+
+# Resposta vazia na PRIMEIRA mensagem (sem ferramenta antes) não cutuca.
+roteiro = iter([{"content": "", "tool_calls": []}])
+vistos.clear()
+tars.perguntar_modelo("modelo-visao", "oi")
+assert len(vistos) == 1
+print("OK: resposta vazia sem tarefa em andamento não gera insistência")
+
+
+# ------------------------------------------------------------------
+# 3: clique de verdade, tela 2560x1440, print reduzido pra 1280x720
+# ------------------------------------------------------------------
+if not os.environ.get("DISPLAY"):
+    print("PULADO (parte real): sem DISPLAY")
+    print("\nTUDO OK.")
+    sys.exit(0)
+
+os.environ.setdefault("XAUTHORITY", "/dev/null")
+for nome in ("pyautogui", "psutil", "tars"):
+    sys.modules.pop(nome, None)
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+import tkinter as tk  # noqa: E402
+
+import tars as real  # noqa: E402
+
+if real.ERRO_PYAUTOGUI:
+    print(f"PULADO (parte real): {real.ERRO_PYAUTOGUI}")
+    sys.exit(0)
+
+largura_tela, altura_tela = real.pyautogui.size()
+if largura_tela <= real.LARGURA_MAXIMA_SCREENSHOT:
+    print(f"PULADO (parte real): tela {largura_tela}px não é reduzida no print")
+    sys.exit(0)
+
+janela = tk.Tk()
+janela.geometry("+900+500")
+visor = tk.StringVar(value="")
+botoes = {}
+for i, rotulo in enumerate(["7", "+", "2", "="]):
+    b = tk.Button(janela, text=rotulo, width=6, height=3,
+                  command=lambda r=rotulo: visor.set(visor.get() + r))
+    b.grid(row=0, column=i)
+    botoes[rotulo] = b
+tk.Label(janela, textvariable=visor).grid(row=1, columnspan=4)
+for _ in range(20):
+    janela.update()
+
+r = real.tirar_print()
+assert r["sucesso"] and "1280x720" in r["mensagem"], r["mensagem"]
+fator = largura_tela / 1280
+
+for rotulo in ["7", "+", "2", "="]:
+    b = botoes[rotulo]
+    # Onde o botão aparece NO PRINT (o que a IA vê e responde)
+    x_img = (b.winfo_rootx() + b.winfo_width() / 2) / fator
+    y_img = (b.winfo_rooty() + b.winfo_height() / 2) / fator
+    real.clicar_mouse("left", x_img, y_img)
+    for _ in range(10):
+        janela.update()
+
+assert visor.get() == "7+2=", f"visor: {visor.get()!r}"
+escala = real._escala_tela_inteira()
+tam = (round(largura_tela / escala), round(altura_tela / escala))
+assert tam == (1280, 720), tam
+janela.destroy()
+print(f"OK: tela real {largura_tela}x{altura_tela}, cliques com coordenadas do print 1280x720 acertaram os 4 botões")
+
+print("\nTUDO OK.")

app/tests/test_tarefa_longa.py

@@ -0,0 +1,83 @@
+"""4.1: tarefas longas. Antes todo pedido parava em 20 idas-e-voltas.
+Agora:
+- pedido com plano começa com mais (20 + 6 por etapa além da segunda, até 50);
+- enquanto a IA faz progresso de verdade (ações que deram certo), ganha
+  mais 20 de fôlego, até o teto (TARS_LIMITE_ETAPAS, 120);
+- andar em círculos só olhando a tela continua parando em 20;
+- os resultados de ferramenta antigos do mesmo pedido são encurtados."""
+
+import json
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+assert tars.limite_de_ciclos([]) == 20 and tars.limite_de_ciclos(["a", "b"]) == 20
+assert tars.limite_de_ciclos(["a", "b", "c", "d"]) == 32 and tars.limite_de_ciclos(list("abcdefghij")) == 50
+assert tars._merece_folego(20, 15, 0) and not tars._merece_folego(20, 3, 3) and not tars._merece_folego(120, 99, 0)
+print("OK: limite inicial cresce com o plano; fôlego só com ação nova e abaixo do teto")
+
+tars.catalogar_modelos = lambda forcar=False: {}
+tars.carregar_modelo = lambda mod, silencioso=False: True
+tars.ollama_online = lambda: True
+tars.modo_modelo = "MANUAL"
+tars.modelo_manual = "qwen3:8b"
+tars.salvar_sessoes = lambda: None
+tars._contexto_do_pedido = lambda *a, **k: None
+feitos = []
+tars._DISPATCH_FERRAMENTAS["open_application"] = lambda a: feitos.append(a["app"]) or {
+    "sucesso": True, "mensagem": "SUCCESS: opened " + a["app"] + " " + "x" * 2000}
+tars._DISPATCH_FERRAMENTAS["list_windows"] = lambda a: {"sucesso": True, "mensagem": "1 window", "janelas": []}
+assert "list_windows" in tars._FERRAMENTAS_SO_OLHAM
+
+ACOES = 45
+maior_conversa = [0]
+
+
+def turno_trabalhador(modelo, msgs, tools, pensar=True, **kw):
+    maior_conversa[0] = max(maior_conversa[0], sum(len(m.get("content") or "") for m in msgs))
+    if len(feitos) < ACOES:
+        return {"content": "", "tool_calls": [{"function": {"name": "open_application",
+                                                            "arguments": {"app": f"app{len(feitos)}"}}}]}, None
+    return {"content": f"Pronto: abri os {ACOES} apps.", "tool_calls": []}, None
+
+
+tars._executar_turno_streaming = turno_trabalhador
+resposta = tars.perguntar_modelo("qwen3:8b", "abra os 45 apps da lista", tarefa="acao")
+assert resposta == f"Pronto: abri os {ACOES} apps." and len(feitos) == ACOES, (resposta, len(feitos))
+folegos = [m for m in tars.conversa if "Long task in progress" in (m.get("content") or "")]
+assert len(folegos) == 2, len(folegos)
+resultados = [m["content"] for m in tars.conversa if m.get("role") == "tool"]
+assert all(len(r) < 700 for r in resultados[:-tars.RESULTADOS_INTEIROS]), [len(r) for r in resultados]
+inteiros = resultados[-tars.RESULTADOS_INTEIROS:]
+assert len(inteiros[-1]) > 2000, "o resultado mais novo fica inteiro"
+assert sum(len(r) for r in inteiros) <= int(tars.contexto_ia() * 3 * 0.4) + len(inteiros[-1]), "os 'inteiros' cabem no orçamento do contexto"
+print(f"OK: 45 ações seguidas terminam (2 fôlegos extras); resultados antigos encurtados "
+      f"(maior conversa: {maior_conversa[0] // 1000} mil caracteres)")
+
+# Em círculos, só olhando: para no limite de sempre
+tars.limpar_sessao()
+olhadas = []
+
+
+def turno_que_so_olha(modelo, msgs, tools, pensar=True, **kw):
+    olhadas.append(1)
+    return {"content": "", "tool_calls": [{"function": {"name": "list_windows",
+                                                        "arguments": {"filtro": str(len(olhadas))}}}]}, None
+
+
+tars._executar_turno_streaming = turno_que_so_olha
+resposta = tars.perguntar_modelo("qwen3:8b", "faz alguma coisa", tarefa="acao")
+assert len(olhadas) == 20 and "20" in resposta, (len(olhadas), resposta)
+print("OK: sem progresso (só olhando), para nas 20 etapas de sempre")
+
+# Teto
+tars.limpar_sessao()
+feitos.clear()
+ACOES = 10_000
+tars._executar_turno_streaming = turno_trabalhador
+resposta = tars.perguntar_modelo("qwen3:8b", "abra tudo", tarefa="acao")
+assert len(feitos) == tars.LIMITE_CICLOS_MAX == 120 and "120" in resposta, (len(feitos), resposta)
+print("OK: mesmo fazendo progresso, para no teto de 120 etapas")
+
+print("\nTUDO OK.")

app/tests/test_terminal_tela_cheia.py

@@ -0,0 +1,48 @@
+"""16/10: programas de tela cheia (htop, vim, less...) abrem numa janela de terminal em vez de rodar sem terminal, onde
+falhavam com "Error opening terminal" e o modelo concluía que não estavam instalados. Comando com pipe, redirecionamento
+ou 'top -b' continua rodando normal (é texto). Sem sessão gráfica, a mensagem sugere um comando sem tela. O comando
+perigoso continua passando pela confirmação antes."""
+import os
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+for comando, esperado in (("htop", "htop"), ("sudo nano /etc/hosts", "nano"), ("vim notas.txt", "vim"), ("man ls", "man"),
+                          ("TERM=xterm less x.log", "less"), ("/usr/bin/btop", "btop"), ("top", "top"),
+                          ("top -bn1", None), ("top -b -n 1", None), ("htop | head", None), ("less x > y", None),
+                          ("ls -la", None), ("free -h", None), ("echo htop", None), ("cd x && vim y", None)):
+    assert tars.programa_de_tela(comando) == esperado, (comando, tars.programa_de_tela(comando))
+print("OK: reconhece programa de tela cheia sozinho, e não com pipe, redirecionamento ou 'top -b'")
+
+abertos = []
+
+
+class Popen:
+    def __init__(self, argv, **k):
+        abertos.append(argv)
+
+
+real_popen, real_which = tars.subprocess.Popen, tars.shutil.which
+tars.subprocess.Popen = Popen
+tars.shutil.which = lambda p: "/usr/bin/" + p if p in ("gnome-terminal", "xterm") else None
+os.environ["DISPLAY"] = ":99"
+r = tars.executar_terminal("htop")
+assert r["sucesso"] and "terminal window" in r["mensagem"] and "gnome-terminal" in r["mensagem"], r
+assert abertos[-1][:4] == ["gnome-terminal", "--", "bash", "-c"] and abertos[-1][4].startswith("htop;"), abertos
+print("OK: htop abre numa janela de terminal e o modelo fica sabendo")
+
+tars.shutil.which = lambda p: None
+r = tars.executar_terminal("htop")
+assert not r["sucesso"] and "top -bn1" in r["mensagem"]
+os.environ.pop("DISPLAY", None)
+os.environ.pop("WAYLAND_DISPLAY", None)
+r = tars.executar_terminal("vim x")
+assert not r["sucesso"] and "no graphical session" in r["mensagem"]
+print("OK: sem terminal instalado ou sem sessão gráfica, a mensagem sugere um comando sem tela")
+
+tars.subprocess.Popen, tars.shutil.which = real_popen, real_which
+r = tars.executar_terminal("echo oi")
+assert r["sucesso"] and "oi" in r["stdout"], r
+print("OK: comando comum continua igual")
+print("\nTUDO OK.")

app/tests/test_textos.py

@@ -0,0 +1,81 @@
+"""Travas contra defeitos que já aconteceram (16/10), para pegar antes de publicar:
+  * pt_BR e en com as mesmas chaves, os mesmos tipos e os mesmos {campos} (campo diferente derruba o format);
+  * toda chave t("...") escrita no código existe nos dois idiomas (chave faltando aparece crua na tela), e também as
+    famílias montadas com f-string (probes.r.sis_{condição} etc.);
+  * nenhum texto dos idiomas nem literal das telas Qt usa glifo fora da IBM Plex (o "●" derrubou a janela nos Probes);
+  * todo .py do app compila."""
+import json
+import py_compile
+import re
+import sys
+import tempfile
+from pathlib import Path
+
+from _util import RAIZ
+
+RAIZ = Path(RAIZ)
+pt = json.loads((RAIZ / "idiomas" / "pt_BR.json").read_text(encoding="utf-8"))
+en = json.loads((RAIZ / "idiomas" / "en.json").read_text(encoding="utf-8"))
+campos = lambda v: sorted(re.findall(r"\{(\w+)", v)) if isinstance(v, str) else None  # noqa: E731
+
+assert set(pt) == set(en), f"chaves só num idioma: {sorted(set(pt) ^ set(en))}"
+assert not [k for k in pt if type(pt[k]) is not type(en[k])], "tipos diferentes entre idiomas"
+diferentes = [k for k in pt if campos(pt[k]) != campos(en[k])]
+assert not diferentes, f"{{campos}} diferentes entre pt_BR e en: {diferentes}"
+print(f"OK: pt_BR e en com as mesmas {len(pt)} chaves, tipos e campos")
+
+fontes_py = [p for p in RAIZ.rglob("*.py") if not set(p.relative_to(RAIZ).parts[:1]) & {"build", "dist", "tests", "gargantua"}]
+usadas = {}
+for p in fontes_py:
+    for m in re.finditer(r"""\bt\(\s*["']([\w.]+)["']""", p.read_text(encoding="utf-8")):
+        usadas.setdefault(m.group(1), p.name)
+faltam = {k: arq for k, arq in usadas.items() if k not in pt}
+assert not faltam, f"chaves usadas no código que não existem nos idiomas: {faltam}"
+sys.path.insert(0, str(RAIZ))
+import tars_modos  # noqa: E402
+import tars_probes as tp  # noqa: E402
+familias = ([f"probes.tipo.{x}" for x in ("pasta", "web", "feed", "sistema", "programa", "git", "palavras")]
+            + [f"probes.tipo.{x}_ex" for x in ("pasta", "web", "feed", "sistema", "programa", "git", "palavras")]
+            + [f"acoes.{g}.{x}" for g, xs in (("aba", ("reescrever", "resumir", "traduzir", "perguntar")),
+                                               ("resultado", ("reescrever", "resumir", "traduzir", "perguntar")),
+                                               ("opcao", ("corrigir", "formal", "informal", "para_en", "para_pt"))) for x in xs]
+            + [f"acoes.atalho_{s}" for s in ("linux", "windows", "macos")]
+            + [f"probes.r.sis_{c}" for c in tp.CONDICOES_DO_SISTEMA] + [f"probes.pp.q_sis_{c}" for c in tp.CONDICOES_DO_SISTEMA]
+            + [f"probes.pp.n_sis_{c}" for c in tp.CONDICOES_DO_SISTEMA] + [f"probes.f.sis_{c}" for c in tp.CONDICOES_DO_SISTEMA]
+            + [f"probes.r.prog_{e}" for e in tp.EVENTOS_DO_PROGRAMA] + [f"probes.pp.q_prog_{e}" for e in tp.EVENTOS_DO_PROGRAMA]
+            + [f"probes.f.prog_{e}" for e in tp.EVENTOS_DO_PROGRAMA]
+            + [f"probes.erro_{e}" for e in ("json", "ferramentas", "sem_modelo", "sem_resposta", "missao", "limite", "destino")]
+            + [f"modo.{m}.{x}" for m in tars_modos.MODOS for x in ("nome", "desc")])
+assert not [k for k in familias if k not in pt], f"chaves dinâmicas faltando: {[k for k in familias if k not in pt]}"
+print(f"OK: as {len(usadas)} chaves do código e as {len(familias)} dinâmicas existem nos dois idiomas")
+
+try:
+    from PySide6.QtGui import QGuiApplication, QRawFont
+except ImportError:
+    print("(sem PySide6: glifos não conferidos)")
+else:
+    app = QGuiApplication.instance() or QGuiApplication(["teste", "-platform", "offscreen"])
+    plex = [QRawFont(str(f), 15) for f in sorted((RAIZ / "tars_qt" / "fontes").glob("*.ttf"))]
+    assert plex, "fontes da IBM Plex não encontradas"
+    fora = lambda texto: {c for c in texto if ord(c) > 0x7F and not any(f.supportsCharacter(ord(c)) for f in plex)}  # noqa: E731
+    ruins = {f"{k}@{nome}": fora(v) for nome, d in (("pt_BR", pt), ("en", en)) for k, v in d.items()
+             if isinstance(v, str) and fora(v)}
+    assert not ruins, f"textos com glifo fora da IBM Plex (derruba a janela em algumas máquinas): {ruins}"
+    from tars_qt import tema
+    trocados = set(tema._TROCAS.keys())       # a tabela de trocas e quem procura esses sinais podem citá-los
+    ruins = {}
+    for p in list((RAIZ / "tars_qt").glob("*.py")) + [RAIZ / "tars_probes.py", RAIZ / "tars_modos.py"]:
+        for n, linha in enumerate(p.read_text(encoding="utf-8").splitlines(), 1):
+            if linha.lstrip().startswith("#"):
+                continue
+            f = {c for c in fora(linha) if ord(c) not in trocados}
+            if f:
+                ruins[f"{p.name}:{n}"] = f
+    assert not ruins, f"literais das telas com glifo fora da IBM Plex: {ruins}"
+    print("OK: nenhum texto dos idiomas nem literal das telas usa glifo fora da IBM Plex")
+
+with tempfile.TemporaryDirectory() as pasta:
+    for p in fontes_py:
+        py_compile.compile(str(p), cfile=str(Path(pasta) / "x.pyc"), doraise=True)
+print(f"OK: os {len(fontes_py)} arquivos .py do app compilam")
+print("\nTUDO OK.")

app/tests/test_think_vazado.py

@@ -0,0 +1,129 @@
+"""4.0: raciocínio que vaza no texto da resposta (print real: o Gargantua
+escreveu o raciocínio em inglês como resposta, com um "</think>" solto no
+fim, e o turno seguinte começou com "</think>").
+
+O FiltroPensamento separa de novo: o raciocínio vai como pensamento (cinza
+na janela), a resposta fica limpa, nenhuma tag aparece e o histórico guarda
+só a resposta."""
+
+import json
+import os
+import sys
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+F = tars.FiltroPensamento
+
+
+def rodar(pedacos):
+    f = F()
+    eventos = []
+    for p in pedacos:
+        eventos += f.alimentar(p)
+    eventos += f.terminar()
+    return f, eventos
+
+
+def textos(eventos, tipo):
+    return "".join(t for k, t in eventos if k == tipo)
+
+
+def picar(texto, n=7):
+    return [texto[i:i + n] for i in range(0, len(texto), n)]
+
+
+# 1. O caso do print: raciocínio sem <think>, "</think>" no fim, depois a resposta
+bruto = ('Okay, the user said "abre o claude". Let me figure out what they mean.\n\nSo, I should call '
+         'open_application.\n</think>\n\nAbri o Claude.')
+f, ev = rodar(picar(bruto))
+assert f.conteudo == "Abri o Claude.", f.conteudo
+assert "Let me figure out" in f.texto_pensado and "think>" not in f.texto_pensado
+assert "think>" not in json.dumps(ev) and "Let me" not in textos(ev, "resposta"), ev
+assert "Let me figure out" in textos(ev, "pensamento") and textos(ev, "resposta") == "Abri o Claude.", ev
+print("OK: raciocínio sem <think> e com '</think>' no fim vira pensamento; a resposta fica limpa")
+
+# 2. Turno que começa com um "</think>" solto
+f, ev = rodar(picar("</think>\n\nThe application \"Claude\" has been opened."))
+assert f.conteudo == 'The application "Claude" has been opened.' and not f.texto_pensado, (f.conteudo, ev)
+assert "think" not in json.dumps(ev)
+print("OK: '</think>' solto no começo some")
+
+# 3. <think> ... </think> normal dentro do texto (tags picadas em pedaços de 3)
+f, ev = rodar(picar("<think>\npreciso abrir o app\n</think>\n\nPronto, abri.", 3))
+assert f.conteudo == "Pronto, abri." and f.texto_pensado == "preciso abrir o app", (f.conteudo, f.texto_pensado)
+assert "think>" not in json.dumps(ev) and "<" not in json.dumps(ev), ev
+print("OK: <think>...</think> com as tags picadas entre pedaços vira pensamento")
+
+# 4. Resposta normal: passa igual, sem atraso de tag
+for resp in ("Oi! Tudo certo por aqui.", "12 x 8 = 96", "Abri a calculadora e fiz a conta: 96.",
+             "Okay, abri o Firefox pra você."[:0] or "Claro! Abri o Firefox."):
+    f, ev = rodar(picar(resp))
+    assert f.conteudo == resp and not f.texto_pensado and textos(ev, "resposta") == resp, (resp, ev)
+print("OK: resposta comum passa igual")
+
+# 5. Começa como 'Okay, ...' mas era a resposta (nunca fechou): vira resposta no fim
+resp = "Okay, I opened the calculator for you and the result is 96."
+f, ev = rodar(picar(resp))
+assert f.conteudo == resp and not f.texto_pensado, (f.conteudo, f.texto_pensado)
+assert textos(ev, "resposta") == resp
+print("OK: 'Okay, ...' que nunca fecha era a resposta mesmo")
+
+# 6. Pareceu resposta, mas veio '</think>': o que foi mostrado vira pensamento (era_pensamento)
+bruto = "Preciso ver quais apps existem. Vou chamar a ferramenta certa pra isso agora.\n</think>\nAbri."
+f, ev = rodar(picar(bruto))
+assert f.conteudo == "Abri." and "Preciso ver" in f.texto_pensado, (f.conteudo, f.texto_pensado)
+assert any(k == "era_pensamento" for k, _ in ev), ev
+print("OK: texto mostrado como resposta que termina em '</think>' é repintado como pensamento")
+
+# 7. De ponta a ponta no turno de streaming (Ollama falso): eventos e retorno
+
+
+class Resposta:
+    def __init__(self, pedacos):
+        self.linhas = [json.dumps({"message": {"content": p}, "done": False}).encode() for p in pedacos]
+        self.linhas.append(json.dumps({"message": {"content": ""}, "done": True}).encode())
+
+    def iter_lines(self):
+        return iter(self.linhas)
+
+    def close(self):
+        pass
+
+
+eventos = []
+tars.emitir = lambda tipo, **dados: eventos.append((tipo, dados))
+bruto = 'Okay, the user wants the calculator. I will call open_application.\n</think>\n\nAbri a calculadora.'
+tars._chamar_ollama_stream = lambda payload: (Resposta(picar(bruto, 5)), None)
+resultado, erro = tars._executar_turno_streaming("ProjectOpenTARS/gargantua:1.0", [{"role": "user", "content": "x"}],
+                                                 None, pensar=False)
+assert not erro and resultado["content"] == "Abri a calculadora." and "I will call" in resultado["thinking"], resultado
+assert "think>" not in json.dumps(eventos), eventos
+assert [e for e in eventos if e[0] == "pensamento"] and eventos[-1][0] == "fim_stream"
+assert "".join(d["texto"] for k, d in eventos if k == "resposta") == "Abri a calculadora."
+print("OK: no turno de verdade, a tela recebe pensamento + resposta limpa, e o histórico guarda só a resposta")
+
+# 8. Janela: 'resposta_era_pensamento' repinta de cinza (só com tkinter e display)
+try:
+    import tkinter as tk
+    sys.modules["tars"] = tars
+    import tars_gui
+    raiz = tk.Tk()
+except Exception as e:
+    print(f"PULADO (janela): {e}")
+else:
+    area = tars_gui.AreaConversa.__new__(tars_gui.AreaConversa)
+    texto = tk.Text(raiz)
+    for nome in ("rotulo_ia", "pensamento", "pensamento_rotulo"):
+        texto.tag_configure(nome)
+    area.t, area.ultimo_estilo, area.blocos, area.fontes = texto, None, [], None
+    area.escrever(tars_gui.formatar_evento("resposta", {"texto": "Let me think about it", "inicio": True}))
+    area.virar_pensamento()
+    conteudo = texto.get("1.0", "end-1c")
+    assert "openTARS" not in conteudo and "Let me think about it" in conteudo, conteudo
+    inicio = texto.search("Let me", "1.0")
+    assert "pensamento" in texto.tag_names(inicio), texto.tag_names(inicio)
+    raiz.destroy()
+    print("OK: na janela, a 'resposta' que era raciocínio vira texto cinza de pensamento")
+
+print("\nTUDO OK.")

app/tests/test_troca_nao_desce.py

@@ -0,0 +1,42 @@
+"""5.1 (item 7 do plano): quando o modelo falha no meio do pedido, a troca automática vai para um modelo do mesmo
+tamanho ou maior, nunca para um bem menor (no print do Enzo, o Gargantua falhou e quem respondeu foi o qwen3:0.6b). Sem
+modelo à altura, o erro aparece em vez de uma resposta ruim. Ollama de mentira."""
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+
+def m(tag, p):
+    return {"tag": tag, "parametros_b": p, "categoria": "geral", "vram_estimado_gb": p, "capacidades": {"tools"},
+            "capacidades_conhecidas": True, "nuvem": False}
+
+
+def rodar(catalogo, fila):
+    tars.catalogar_modelos = lambda forcar=False: catalogo
+    tars.construir_cadeia_fallback = lambda tarefa, catalogo=None: list(fila)
+    tars.carregar_modelo = lambda *a, **k: True
+    chamados = []
+
+    def turno(modelo, mensagens, tools, **kw):
+        chamados.append(modelo)
+        if modelo == "ProjectOpenTARS/Gargantua:latest":
+            return None, "Erro ao comunicar com Ollama: out of memory"
+        return {"content": f"feito por {modelo}", "tool_calls": []}, None
+
+    tars._executar_turno_streaming = turno
+    tars.modo_modelo = "AUTO"
+    tars.conversa[:] = [{"role": "system", "content": "s"}]
+    return tars.perguntar_modelo("ProjectOpenTARS/Gargantua:latest", "oi, tudo bem?", tarefa="geral"), chamados
+
+
+gargantua, pequeno, grande = m("ProjectOpenTARS/Gargantua:latest", 4.0), m("qwen3:0.6b", 0.75), m("qwen3:8b", 8.2)
+catalogo = {x["tag"]: x for x in (gargantua, pequeno, grande)}
+resposta, chamados = rodar(catalogo, ["ProjectOpenTARS/Gargantua:latest", "qwen3:0.6b", "qwen3:8b"])
+assert chamados == ["ProjectOpenTARS/Gargantua:latest", "qwen3:8b"] and "qwen3:8b" in resposta, (chamados, resposta)
+print("OK: depois da falha, pula o qwen3:0.6b e vai para o qwen3:8b")
+
+catalogo = {x["tag"]: x for x in (gargantua, pequeno)}
+resposta, chamados = rodar(catalogo, ["ProjectOpenTARS/Gargantua:latest", "qwen3:0.6b"])
+assert chamados == ["ProjectOpenTARS/Gargantua:latest"] and "out of memory" in resposta, (chamados, resposta)
+print("OK: sem modelo à altura, mostra o erro em vez de passar o pedido para o 0.6b")
+print("\nTUDO OK.")

app/tests/test_url_site.py

@@ -0,0 +1,33 @@
+from _util import carregar_tars
+tars = carregar_tars()
+
+# 1. Pedido tipo "canal da anthropic no youtube" -> devia virar busca no youtube
+r = tars.abrir_site("canal da anthropic no youtube")
+assert "youtube.com/results" in r["url"], r
+assert "anthropic" in r["url"]
+print("OK: canal no youtube vira busca, não domínio inventado:", r["url"])
+
+# 2. Domínio direto continua funcionando
+tars.webbrowser.open = lambda u: True
+r = tars.abrir_site("github.com")
+assert r["url"] == "https://github.com", r
+print("OK: dominio direto:", r["url"])
+
+# 3. perguntar_url_site: IA responde "desconhecido" -> None (cai pra busca)
+tars._consultar_modelo_leve = lambda p, formato=None: "desconhecido"
+assert tars.perguntar_url_site("coisa qualquer") is None
+print("OK: 'desconhecido' vira None")
+
+# 4. perguntar_url_site: IA inventa domínio que não resolve -> None
+tars._consultar_modelo_leve = lambda p, formato=None: "https://anthropic-canals.youtube.com"
+tars._dominio_existe = lambda u: False  # simula DNS falhando
+assert tars.perguntar_url_site("canal da anthropic") is None
+print("OK: dominio inventado (sem DNS) vira None")
+
+# 5. perguntar_url_site: URL real, resolve -> aceita
+tars._consultar_modelo_leve = lambda p, formato=None: "https://www.anthropic.com"
+tars._dominio_existe = lambda u: True
+assert tars.perguntar_url_site("anthropic") == "https://www.anthropic.com"
+print("OK: dominio real aceito")
+
+print("\nTUDO OK.")

app/tests/test_v2_janelas.py

@@ -0,0 +1,98 @@
+"""Controle de janelas (2.0), de verdade: precisa de um display X com
+gerenciador de janelas (ex: Xvfb + openbox). Sem isso, é pulado.
+
+Um app de teste roda em OUTRO processo (como um app real) e o openTARS:
+abre e espera a janela, lista, traz pra frente, tira print só dela,
+clica nos botões com as coordenadas DO PRINT RECORTADO e fecha a
+janela pelo X (sem matar o processo)."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+
+if not os.environ.get("DISPLAY"):
+    print("PULADO: sem DISPLAY")
+    sys.exit(0)
+
+os.environ.setdefault("XAUTHORITY", "/dev/null")
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import tars  # noqa: E402
+
+if tars.ERRO_PYAUTOGUI:
+    print(f"PULADO: {tars.ERRO_PYAUTOGUI}")
+    sys.exit(0)
+
+try:
+    from Xlib import display as _d
+    _x = _d.Display()
+    tem_wm = _x.screen().root.get_full_property(_x.intern_atom("_NET_CLIENT_LIST"), 0) is not None
+    _x.close()
+except Exception:
+    tem_wm = False
+if not tem_wm:
+    print("PULADO: sem gerenciador de janelas (EWMH)")
+    sys.exit(0)
+
+pasta = tempfile.mkdtemp()
+estado = os.path.join(pasta, "estado.json")
+app = os.path.join(pasta, "calcteste.py")
+open(app, "w").write(f'''
+import json, tkinter as tk
+r = tk.Tk(className="calcteste"); r.title("Calc Teste")
+visor = tk.StringVar(value="")
+def salvar(extra=None):
+    json.dump({{"visor": visor.get(), "fechada": extra == "fechada",
+               "botoes": {{b: [w.winfo_rootx() - r.winfo_rootx() + w.winfo_width() // 2,
+                              w.winfo_rooty() - r.winfo_rooty() + w.winfo_height() // 2]
+                          for b, w in botoes.items()}}}}, open({estado!r}, "w"))
+botoes = {{}}
+for i, b in enumerate(["7", "+", "2", "="]):
+    w = tk.Button(r, text=b, width=5, height=3, command=lambda b=b: (visor.set(visor.get() + b), salvar()))
+    w.grid(row=0, column=i); botoes[b] = w
+tk.Label(r, textvariable=visor).grid(row=1, columnspan=4)
+r.protocol("WM_DELETE_WINDOW", lambda: (salvar("fechada"), r.destroy()))
+r.after(500, salvar)
+r.mainloop()
+''')
+
+tars.encontrar_app = lambda nome: {
+    "tipo": "executavel", "nome": "calcteste",
+    "comando": [sys.executable, app], "origem": app,
+}
+
+t0 = time.time()
+r = tars.abrir_aplicativo("calcteste")
+tempo = time.time() - t0
+assert r["sucesso"] and r.get("janela", {}).get("titulo") == "Calc Teste", r
+print(f"OK: abriu e esperou a janela ({tempo:.1f}s): {r['janela']}")
+
+lista = tars.listar_janelas()
+assert any(j["titulo"] == "Calc Teste" and j["em_foco"] for j in lista["janelas"]), lista
+print("OK: list_windows mostra a janela, em foco")
+
+time.sleep(0.6)
+botoes = json.load(open(estado))["botoes"]
+
+r = tars.tirar_print("calcteste")
+assert r["sucesso"] and "Calc Teste" in r["mensagem"] and tars._escala_print["ox"] > 0, r["mensagem"]
+print("OK: print só da janela:", r["mensagem"][:70])
+
+for b in ["7", "+", "2", "="]:
+    x, y = botoes[b]  # posição do botão DENTRO do print recortado
+    tars.clicar_mouse("left", x, y)
+    time.sleep(0.2)
+time.sleep(0.3)
+assert json.load(open(estado))["visor"] == "7+2=", json.load(open(estado))
+print("OK: cliques com coordenadas do print recortado acertaram 7, +, 2, =")
+
+assert tars.focar_janela("calc teste")["sucesso"]
+r = tars.fechar_aplicativo("calcteste")
+time.sleep(0.3)
+assert r["sucesso"] and json.load(open(estado))["fechada"], r
+print("OK: close_application fechou pela janela (o app recebeu o pedido de fechar)")
+
+print("\nTUDO OK.")

app/tests/test_v2_nucleo.py

@@ -0,0 +1,214 @@
+"""Mudanças da 2.0 no núcleo (sem display): cancelar resposta, fallback
+de think/tools só quando o Ollama diz que não suporta, visão preferindo
+modelos com ferramentas, terminal que não trava e comandos perigosos."""
+
+import time
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+
+# ------------------------------------------------------------------
+# Cancelar no meio do texto
+# ------------------------------------------------------------------
+class RespostaLenta:
+    status_code = 200
+
+    def __init__(self):
+        self.fechada = False
+
+    def iter_lines(self):
+        for i in range(100):
+            if i == 3:
+                tars.cancelar_resposta()  # como o botão Parar
+            yield f'{{"message": {{"content": "p{i} "}}, "done": false}}'.encode()
+
+    def close(self):
+        self.fechada = True
+
+
+lenta = RespostaLenta()
+tars._chamar_ollama_stream = lambda payload: (lenta, None)
+tars.carregar_modelo = lambda m: True
+tars.modo_modelo = "MANUAL"
+resposta = tars.perguntar_modelo("m", "conte uma história")
+assert resposta == "(interrompido)" and lenta.fechada, resposta
+assert tars.conversa[-1]["content"] == "(interrupted by the user)"
+assert not tars._cancelar.is_set(), "o próximo pedido não pode nascer cancelado"
+print("OK: Parar interrompe o texto na hora e deixa a conversa consistente")
+
+
+# ------------------------------------------------------------------
+# think/tools: só desliga quando o Ollama diz que não suporta
+# ------------------------------------------------------------------
+class R:
+    def __init__(self, status, texto=""):
+        self.status_code, self.text = status, texto
+
+
+import importlib.util  # noqa: E402
+
+spec = importlib.util.spec_from_file_location("t2", tars.__file__)
+t2 = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(t2)
+t2.catalogar_modelos = lambda forcar=False: {}
+
+respostas = iter([R(500, "out of memory"), R(200)])
+t2.ollama_request = lambda p, stream=False: next(respostas)
+_, erro = t2._chamar_ollama_stream({"model": "x", "think": True, "tools": [1]})
+assert erro and "out of memory" in erro and "x" not in t2._MODELOS_SEM_TOOLS, erro
+print("OK: erro passageiro (falta de memória) não marca o modelo como 'sem ferramentas'")
+
+enviados = []
+respostas = iter([R(400, '"y" does not support tools'), R(200)])
+t2.ollama_request = lambda p, stream=False: (enviados.append(dict(p)), next(respostas))[1]
+resp, erro = t2._chamar_ollama_stream({"model": "y", "tools": [1]})
+assert resp and not erro and "y" in t2._MODELOS_SEM_TOOLS and "tools" not in enviados[-1]
+print("OK: 'does not support tools' → tenta de novo sem ferramentas e lembra")
+
+
+# ------------------------------------------------------------------
+# Visão: prefere quem enxerga E chama ferramentas
+# ------------------------------------------------------------------
+def modelo(tag, params, caps):
+    return {"tag": tag, "parametros_b": params, "categoria": "visao",
+            "vram_estimado_gb": 3.0, "capacidades": set(caps), "capacidades_conhecidas": True}
+
+
+catalogo = {m["tag"]: m for m in (
+    modelo("so-ve:27b", 27, {"completion", "vision"}),
+    modelo("ve-e-age:12b", 12, {"completion", "vision", "tools"}),
+)}
+tars.detectar_gpu = lambda forcar=False: {"vram_total_gb": 48.0, "vram_livre_gb": 40.0}
+assert tars.construir_cadeia_fallback("visao", catalogo)[0] == "ve-e-age:12b"
+print("OK: tarefa de visão escolhe modelo que enxerga E clica")
+
+
+# ------------------------------------------------------------------
+# Terminal: não trava esperando senha nem programa em segundo plano
+# ------------------------------------------------------------------
+t0 = time.time()
+r = tars.executar_terminal("read resposta; echo \"lido:[$resposta]\"")
+assert time.time() - t0 < 3 and "lido:[]" in r["stdout"], r
+t0 = time.time()
+r = tars.executar_terminal("sleep 20 &")
+assert time.time() - t0 < 2 and r["sucesso"], r
+print("OK: comandos que pedem entrada ou rodam em segundo plano não travam")
+
+for cmd in ("rm -r ~/Documentos", "rm -R pasta", "find . -name '*.log' -delete", "git reset --hard HEAD~3"):
+    assert tars._comando_e_perigoso(cmd), cmd
+for cmd in ("rm arquivo.txt", "ls -R", "git status", "find . -name x"):
+    assert not tars._comando_e_perigoso(cmd), cmd
+print("OK: rm -r, find -delete e git reset --hard pedem confirmação")
+
+# DNS não mexe mais no timeout global de sockets
+import socket  # noqa: E402
+
+antes = socket.getdefaulttimeout()
+tars._dominio_existe("https://dominio-que-nao-existe-opentars.invalid")
+assert socket.getdefaulttimeout() == antes
+print("OK: checagem de domínio não altera o timeout de rede do processo")
+
+# Resposta do ajudante sem <think>
+tars._SESSION.post = lambda *a, **k: type("Resp", (), {
+    "status_code": 200,
+    "json": lambda self: {"message": {"content": "<think>hmm</think>gnome-calculator"}},
+})()
+assert tars._chat_unico("m", "p") == "gnome-calculator"
+print("OK: raciocínio <think> não vaza na resposta do modelo ajudante")
+
+
+# ------------------------------------------------------------------
+# Correções da revisão independente
+# ------------------------------------------------------------------
+import threading  # noqa: E402
+
+# Ordem: [print, clique] na mesma resposta -> os dois resultados logo
+# após as chamadas, e a imagem só depois deles.
+spec3 = importlib.util.spec_from_file_location("t3", tars.__file__)
+t3 = importlib.util.module_from_spec(spec3)
+spec3.loader.exec_module(t3)
+t3.SEM_INTERFACE = False  # o teste vale com ou sem tela
+t3.carregar_modelo = lambda m: True
+t3.modo_modelo = "MANUAL"
+t3._DISPATCH_FERRAMENTAS["take_screenshot"] = lambda a: {"sucesso": True, "mensagem": "ok", "_imagem_b64": "IMG"}
+t3._DISPATCH_FERRAMENTAS["click_mouse"] = lambda a: {"sucesso": True, "mensagem": "ok"}
+roteiro = iter([
+    {"content": "", "tool_calls": [{"function": {"name": "take_screenshot", "arguments": {}}},
+                                   {"function": {"name": "click_mouse", "arguments": {"x": 1, "y": 1}}}]},
+    {"content": "feito", "tool_calls": []},
+])
+vistos = []
+t3._executar_turno_streaming = lambda m, msgs, tools, **kw: (vistos.append([dict(x) for x in msgs]), (next(roteiro), None))[1]
+t3.perguntar_modelo("m", "tarefa")
+papeis = [x["role"] for x in vistos[1][-4:]]
+assert papeis == ["assistant", "tool", "tool", "user"] and vistos[1][-1].get("images") == ["IMG"], papeis
+print("OK: vários resultados de ferramenta ficam juntos, e o print vem depois deles")
+
+# Parar no meio de uma sequência de ferramentas: as que não rodaram
+# ganham um resultado "cancelado" (a conversa continua válida).
+roteiro = iter([{"content": "", "tool_calls": [
+    {"function": {"name": "click_mouse", "arguments": {}}},
+    {"function": {"name": "take_screenshot", "arguments": {}}},
+    {"function": {"name": "click_mouse", "arguments": {}}}]}])
+t3._DISPATCH_FERRAMENTAS["click_mouse"] = lambda a: (t3.cancelar_resposta(), {"sucesso": True, "mensagem": "ok"})[1]
+t3.perguntar_modelo("m", "três passos")
+ultimas = t3.conversa[-5:]
+assert [x["role"] for x in ultimas] == ["assistant", "tool", "tool", "tool", "assistant"], [x["role"] for x in ultimas]
+assert "Cancelled" in ultimas[2]["content"] and "Cancelled" in ultimas[3]["content"]
+print("OK: Parar no meio das ferramentas deixa um resultado 'cancelado' pra cada uma que não rodou")
+
+
+# Parar enquanto o Ollama ainda lê a conversa (nenhuma linha chegou)
+class Travada:
+    status_code = 200
+
+    def __init__(self):
+        self.fechou = threading.Event()
+
+    def iter_lines(self):
+        self.fechou.wait(10)
+        raise ConnectionError("fechada")
+
+    def close(self):
+        self.fechou.set()
+
+
+travada = Travada()
+t4 = importlib.util.module_from_spec(spec3)  # módulo novo, com o streaming de verdade
+spec3.loader.exec_module(t4)
+t4.carregar_modelo = lambda m: True
+t4.modo_modelo = "MANUAL"
+t4._chamar_ollama_stream = lambda p: (travada, None)
+threading.Timer(0.5, t4.cancelar_resposta).start()
+t0 = time.time()
+assert t4.perguntar_modelo("m", "oi") == "(interrompido)"
+assert time.time() - t0 < 3, time.time() - t0
+print(f"OK: Parar funciona mesmo antes da IA começar a escrever ({time.time() - t0:.1f}s)")
+
+# Comando de terminal longo também para
+threading.Timer(0.5, tars.cancelar_resposta).start()
+t0 = time.time()
+r = tars.executar_terminal("sleep 20")
+tars._cancelar.clear()
+assert time.time() - t0 < 3 and "interrupted" in r["mensagem"], r
+print("OK: Parar interrompe um comando de terminal demorado")
+
+# DNS travado não segura o openTARS além do limite
+import socket as _s  # noqa: E402
+tars.socket.gethostbyname = lambda h: time.sleep(20)
+t0 = time.time()
+assert tars._dominio_existe("https://qualquer.com") is False
+assert time.time() - t0 < tars.TIMEOUT_DNS + 1.5, time.time() - t0
+tars.socket.gethostbyname = _s.gethostbyname
+print("OK: DNS travado respeita o limite de tempo")
+
+# Mais de um modelo carregado: o novo só convive se TODOS couberem
+tars._cache_catalogo["dados"] = {"a": {"vram_estimado_gb": 5.0}, "b": {"vram_estimado_gb": 5.0}, "c": {"vram_estimado_gb": 12.0}}
+tars.detectar_gpu = lambda forcar=False: {"vram_total_gb": 24.0, "vram_livre_gb": 20.0}
+tars.contexto_ia = lambda: 16384
+assert tars._cabem_juntos(["a"], "b") and not tars._cabem_juntos(["a", "b"], "c")
+print("OK: descarrega os modelos antigos quando o novo não cabe com todos eles")
+
+print("\nTUDO OK.")

app/tests/test_variantes_gargantua.py

@@ -0,0 +1,73 @@
+"""Variantes do Gargantua (Lite, Code) no openTARS: o app nunca as confunde com o oficial e as usa só onde servem."""
+from _util import carregar_tars
+
+tars = carregar_tars()
+import tars_primeiro_uso as pu
+
+# 1) reconhecer a variante pelo nome OU pela etiqueta
+casos = [("gargantua-code", "code"), ("gargantua-lite:latest", "lite"), ("ProjectOpenTARS/Gargantua:code", "code"),
+         ("ProjectOpenTARS/Gargantua:1.2-lite", "lite"), ("ProjectOpenTARS/Gargantua:latest", ""), ("ProjectOpenTARS/Gargantua:1.2", ""),
+         ("gargantua", ""), ("enzo/gargantua-teste:1.0", ""), ("qwen3:4b", ""), ("qwen2.5-coder:7b", ""), ("", ""), (None, "")]
+for nome, esperado in casos:
+    assert tars.variante_do_gargantua(nome) == esperado, (nome, tars.variante_do_gargantua(nome))
+    assert pu.e_variante_do_gargantua(nome) == bool(esperado), nome         # a cópia do primeiro uso concorda
+print("OK: variante reconhecida pelo nome e pela etiqueta (e as duas cópias da regra concordam)")
+
+# 2) 'o Gargantua instalado' é o oficial; variante só conta se não houver outro
+cat = {"gargantua-code:latest": {}, "ProjectOpenTARS/Gargantua:code": {}, "gargantua-lite:latest": {}}
+assert tars.variante_do_gargantua(tars.gargantua_instalado(cat))             # só variantes: devolve uma delas, nunca None
+cat["ProjectOpenTARS/Gargantua:latest"] = {}
+assert tars.gargantua_instalado(cat) == "ProjectOpenTARS/Gargantua:latest"
+assert pu.tem_gargantua(["gargantua-code:latest", "ProjectOpenTARS/Gargantua:code", "gargantua-lite"]) is False   # o primeiro uso baixa o oficial
+assert pu.tem_gargantua(["ProjectOpenTARS/Gargantua:code", "ProjectOpenTARS/Gargantua:latest"]) is True
+assert pu.nome_do_gargantua(["ProjectOpenTARS/Gargantua:code", "ProjectOpenTARS/Gargantua:latest"]) == "ProjectOpenTARS/Gargantua:latest"
+assert pu.nome_do_gargantua(["ProjectOpenTARS/Gargantua:code"]) == pu.MODELO_GARGANTUA
+print("OK: o Gargantua oficial nunca é trocado por uma variante (instalado, primeiro uso)")
+
+
+def entrada(tag, params, caps=("completion", "tools"), categoria="geral"):
+    return {"tag": tag, "familia": tag.split(":")[0], "parametros_b": params, "quantizacao": "Q4_K_M",
+            "vram_estimado_gb": params * 0.6 + 0.6, "capacidades": set(caps), "capacidades_conhecidas": True,
+            "categoria": categoria, "emoji": "x", "nuvem": False}
+
+
+catalogo = {
+    "qwen3:8b": entrada("qwen3:8b", 8.2), "qwen3:4b": entrada("qwen3:4b", 4.0),
+    "qwen2.5-coder:7b": entrada("qwen2.5-coder:7b", 7.6, categoria="codigo"),
+    "ProjectOpenTARS/Gargantua:latest": entrada("ProjectOpenTARS/Gargantua:latest", 4.0),
+    "gargantua-code:latest": entrada("gargantua-code:latest", 4.0, categoria="codigo"),
+    "gargantua-lite:latest": entrada("gargantua-lite:latest", 1.7),
+}
+
+# 3) ação/busca: o oficial na frente; Lite só depois dele; o Code (que é de código) nem entra na frente
+for tarefa in ("acao", "busca", "acao_complexa"):
+    fila = tars.construir_cadeia_fallback(tarefa, catalogo=catalogo)
+    assert fila[0] == "ProjectOpenTARS/Gargantua:latest", (tarefa, fila)
+    assert fila.index("gargantua-lite:latest") > 0
+    assert fila.index("gargantua-code:latest") > fila.index("qwen3:8b") or fila.index("gargantua-code:latest") > fila.index("gargantua-lite:latest"), (tarefa, fila)
+    assert fila.index("gargantua-code:latest") >= len(fila) - 2, (tarefa, fila)       # especialista em código: no fim fora de código
+print("OK: nas ações o oficial vai na frente; Lite depois; Code só como último recurso")
+
+# 4) código: o Gargantua Code vai na frente do qwen2.5-coder e do oficial
+fila = tars.construir_cadeia_fallback("codigo", catalogo=catalogo)
+assert fila[0] == "gargantua-code:latest" and "ProjectOpenTARS/Gargantua:latest" in fila, fila
+sem_code = {k: v for k, v in catalogo.items() if "code:" not in k}
+assert tars.construir_cadeia_fallback("codigo", catalogo=sem_code)[0] == "qwen2.5-coder:7b"      # sem ele, o de sempre
+print("OK: em pedido de código o Gargantua Code vai na frente (e sem ele nada muda)")
+
+# 5) só com Lite instalado (PC fraco): ele atende as ações
+so_lite = {"gargantua-lite:latest": catalogo["gargantua-lite:latest"], "qwen3:0.6b": entrada("qwen3:0.6b", 0.6, categoria="simples")}
+assert tars.construir_cadeia_fallback("acao", catalogo=so_lite)[0] == "gargantua-lite:latest"
+print("OK: num PC fraco só com o Lite, ele atende as ações")
+
+# 6) TARS_SEM_GARGANTUA desliga a preferência (também a do Code)
+import os
+os.environ["TARS_SEM_GARGANTUA"] = "1"
+assert tars.construir_cadeia_fallback("codigo", catalogo=catalogo)[0] == "qwen2.5-coder:7b"
+assert tars.construir_cadeia_fallback("acao", catalogo=catalogo)[0] != "ProjectOpenTARS/Gargantua:latest"
+del os.environ["TARS_SEM_GARGANTUA"]
+
+# 7) o formato (prompt curto + 19 ferramentas, sem raciocínio) vale pras variantes: foram treinadas assim
+for v in ("gargantua-code:latest", "gargantua-lite:latest", "ProjectOpenTARS/Gargantua:code"):
+    assert tars.eh_gargantua(v), v
+print("\nTUDO OK.")

app/tests/test_ver_imagem.py

@@ -0,0 +1,44 @@
+"""take_screenshot(file=...): a IA "olha" um arquivo de imagem (o Cooper descreve se o modelo não enxerga).
+Pasta pessoal temporária (antes gravava na de verdade e, se falhasse, deixava ~/Documentos/Foto.PNG), com Documents E
+Documentos, como no PC do Enzo: "Documents/foto.png" tem de achar a foto que está em Documentos."""
+import os
+import tempfile
+os.environ["HOME"] = tempfile.mkdtemp(prefix="opentars-casa-")
+from _util import carregar_tars  # noqa: E402
+from PIL import Image  # noqa: E402
+tars = carregar_tars()
+
+d = tempfile.mkdtemp()
+foto = os.path.join(d, "foto.png")
+Image.new("RGB", (900, 500), (200, 30, 30)).save(foto)
+
+r = tars.executar_ferramenta("take_screenshot", {"file": foto})
+assert r["sucesso"] and r["_imagem_b64"] and r["arquivo"].endswith("foto.png"), r
+print("OK: take_screenshot(file) carrega a imagem do arquivo")
+
+r = tars.executar_ferramenta("look_at_image", {"image_path": foto})   # apelidos de nome e de argumento
+assert r["sucesso"] and r["_imagem_b64"], r
+print("OK: look_at_image(image_path=...) vira take_screenshot(file=...)")
+
+r = tars.executar_ferramenta("take_screenshot", {"file": os.path.join(d, "nao_existe.png")})
+assert not r["sucesso"] and "not found" in r["mensagem"].lower()
+print("OK: arquivo que não existe dá erro claro")
+
+# caminhos como a IA costuma escrever: relativo, pasta em outro idioma, maiúscula
+casa = os.path.expanduser("~")
+assert casa == os.environ["HOME"] and "opentars-casa-" in casa
+os.makedirs(os.path.join(casa, "Documentos"), exist_ok=True)
+os.makedirs(os.path.join(casa, "Documents"), exist_ok=True)       # as duas: o resolvedor tem de voltar atrás
+Image.new("RGB", (50, 50), (1, 2, 3)).save(os.path.join(casa, "Documentos", "Foto.PNG"))
+for escrito in ("~/Documentos/Foto.PNG", "Documents/foto.png", "home/documentos/foto.png"):
+    r = tars.executar_ferramenta("take_screenshot", {"file": escrito})
+    assert r["sucesso"], (escrito, r["mensagem"])
+print("OK: caminho relativo, pasta em inglês/português e maiúscula também funcionam")
+os.remove(os.path.join(casa, "Documentos", "Foto.PNG"))
+
+# modelo sem visão: o Cooper descreve (aqui, falso) e a mensagem diz que é uma foto, não a tela
+tars.descrever_com_visao = lambda img, pedido: ("a red rectangle", "cooper:fake")
+texto = tars._print_em_texto("x", "o que tem nessa imagem?", "gargantua", None, "/x/foto.png")
+assert "a red rectangle" in texto and "don't click" in texto and "foto.png" in texto, texto
+print("OK: modelo sem visão recebe a descrição do Cooper da foto")
+print("TUDO OK.")

app/tests/test_visao_fallback.py

@@ -0,0 +1,91 @@
+"""2.5.2: print de tela com um modelo que não enxerga.
+
+Log real: qwen3:8b tirou um print; o openTARS mandou a imagem, o Ollama
+respondeu 400 "model does not support multimodal", e o reenvio "só texto"
+AINDA levava a imagem (erro de novo, pedido perdido)."""
+
+from _util import carregar_tars
+
+tars = carregar_tars()
+
+import base64 as _b64, io as _io  # noqa: E402
+from PIL import Image as _Image  # noqa: E402
+_buf = _io.BytesIO()
+_Image.new("RGB", (400, 400), "white").save(_buf, format="PNG")
+PNG = _b64.b64encode(_buf.getvalue()).decode()
+
+COOPER = "ProjectOpenTARS/cooper:latest"
+ERRO_400 = ('Ollama error (400): {"error":"{\\"error\\":{\\"code\\":400,\\"message\\":\\"Multimodal data '
+            'provided, but model does not support multimodal requests.\\"}}"}')
+
+
+def catalogo(conhecidas):
+    return {
+        "qwen3:8b": {"tag": "qwen3:8b", "capacidades": {"tools", "thinking"}, "capacidades_conhecidas": conhecidas,
+                     "categoria": "geral", "parametros_b": 8.2, "vram_estimado_gb": 5.5},
+        COOPER: {"tag": COOPER, "familia": "qwen3vl", "capacidades": {"vision", "completion"}, "capacidades_conhecidas": True,
+                 "categoria": "visao", "parametros_b": 2.0, "vram_estimado_gb": 2.0},
+    }
+
+
+descricoes = []
+
+
+def chat_unico(modelo, prompt, imagens=None, **kw):
+    descricoes.append((modelo, bool(imagens)))
+    return "Calculator window. Display: 0. Button '1' at (40, 300), '=' at (200, 380)."
+
+
+tars._chat_unico = chat_unico
+tars.carregar_modelo = lambda m, silencioso=False: True
+tars.contexto_ia = lambda: 8192
+tars.detectar_gpu = lambda forcar=False: {"vram_total_gb": 12.0, "vram_livre_gb": 11.0}
+tars.modo_modelo = "MANUAL"
+tars._DISPATCH_FERRAMENTAS["take_screenshot"] = lambda a: {
+    "sucesso": True, "mensagem": "SUCCESS: screenshot taken.", "_imagem_b64": PNG}
+
+enviados = []
+
+
+def turno(modelo, msgs, tools, **kw):
+    com_imagem = any(m.get("images") for m in msgs)
+    enviados.append((modelo, com_imagem, bool(tools)))
+    if com_imagem and modelo == "qwen3:8b":
+        return None, ERRO_400
+    if not any(m["role"] == "tool" for m in msgs[-4:]) and not any("described the screenshot" in (m.get("content") or "") for m in msgs):
+        return {"content": "", "tool_calls": [{"function": {"name": "take_screenshot", "arguments": {"window": "calculator"}}}]}, None
+    return {"content": "The calculator shows 0.", "tool_calls": []}, None
+
+
+tars._executar_turno_streaming = turno
+
+# 1. O catálogo já diz que o qwen3 não enxerga: a imagem nem vai
+tars.catalogar_modelos = lambda forcar=False: catalogo(True)
+tars.conversa = []
+tars._sessoes_por_modelo = {} if hasattr(tars, "_sessoes_por_modelo") else None
+r = tars.perguntar_modelo("qwen3:8b", "what does the calculator show?", tarefa="acao")
+assert r == "The calculator shows 0.", r
+assert not any(img for m, img, _ in enviados), enviados
+assert descricoes == [(COOPER, True)], descricoes
+print("OK: modelo sem visão -> o print não vai; o Cooper descreve a tela em texto e a tarefa continua")
+
+# 2. Catálogo sem capacidades conhecidas: o Ollama recusa a imagem ->
+#    TODA imagem sai da conversa e o turno é refeito COM as ferramentas
+enviados.clear(); descricoes.clear()
+tars._MODELOS_SEM_VISAO.clear()
+tars.catalogar_modelos = lambda forcar=False: catalogo(False)
+tars.conversa = []
+r = tars.perguntar_modelo("qwen3:8b", "what does the calculator show now?", tarefa="acao")
+assert r == "The calculator shows 0.", (r, enviados)
+com_imagem = [e for e in enviados if e[1]]
+assert len(com_imagem) == 1 and enviados[enviados.index(com_imagem[0]) + 1] == ("qwen3:8b", False, True), enviados
+assert "qwen3:8b" in tars._MODELOS_SEM_VISAO and not tars.modelo_enxerga("qwen3:8b")
+print("OK: 400 'does not support multimodal' -> imagem trocada por descrição, repete com ferramentas, e lembra")
+
+# 3. Sem nenhum modelo com visão: orienta a usar list_elements
+enviados.clear(); descricoes.clear()
+tars.catalogar_modelos = lambda forcar=False: {"qwen3:8b": catalogo(True)["qwen3:8b"]}
+msg = tars._print_em_texto(PNG, "x", "qwen3:8b")
+assert "list_elements" in msg and not descricoes
+print("OK: sem modelo de visão instalado -> a IA é mandada pro list_elements")
+print("\nTUDO OK.")

app/tests/test_visao_fallback_ferramentas.py

@@ -0,0 +1,35 @@
+from _util import carregar_tars
+import io, json
+tars = carregar_tars()
+
+# Force AUTO mode, single candidate model, no fallback chain needed
+tars.modo_modelo = "MANUAL"
+tars.modelo_manual = "qwen3.8:27b"
+
+tars.carregar_modelo = lambda *a, **k: True
+
+calls = []
+
+def fake_stream(modelo, mensagens, tools, **kw):
+    calls.append(tools)
+    imagem_no_turno = bool(mensagens) and mensagens[-1].get("images")
+    if imagem_no_turno and tools:
+        # simulate failure: model doesn't support tools+images together
+        return None, "Erro do Ollama (400): tools not supported with images"
+    if imagem_no_turno and not tools:
+        return {"content": "Vejo uma tela com um editor de texto aberto.", "thinking": "", "tool_calls": []}, None
+    # first turn: request a screenshot
+    return {"content": "", "thinking": "", "tool_calls": [
+        {"function": {"name": "take_screenshot", "arguments": {}}}
+    ]}, None
+
+tars._executar_turno_streaming = fake_stream
+tars.executar_ferramenta = lambda nome, args: {"sucesso": True, "mensagem": "print tirado", "_imagem_b64": "AAAA"}
+tars.obter_sessao = lambda modelo: [{"role": "system", "content": "sys"}]
+
+resultado = tars.perguntar_modelo("qwen3.8:27b", "veja minha tela e faça uma pergunta simples", tarefa="visao")
+print("RESULTADO FINAL:", repr(resultado))
+assert resultado == "Vejo uma tela com um editor de texto aberto."
+print("Numero de chamadas a _executar_turno_streaming:", len(calls))
+assert len(calls) == 3  # 1) tool-call turn, 2) failed image+tools turn, 3) fallback image-only turn
+print("OK: fallback funcionou e resposta final foi retornada corretamente.")

app/tests/test_voz_continua.py

@@ -0,0 +1,51 @@
+"""Voz: "contínua" ouve sem o nome; "tars" só com o nome; gravador que falha vira erro explicado."""
+import array, math, os, sys, time
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import tars_voz as v
+
+def tom(ms, amp):
+    n = int(v.TAXA * ms / 1000)
+    a = array.array("h", (int(amp * math.sin(2 * math.pi * 300 * i / v.TAXA)) for i in range(n)))
+    return a.tobytes()
+
+def gravar():
+    quieto = tom(1, 0)  # zeros
+    yield b"\x01\x00" * int(v.TAXA * 0.5)                # ruído de fundo mínimo
+    for _ in range(3):
+        yield tom(600, 6000)                               # fala
+        yield b"\x01\x00" * int(v.TAXA * 0.9)              # silêncio
+    time.sleep(0.3)
+
+class Falso:
+    def __init__(self, texto): self.texto = texto
+    def transcrever(self, *a, **k): return self.texto
+    def aquecer(self): pass
+
+def rodar(modo, texto):
+    pedidos = []
+    o = v.Ouvinte(pedidos.append, "pt_BR", modo=modo, gravar=gravar, transcritor=Falso(texto),
+                  transcritor_ativacao=Falso(texto), aquecer=False)
+    o._rodar()
+    return pedidos
+
+assert rodar("continua", "abre o firefox") , "contínua não ouviu"
+print("OK: contínua: fala sem dizer TARS vira pedido")
+assert rodar("continua", "TARS, abre o firefox")[0] == "abre o firefox"
+print("OK: contínua: se disser TARS, o nome é tirado")
+assert rodar("ativacao", "abre o firefox") == []
+print("OK: palavra TARS: sem o nome, não age")
+assert rodar("ativacao", "TARS, abre o firefox")[0] == "abre o firefox"
+print("OK: palavra TARS: com o nome, age")
+
+# gravador que falha: erro explicado em vez de "parado" mudo
+estados = []
+o = v.Ouvinte(lambda t: None, "pt_BR", modo="continua", ao_estado=estados.append, aquecer=False)
+orig, v.GRAVADORES = v.GRAVADORES, (("false", ["false"]),)
+try:
+    o._rodar()
+finally:
+    v.GRAVADORES = orig
+assert any(e.startswith("erro:microfone") for e in estados), estados
+print("OK: gravador que morre vira erro:", [e for e in estados if e.startswith("erro")][0][:90])
+print("TUDO OK.")

app/tests/test_voz_kokoro.py

@@ -0,0 +1,208 @@
+"""4.0 Endurance: voz natural (Kokoro) e ouvir melhor (Whisper, "TARS").
+
+- 5.0 Tesseract: voz em inglês e em português (Kokoro pf_dora/pm_alex/pm_santa, Whisper multilíngue);
+- texto preparado pra fala (contas, datas, caminhos, unidades, "openTARS");
+- fala frase a frase (a primeira toca enquanto as outras são geradas) e o
+  "Parar" corta no meio;
+- voz escolhida e velocidade (config.json -> Kokoro);
+- Whisper escolhido pelo hardware, "TARS" mais tolerante, frases fantasma descartadas.
+"""
+
+import json
+import os
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+for var in ("XDG_RUNTIME_DIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME"):
+    os.environ[var] = tempfile.mkdtemp(prefix=f"opentars-{var.lower()}-")
+os.environ["TARS_ARQUIVO_SESSOES"] = os.path.join(tempfile.mkdtemp(), "sessoes.json")
+
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+voz = tars.voz_lib
+
+# 1. Texto -> fala (Endurance Neo: a voz é só em inglês)
+P = voz.preparar_para_fala
+casos = {
+    "Opened the calculator: 12 x 8 = 96.": "Opened the calculator: 12 times 8 equals 96.",
+    "The result is 8,148.": "The result is 8148.",
+    "I created /home/sam/Desktop/notes.txt for you.": "I created notes.txt for you.",
+    "You have 3.5 GB free (45%).": "You have 3.5 gigabytes free (45 percent).",
+    "Today is 2026-10-01.": "Today is October 1, 2026.",
+    "Your screen is 1920x1080.": "Your screen is 1920 by 1080.",
+    "It takes 3-5 minutes.": "It takes 3 to 5 minutes.",
+    "281 - 54 = 227": "281 minus 54 equals 227",
+    "I am Gargantua, the openTARS AI. You can call me TARS.":
+        "I am Gargantua, the open Tars AI. You can call me Tars.",
+}
+for entrada, esperado in casos.items():
+    assert P(entrada, "en") == esperado, (entrada, P(entrada, "en"))
+assert P("12 x 8 = 96, on 2026-10-01; 1,234 files", "en") == "12 times 8 equals 96, on October 1, 2026; 1234 files"
+assert P("Done! Opened Firefox.") == "Done! Opened Firefox."
+print("OK: math, dates, paths and units become natural English speech")
+
+frases = voz.dividir_frases("Oi. Abri o Firefox e pesquisei o que você pediu, já está na tela. Pronto! "
+                            "Quer que eu salve a página nos seus favoritos? " + "Uma frase bem comprida, " * 20 + "fim.")
+assert len(frases) >= 3 and all(len(f) <= 270 for f in frases) and frases[0].startswith("Oi."), frases
+assert " ".join(frases).replace("  ", " ").startswith("Oi. Abri o Firefox")
+print(f"OK: resposta longa vira {len(frases)} trechos (o primeiro toca enquanto os outros são gerados)")
+
+# 2. Voz escolhida e velocidade (Kokoro, só inglês)
+assert set(voz.VOZES_DISPONIVEIS) == {"en", "pt_BR"}
+assert set(voz.VOZES_DISPONIVEIS["en"]) == {"heart", "bella", "michael", "emma"}
+assert set(voz.VOZES_DISPONIVEIS["pt_BR"]) == {"dora", "alex", "santa"}
+assert voz.IDIOMAS_COM_VOZ == ("en", "pt_BR") and voz.tem_voz("en") and voz.tem_voz("pt_BR") and not voz.tem_voz("de")
+assert voz.nome_da_voz("en") == "heart" and voz.voz_kokoro("en") == ("af_heart", "en-us")
+assert voz.nome_da_voz("pt_BR") == "dora" and voz.voz_kokoro("pt_BR") == ("pf_dora", "pt-br")
+assert voz.voz_kokoro("de") == ("af_heart", "en-us"), "idioma sem voz cai na voz em inglês"
+assert voz.voz_kokoro("pt_BR", "santa") == ("pm_santa", "pt-br")
+voz.configurar(vozes={"en": "michael", "pt_BR": "alex"}, velocidade=1.25)
+assert voz.voz_kokoro("en") == ("am_michael", "en-us") and voz.voz_kokoro("pt_BR") == ("pm_alex", "pt-br")
+assert voz.voz_kokoro("en", "emma") == ("bf_emma", "en-gb")
+assert voz.PREFERENCIAS["velocidade"] == 1.25
+voz.configurar(velocidade=9)
+assert voz.PREFERENCIAS["velocidade"] == voz.VELOCIDADE_MAX
+voz.configurar(vozes={"en": "nao-existe"}, velocidade=1.0)
+assert voz.nome_da_voz("en") == "heart"
+
+tars.i18n.definir_idioma("en")
+ok, msg = tars.escolher_voz("dora")
+assert not ok and "heart" in msg
+for arquivo in voz.arquivos_kokoro():  # já baixado: não vai pra internet
+    arquivo.parent.mkdir(parents=True, exist_ok=True)
+    arquivo.write_bytes(b"x" * 2000)
+ok, msg = tars.escolher_voz("Bella")
+assert ok and tars.preferencias_voz()["vozes"]["en"] == "bella" and voz.voz_kokoro("en")[0] == "af_bella"
+assert tars.definir_velocidade_voz("1,1")[0] and abs(voz.PREFERENCIAS["velocidade"] - 1.1) < 1e-9
+assert not tars.definir_velocidade_voz("rápido")[0]
+assert "Bella" in tars.frase_de_teste_voz()
+print("OK: Kokoro voices (Heart, Bella, Michael, Emma); choice and speed go from config.json to Kokoro")
+
+# 2a. Português (5.0): vozes pf_dora / pm_alex / pm_santa, Whisper multilíngue, texto falado em português
+tars.i18n.definir_idioma("pt_BR")
+assert tars.voz_no_idioma() and tars.voz_atual() == "dora"
+ok, msg = tars.escolher_voz("heart")
+assert not ok and "dora" in msg
+ok, msg = tars.escolher_voz("Santa")
+assert ok and tars.preferencias_voz()["vozes"]["pt_BR"] == "santa" and voz.voz_kokoro("pt_BR") == ("pm_santa", "pt-br")
+assert voz._idioma_whisper["l"] == "pt_BR"
+voz._config_whisper.clear()
+assert voz.config_whisper(forcar=True, memoria=(2500, 6144))["pedido"] == ("small", "cpu", "int8")
+assert voz.config_whisper(forcar=True, memoria=(5600, 6144))["ativacao"] == ("base", "cuda", "int8_float16")
+voz._config_whisper.clear()
+assert voz.CONFIRMACOES["pt_BR"] == "Sim?"
+assert voz.preparar_para_fala("12 x 8 = 96 em 2026-10-01 (16GB, 1.234 arquivos, 50%)", "pt_BR") == \
+    "12 vezes 8 igual a 96 em primeiro de outubro de 2026 (16 gigabytes, 1234 arquivos, 50 por cento)"
+assert voz.e_alucinacao("Legendas pela comunidade Amara.org") and voz.e_alucinacao("Obrigado por assistir!")
+assert not voz.e_alucinacao("abre o navegador")
+tars.i18n.definir_idioma("en")
+voz._config_whisper.clear()
+tars.aplicar_preferencias_voz()
+print("OK: voz em português (Dora, Alex, Santa), Whisper multilíngue, números/datas/unidades falados em português")
+
+# 2b. Whisper escolhido pelo hardware (modelos .en no processador)
+voz._config_whisper.clear()
+assert voz.config_whisper(forcar=True, memoria=(5600, 6144))["pedido"] == ("large-v3-turbo", "cuda", "int8_float16")
+assert voz.config_whisper(forcar=True, memoria=(2500, 6144))["pedido"] == ("small.en", "cpu", "int8")
+assert voz.config_whisper(forcar=True, memoria=(3000, 12288))["pedido"][1] == "cuda"
+medir_placa = voz._memoria_da_placa
+voz._memoria_da_placa = lambda: None       # sem placa de vídeo (antes media a placa de verdade e dependia da VRAM livre)
+assert voz.config_whisper(forcar=True, memoria=None)["ativacao"] == ("base.en", "cpu", "int8")
+voz._memoria_da_placa = medir_placa
+voz._config_whisper["placa_falhou"] = True
+assert voz.config_whisper(forcar=True, memoria=(5600, 6144))["pedido"][1] == "cpu"
+voz._config_whisper.clear()
+print("OK: Whisper large-v3-turbo on the GPU when there is room, small.en on the CPU; GPU failure -> CPU")
+
+# 2c. "TARS" mais tolerante, sem ligar à toa; frases inventadas pelo Whisper
+for texto in ("Tars, open Firefox", "Tarz, what time is it", "hey Thars, close Discord",
+              "Dars, search for a recipe", "ok tares open spotify", "Tarzo open the calculator"):
+    chamou, resto = voz.achar_ativacao(texto)
+    assert chamou and resto, (texto, chamou, resto)
+for texto in ("Tas, open Firefox", "stars", "we were talking about tars last night at dinner", "starship"):
+    assert not voz.achar_ativacao(texto)[0], texto
+assert voz.parece_chamado("Taz, open firefox") and not voz.parece_chamado("open firefox")
+for texto in ("Thanks for watching!", "Subtitles by the Amara.org community", "Please subscribe", "...", "♪♪"):
+    assert voz.e_alucinacao(texto), texto
+assert not voz.e_alucinacao("open the browser and search thanks for watching")
+print("OK: 'TARS' heard in more spellings (tarz, thars, dars...), not 'tas'; Whisper ghost phrases dropped")
+
+# 2d. Transcrição do pedido: vocabulário dos apps, beam 5, detector de voz
+class ModeloFalso:
+    def __init__(self, texto):
+        self.texto, self.opcoes = texto, []
+
+    def transcribe(self, dados, **opcoes):
+        self.opcoes.append(opcoes)
+        return iter([type("S", (), {"text": self.texto})()]), None
+
+
+voz.Transcritor._cache["pedido-teste"] = m = ModeloFalso(" open Steam")
+tr = voz.Transcritor("pedido-teste")
+assert tr.transcrever(b"\0\0" * 1600, "en", vocabulario=["Steam", "Discord"]) == "open Steam"
+o = m.opcoes[-1]
+assert o["beam_size"] == 5 and o["vad_filter"] is True and "Steam" in o["hotwords"] and "initial_prompt" not in o, o
+voz.Transcritor._cache["fantasma"] = ModeloFalso(" Thanks for watching!")
+assert voz.Transcritor("fantasma").transcrever(b"\0\0" * 1600, "en") == ""
+print("OK: pedido transcrito com os nomes dos apps como vocabulário, busca mais cuidadosa e sem frases fantasma")
+
+# 2e. Segunda chance: o modelo rápido ouviu "Taz", o bom confere e acha o "TARS"
+class TranscritorFalso:
+    def __init__(self, texto):
+        self.texto, self.vocabularios = texto, []
+
+    def transcrever(self, audio, idioma=None, dica=None, rapido=False, vocabulario=None):
+        self.vocabularios.append(vocabulario)
+        return self.texto
+
+
+rapido_ruim, bom = TranscritorFalso("Taz, open"), TranscritorFalso("Tars, open Firefox.")
+ouv = voz.Ouvinte(lambda texto: None, "en", transcritor=bom, transcritor_ativacao=rapido_ruim, aquecer=False,
+                  vocabulario=lambda: ["Firefox", "Steam"])
+assert ouv._nome_no_trecho(b"\0\0" * 16000 * 2, None, "en") == (True, "open Firefox")
+assert bom.vocabularios[-1] == ["Firefox", "Steam"]
+rapido_nada = TranscritorFalso("Good morning everyone")
+ouv2 = voz.Ouvinte(lambda texto: None, "en", transcritor=bom, transcritor_ativacao=rapido_nada, aquecer=False)
+bom.vocabularios.clear()
+assert ouv2._nome_no_trecho(b"\0\0" * 16000 * 2, None, "en") == (False, "") and not bom.vocabularios
+print("OK: 'Taz' no modelo rápido -> o modelo bom confere e acha 'TARS'; fala comum nem passa pelo modelo bom")
+
+# 3. Fala frase a frase, com Parar no meio
+geradas, tocadas = [], []
+
+
+class FaladorTeste(voz.Falador):
+    def _gerar(self, texto, idioma, destino, cancelar=None):
+        time.sleep(0.05)
+        geradas.append(texto)
+        Path(destino).write_bytes(b"RIFF" + b"\0" * 100)
+        return True
+
+    def _tocar_arquivo(self, tocador, wav, cancelar):
+        if cancelar.is_set():
+            return
+        tocadas.append(geradas[len(tocadas)])
+        time.sleep(0.15)
+
+
+f = FaladorTeste(tocar=["true"])
+texto = "Primeira frase, com um pouco de texto pra ter tamanho. Segunda frase, também com bastante texto. " \
+        "Terceira frase, a última, igualmente longa pra não juntar."
+f._falar_de_fato(texto, "en")
+assert tocadas == geradas and len(tocadas) == 3, (geradas, tocadas)
+assert not f.falando.is_set()
+assert not list(Path(tempfile.gettempdir()).glob("opentars-fala-*.wav")), "wav temporário ficou pra trás"
+geradas.clear(), tocadas.clear()
+t = threading.Thread(target=f._falar_de_fato, args=(texto, "en"))
+t.start()
+time.sleep(0.12)
+f.parar()
+t.join(3)
+assert not t.is_alive() and len(tocadas) < 3 and not f.falando.is_set(), tocadas
+print("OK: fala frase a frase, sem sobrar arquivo, e o Parar corta no meio")
+
+print("\nTUDO OK.")

app/tests/test_voz_progresso.py

@@ -0,0 +1,86 @@
+"""26/10: o download da voz tem barra de verdade: o Kokoro é medido em bytes (Content-Length), o resto fica em movimento.
+Sem internet: `requests.get` é de mentira."""
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+os.environ["QT_QPA_PLATFORM"] = "offscreen"
+os.environ["TARS_PASTA_KOKORO"] = tempfile.mkdtemp(prefix="opentars-kokoro-")
+from _util import RAIZ  # noqa: E402,F401
+
+import requests  # noqa: E402
+import tars_voz as voz  # noqa: E402
+
+voz.pasta_kokoro = lambda: Path(os.environ["TARS_PASTA_KOKORO"])
+TAMANHOS = {"kokoro-v1.0.onnx": 3_000_000, "voices-v1.0.bin": 1_000_000}
+
+
+class _Resp:
+    def __init__(self, url):
+        self.tamanho = TAMANHOS[next(n for n in TAMANHOS if n in url)]
+        self.headers = {"Content-Length": str(self.tamanho)}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def raise_for_status(self):
+        pass
+
+    def iter_content(self, bloco):
+        for i in range(0, self.tamanho, bloco):
+            yield b"x" * min(bloco, self.tamanho - i)
+
+
+requests.get = lambda url, **k: _Resp(url)
+passos = []
+ok, erro = voz.baixar_voz("en", lambda m: None, progresso=lambda f, t: passos.append((round(f, 3), t)))
+assert ok, erro
+fracoes = [f for f, _ in passos]
+assert fracoes == sorted(fracoes) and fracoes[-1] > 0.99 and fracoes[0] < 0.1, fracoes[:3]
+assert all("MB" in t for _, t in passos)
+assert (voz.pasta_kokoro() / "kokoro-v1.0.onnx").stat().st_size == 3_000_000 and not list(voz.pasta_kokoro().glob("*.parte"))
+print("OK: o download do Kokoro reporta a fração em bytes, do começo ao fim, sem sobra de arquivo parcial")
+
+passos.clear()
+ok, _ = voz.baixar_voz("en", lambda m: None, progresso=lambda f, t: passos.append(f))
+assert ok and passos == [], "já baixado: nada a medir"
+print("OK: o que já está baixado não baixa de novo")
+
+# a janela: a barra mostra a fração e some no fim
+from PySide6.QtWidgets import QApplication  # noqa: E402
+from tars_qt import configuracoes as cfgmod  # noqa: E402
+app = QApplication.instance() or QApplication([])
+
+
+class _N:
+    def config_voz(self): return {"falar": False}
+    def preferencias_voz(self): return {"velocidade": 1.0}
+    def voz_atual(self): return "af_heart"
+    def o_que_falta_voz(self): return ["voz"]
+    def descrever_falta_voz(self, f): return "voz"
+    def salvar_config_voz(self, **k): pass
+
+    def instalar_voz(self, avisar=None, progresso=None):
+        progresso(None, "pip install faster-whisper")
+        progresso(0.5, "kokoro-v1.0.onnx: 160 / 310 MB")
+        return True, ""
+
+
+class _C:
+    nucleo = _N()
+    def depois(self, f): f()
+    def em_segundo_plano(self, trabalho, pronto): pronto(trabalho())
+
+
+pagina = cfgmod.PVoz(_C())
+vistos = []
+original = pagina.barra.setValue
+pagina.barra.setValue = lambda v: (vistos.append(v), original(v))[1]
+pagina._instalar()
+assert 50 in vistos and not pagina.barra.isVisibleTo(pagina)
+print("OK: a janela mostra a barra do download da voz e a esconde no fim")
+print("test_voz_progresso: TUDO OK.")

app/tests/test_voz_v30.py

@@ -0,0 +1,336 @@
+"""3.0: voz — microfone em trechos, palavra de ativação "TARS", texto pra
+fala, e o Ouvinte de ponta a ponta com áudio sintético e um "Whisper" falso.
+Não precisa de microfone, Whisper nem Piper instalados."""
+
+import array
+import math
+import os
+import tempfile
+
+os.environ.setdefault("XDG_DATA_HOME", tempfile.mkdtemp(prefix="opentars-dados-"))
+from _util import carregar_tars  # noqa: E402
+
+tars = carregar_tars()
+voz = tars.voz_lib
+TAXA = voz.TAXA
+
+
+def tom(segundos, amplitude=6000, freq=220):
+    n = int(TAXA * segundos)
+    a = array.array("h", (int(amplitude * math.sin(2 * math.pi * freq * i / TAXA)) for i in range(n)))
+    return a.tobytes()
+
+
+def silencio(segundos, amplitude=40):
+    n = int(TAXA * segundos)
+    a = array.array("h", ((amplitude if (i // 7) % 2 else -amplitude) for i in range(n)))
+    return a.tobytes()
+
+
+def frequencia(audio):
+    """Frequência do tom no áudio (ignora o silêncio): o 'Whisper' falso
+    reconhece a fala pela 'voz' (cada frase de teste tem um tom)."""
+    a = array.array("h")
+    a.frombytes(audio)
+    fortes = [x for x in a if abs(x) > 300]
+    if len(fortes) < 100:
+        return 0
+    trocas = sum(1 for x, y in zip(a, a[1:]) if abs(x) > 300 or abs(y) > 300 if (x < 0) != (y < 0))
+    return trocas / 2 / (len(fortes) / TAXA)
+
+
+# ------------------------------------------------------------
+# 1. Segmentador: acha as falas no meio do silêncio
+# ------------------------------------------------------------
+audio = silencio(1.0) + tom(0.8) + silencio(1.0) + tom(0.1) + silencio(1.0) + tom(1.5, freq=330) + silencio(1.0)
+seg = voz.Segmentador()
+trechos = []
+for i in range(0, len(audio), 1234):  # pedaços de tamanho qualquer, como vêm do arecord
+    trechos += seg.alimentar(audio[i:i + 1234])
+assert len(trechos) == 2, [len(t) for t in trechos]                    # o estalo de 0,1 s não conta
+dur = [len(t) / 2 / TAXA for t in trechos]
+assert 0.8 <= dur[0] <= 0.8 + (voz.SILENCIO_FIM_MS + voz.PRE_ROLL_MS) / 1000 + 0.1, dur
+assert 1.5 <= dur[1] <= 1.5 + (voz.SILENCIO_FIM_MS + voz.PRE_ROLL_MS) / 1000 + 0.1, dur
+assert seg.limiar == voz.LIMIAR_MINIMO, "ruído baixo: limiar mínimo"
+print(f"OK: segmentador acha as 2 falas ({dur[0]:.2f}s e {dur[1]:.2f}s) e ignora o estalo de 0,1 s")
+
+barulho = voz.Segmentador()
+for _ in range(50):
+    barulho.alimentar(silencio(0.1, amplitude=900))
+assert barulho.limiar > 2000 and not barulho.alimentar(silencio(2, amplitude=900)), "ruído de fundo alto não é fala"
+print(f"OK: com ruído de fundo (ventoinha), o limiar sobe pra {barulho.limiar:.0f} e o ruído não vira fala")
+
+# ------------------------------------------------------------
+# 2. Palavra de ativação
+# ------------------------------------------------------------
+casos = {
+    "TARS, abre o Firefox.": (True, "abre o Firefox"),
+    "Ei Tars abre o spotify": (True, "abre o spotify"),
+    "Hey Tarz, what's the weather?": (True, "what's the weather"),
+    "ok thars": (True, ""),
+    "Tars.": (True, ""),
+    "OpenTARS, fecha a aba": (True, "fecha a aba"),
+    "Oye Tars, abre el navegador": (True, "abre el navegador"),
+    "eu tava vendo aquele filme com o tars ontem": (False, ""),
+    "abre o firefox": (False, ""),
+    "Mars is a planet": (False, ""),
+    "tarsila do amaral": (False, ""),
+    "Ei… TARS, abre o Firefox": (True, "abre o Firefox"),       # "…" vira 3 caracteres no NFKD
+    "Olá TARS, finaliza o download": (True, "finaliza o download"),
+}
+for frase, esperado in casos.items():
+    assert voz.achar_ativacao(frase) == esperado, (frase, voz.achar_ativacao(frase))
+print(f"OK: 'TARS' no começo (e variações do Whisper) chama; no meio da frase ou parecido, não ({len(casos)} casos)")
+
+# ------------------------------------------------------------
+# 3. Texto -> fala
+# ------------------------------------------------------------
+md = ("## Pronto!\n\nAbri o **Firefox** e pesquisei [RTX 5060](https://x.com/y).\n\n"
+      "```bash\nsudo apt update\n```\n- item um\n- item dois 🚀\n| a | b |\n")
+fala = voz.limpar_para_fala(md)
+assert fala == "Pronto!. Abri o Firefox e pesquisei RTX 5060. item um. item dois" or "sudo" not in fala, fala
+assert "**" not in fala and "http" not in fala and "sudo" not in fala and "🚀" not in fala and "|" not in fala, fala
+longo = voz.limpar_para_fala("Frase curta. " * 200)
+assert len(longo) <= voz.LIMITE_FALA and longo.endswith("."), longo[-30:]
+print(f"OK: markdown, código, links e emoji saem da fala: '{fala}'")
+
+# ------------------------------------------------------------
+# 4. Programas e o que falta
+# ------------------------------------------------------------
+assert voz.comando_gravar(lambda p: p == "parecord")[0] == "parecord"
+assert voz.comando_gravar(lambda p: False) is None
+assert voz.comando_tocar(lambda p: p in ("aplay", "paplay"))[0] == "paplay"
+falta = voz.o_que_falta("pt_BR", existe=lambda p: False, tem_modulo=lambda m: False)
+assert falta == ["faster-whisper", "kokoro-onnx", "voz", "gravador", "tocador"], falta
+# 4.0: Kokoro (um modelo pra todas as vozes); Piper só de reserva
+assert voz.arquivo_voz("pt_BR").name == voz.arquivo_voz("en").name == "kokoro-v1.0.onnx"
+assert voz.voz_kokoro("pt_BR") == ("pf_dora", "pt-br") and voz.voz_kokoro("de") == ("af_heart", "en-us")
+assert voz.urls_voz_piper("pt_BR")[0].endswith("en/en_US/lessac/medium/en_US-lessac-medium.onnx?download=true")
+texto = tars.descrever_falta_voz(["kokoro-onnx", "gravador"])
+assert "kokoro-onnx" in texto and "alsa-utils" in texto, texto
+print("OK: acha gravador/tocador que houver, diz o que falta (em português) e de onde vem a voz de cada idioma")
+
+# ------------------------------------------------------------
+# 5. Ouvinte de ponta a ponta (áudio sintético, Whisper falso)
+# ------------------------------------------------------------
+
+
+class WhisperFalso:
+    """Devolve o texto 'falado' no trecho: pela frequência do tom (chaves
+    >= 100, em Hz) ou pela duração (chaves pequenas, em segundos)."""
+
+    def __init__(self, falas):
+        self.falas = falas
+        self.chamadas = 0
+
+    def transcrever(self, audio, idioma=None, dica="", rapido=False):
+        self.chamadas += 1
+        if min(self.falas) >= 100:
+            f = frequencia(audio)
+            return min(self.falas.items(), key=lambda kv: abs(kv[0] - f))[1]
+        dur = len(audio) / 2 / TAXA
+        return min(self.falas.items(), key=lambda kv: abs(kv[0] - dur))[1]
+
+
+def rodar_ouvinte(modo, blocos, falas):
+    pedidos, estados = [], []
+    rapido, bom = WhisperFalso(falas), WhisperFalso(falas)
+    ouv = voz.Ouvinte(pedidos.append, "pt_BR", modo=modo, ao_estado=estados.append,
+                      gravar=lambda: iter(blocos), transcritor=bom, transcritor_ativacao=rapido)
+    ouv._rodar()
+    return pedidos, estados, rapido, bom
+
+
+def picotar(audio, n=3200):
+    return [audio[i:i + n] for i in range(0, len(audio), n)]
+
+
+falas = {200: "o tempo está bom hoje", 300: "TARS, abre a calculadora", 400: "Tars", 500: "fecha o spotify"}
+audio = (silencio(0.5) + tom(1.0, freq=200) + silencio(1) + tom(1.8, freq=300) + silencio(1) + tom(0.6, freq=400)
+         + silencio(1) + tom(1.3, freq=500) + silencio(1))
+pedidos, estados, rapido, bom = rodar_ouvinte("ativacao", picotar(audio), falas)
+assert pedidos == ["abre a calculadora", "fecha o spotify"], (pedidos, falas)
+assert "chamado" in estados and estados[-1] == "parado"
+assert rapido.chamadas == 3 and bom.chamadas == 2, (rapido.chamadas, bom.chamadas)
+print("OK: conversa normal é ignorada; 'TARS, abre a calculadora' vira pedido; 'TARS' + pausa + 'fecha o spotify' também")
+
+pedidos, estados, _, bom = rodar_ouvinte("uma_vez", picotar(silencio(0.3) + tom(1.2) + silencio(1) + tom(1.2)),
+                                         {1.9: "abre o gimp", 1.8: "abre o gimp", 2.0: "abre o gimp"})
+assert pedidos == ["abre o gimp"] and bom.chamadas == 1, (pedidos, bom.chamadas)
+print("OK: 'Falar agora' (Ctrl+M): a primeira fala é o pedido, sem precisar dizer TARS, e para de ouvir")
+
+
+class FaladorFalso:
+    def __init__(self):
+        import threading
+        self.falando = threading.Event()
+
+
+f = FaladorFalso()
+f.falando.set()
+pedidos = []
+ouv = voz.Ouvinte(pedidos.append, "pt_BR", modo="uma_vez", falador=f,
+                  gravar=lambda: iter(picotar(silencio(0.3) + tom(1.2) + silencio(1))),
+                  transcritor=WhisperFalso({1.9: "TARS, desliga"}), transcritor_ativacao=WhisperFalso({1.9: "x"}))
+ouv._rodar()
+assert pedidos == [], "enquanto o openTARS fala, ele não ouve a própria voz"
+print("OK: enquanto está falando, não escuta (a própria voz não vira pedido)")
+
+# ------------------------------------------------------------
+# 6. Responder falando só quando a pessoa quer
+# ------------------------------------------------------------
+falou = []
+tars.falador = lambda: type("F", (), {"falar": lambda self, texto, idioma, ao_terminar=None: falou.append(texto) or True})()
+tars.o_que_falta_voz = lambda: []
+tars.salvar_config_voz(falar=False)
+assert not tars.falar_resposta("Abri o Firefox.") and falou == []
+assert tars.falar_resposta("Abri o Firefox.", forcar=True) and falou == ["Abri o Firefox."]
+tars.salvar_config_voz(falar=True)
+assert tars.config_voz()["falar"] and tars.falar_resposta("Pronto.")
+assert not tars.falar_resposta(tars.RESPOSTA_INTERROMPIDA)
+tars.o_que_falta_voz = lambda: ["voz"]
+assert not tars.falar_resposta("Pronto.", forcar=True), "sem a voz instalada, fica quieto"
+print("OK: fala a resposta se 'responder falando' estiver ligado ou se o pedido veio por voz")
+
+# duas falas seguidas: a primeira acabar não pode "destravar" o microfone
+fal = voz.Falador()
+fal._comecou()
+fal._comecou()
+fal._acabou()
+assert fal.falando.is_set(), "a segunda fala ainda está tocando"
+fal._acabou()
+assert not fal.falando.is_set()
+print("OK: com duas falas sobrepostas, o microfone só volta quando a última acaba")
+
+# ------------------------------------------------------------
+# 7. Resposta rápida ao "TARS" (Endurance Neo: Whisper sempre em inglês)
+# ------------------------------------------------------------
+class ModeloFalso:
+    def __init__(self):
+        self.opcoes = []
+
+    def transcribe(self, dados, **opcoes):
+        self.opcoes.append(dict(opcoes))
+        if "without_timestamps" in opcoes:
+            raise TypeError("transcribe() got an unexpected keyword argument 'without_timestamps'")
+        return iter([type("S", (), {"text": " TARS, open the browser."})()]), None
+
+
+tr = voz.Transcritor("teste")
+voz.Transcritor._cache["teste"] = modelo = ModeloFalso()
+assert tr.transcrever(silencio(0.5), "pt_BR", rapido=True) == "TARS, open the browser."
+o = modelo.opcoes[-1]
+assert o["language"] == "pt" and o["initial_prompt"] == "TARS, openTARS." and o["temperature"] == 0.0
+assert o["max_new_tokens"] == 12 and o["beam_size"] == 1 and "without_timestamps" not in o
+assert tr.transcrever(silencio(0.5), "en", rapido=True) and modelo.opcoes[-1]["language"] == "en"
+assert voz.achar_ativacao("Tas, open Firefox") == (False, "")
+print("OK: Whisper no idioma da voz (pt/en), só com o nome de dica, sem refazer com outras temperaturas; "
+      "faster-whisper antigo funciona")
+
+
+class WhisperCronometrado(WhisperFalso):
+    def __init__(self, falas, nome, linha):
+        super().__init__(falas)
+        self.nome, self.linha, self.aquecido = nome, linha, False
+
+    def transcrever(self, audio, idioma=None, dica="", rapido=False):
+        self.linha.append((self.nome, round(len(audio) / 2 / TAXA, 2)))
+        return super().transcrever(audio, idioma, rapido=rapido)
+
+    def aquecer(self):
+        self.aquecido = True
+
+
+class FaladorConfirma:
+    def __init__(self):
+        self.falando = threading.Event()
+        self.confirmados = []
+
+    def confirmar(self, idioma):
+        self.confirmados.append(idioma)
+
+    def preparar_confirmacao(self, idioma):
+        pass
+
+
+import threading  # noqa: E402
+
+linha, estados, pedidos = [], [], []
+audio = silencio(0.4) + tom(2.2) + silencio(1.0)
+rapido = WhisperCronometrado({220: "TARS, abre"}, "tiny", linha)
+bom = WhisperCronometrado({220: "TARS, abre a calculadora"}, "base", linha)
+
+
+def estado(e):
+    estados.append((e, len(linha)))
+
+
+ouv = voz.Ouvinte(pedidos.append, "pt_BR", ao_estado=estado, gravar=lambda: iter(picotar(audio, 1600)),
+                  transcritor=bom, transcritor_ativacao=rapido, falador=FaladorConfirma())
+ouv._rodar()
+assert rapido.aquecido and bom.aquecido, "os dois Whisper são aquecidos antes da primeira fala"
+assert pedidos == ["abre a calculadora"], pedidos
+assert [n for n, _ in linha] == ["tiny", "base"], linha           # o tiny não roda de novo no fim
+assert linha[0][1] <= voz.CEDO_MAX_S, linha                       # só o começo da fala
+chamado = next(i for i, (e, _) in enumerate(estados) if e == "chamado")
+transcrevendo = next(i for i, (e, _) in enumerate(estados) if e == "transcrevendo")
+assert chamado < transcrevendo and estados[0][0] == "carregando"
+print("OK: 'TARS, abre a calculadora' — o nome é conferido com a pessoa ainda falando (tela mostra na hora); "
+      "no fim, só o pedido é transcrito")
+
+# "TARS" sozinho: responde "Sim?" e a próxima fala é o pedido; depois, conversa sem o nome
+f = FaladorConfirma()
+audio = silencio(0.4) + tom(0.5, freq=400) + silencio(1.0) + tom(1.2, freq=250) + silencio(1.0)
+pedidos = []
+ouv = voz.Ouvinte(pedidos.append, "pt_BR", gravar=lambda: iter(picotar(audio, 1600)), falador=f,
+                  transcritor=WhisperFalso({250: "abre o gimp", 400: "Tars"}),
+                  transcritor_ativacao=WhisperFalso({400: "Tars.", 250: "abre o gimp"}))
+ouv._rodar()
+assert f.confirmados == ["pt_BR"] and pedidos == ["abre o gimp"], (f.confirmados, pedidos)
+ouv._thread = type("T", (), {"is_alive": lambda self: True})()
+ouv.abrir_conversa()
+assert ouv._esperando_pedido()
+print("OK: 'TARS' sozinho responde 'Sim?' (na voz do idioma) e ouve o pedido; depois de responder, dá pra "
+      "continuar sem dizer o nome")
+
+wav = voz.sininho_wav()
+assert wav[:4] == b"RIFF" and len(wav) > 5000
+print("OK: sininho de confirmação gerado na hora (sem arquivo nenhum pra baixar)")
+
+# 5.0: "segurar para falar": soltar o botão fecha a fala em andamento sem esperar o silêncio
+seg = voz.Segmentador()
+seg.alimentar(b"\x00\x00" * (voz.TAXA * 1))                # 1 s de silêncio: aprende o ruído de fundo
+fala_parcial = bytes(voz.array.array("h", [8000, -8000] * (voz.TAXA // 2)))   # 1 s de "fala", sem silêncio depois
+assert seg.alimentar(fala_parcial) == [] and seg.falando_ms > 0
+trecho = seg.encerrar()
+assert trecho and seg.falando_ms == 0 and seg.encerrar() is None
+seg2 = voz.Segmentador()
+seg2.alimentar(b"\x00\x00" * (voz.TAXA * 1))
+seg2.alimentar(bytes(voz.array.array("h", [8000, -8000] * 800)))   # 100 ms: curto demais
+assert seg2.encerrar() is None, "estalo curtíssimo não vira pedido"
+
+# ... e pelo Ouvinte: soltou o botão, o pedido sai
+silencio_ini = b"\x00\x00" * (voz.TAXA * 1)
+fala = bytes(voz.array.array("h", [8000, -8000] * (voz.TAXA // 2)))
+pedidos5 = []
+ouv5 = voz.Ouvinte(pedidos5.append, "en", modo="uma_vez", aquecer=False,
+                   transcritor=type("T", (), {"transcrever": lambda self, a, i=None, dica=None, rapido=False, vocabulario=None: "open the browser",
+                                              "aquecer": lambda self: None})(),
+                   transcritor_ativacao=type("T", (), {"transcrever": lambda self, *a, **k: "", "aquecer": lambda self: None})())
+
+
+def fonte5():
+    yield silencio_ini
+    yield fala
+    ouv5.terminar_fala()          # soltou o botão
+    yield b"\x00\x00" * 480      # o próximo bloco já fecha o trecho
+    yield b"\x00\x00" * 480
+
+
+ouv5._gravar = fonte5
+ouv5.iniciar()
+ouv5._thread.join(timeout=10)
+assert pedidos5 == ["open the browser"], pedidos5
+print("OK: soltar o botão fecha a fala em andamento (segurar para falar)")
+
+print("\nTUDO OK.")

app/tests/test_wait_e_polling.py

@@ -0,0 +1,26 @@
+import time
+
+from _util import carregar_tars
+tars = carregar_tars()
+
+# 4.6: wait_seconds saiu; quem ainda o chama cai no sleep do terminal, limitado a 5 s
+inicio = time.time()
+resultado = tars.executar_ferramenta("wait_seconds", {"seconds": 0.05})
+assert resultado["sucesso"] and time.time() - inicio < 2
+print("OK: wait_seconds antigo vira sleep no terminal:", resultado["mensagem"][:60])
+
+# abrir_aplicativo confirma por polling (processo aparece rápido = retorno rápido)
+tars.psutil.process_iter = lambda *a, **k: iter([
+    type("P", (), {"info": {"name": "minhaapp", "cmdline": ["minhaapp"]}})()
+])
+tars.shutil.which = lambda nome: "/usr/bin/minhaapp" if nome == "minhaapp" else None
+tars.subprocess.Popen = lambda *a, **k: None
+
+inicio = time.time()
+r = tars.abrir_aplicativo("minhaapp")
+decorrido = time.time() - inicio
+assert r["sucesso"]
+assert decorrido < tars.TIMEOUT_POLL_PROCESSO_SEG
+print(f"OK: app confirmado rápido via polling ({decorrido:.2f}s, bem abaixo do teto de {tars.TIMEOUT_POLL_PROCESSO_SEG}s)")
+
+print("\nTUDO OK.")

opentars_all.deb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9171c5f46683e00be01c391364028b0abdec92610497140bdb394cc00381266a
+size 1270260