openTARS 5.3 Tesseract

README.md

@@ -20,7 +20,7 @@ This repository is a **mirror** of the app for people who find openTARS here. Th
 
 ## What is here
 
-- `opentars_all.deb`: the Ubuntu/Debian package (version 5.2 "Ranger", revision 2026110101).
+- `opentars_all.deb`: the Ubuntu/Debian package (version 5.3 "Tesseract", revision 2026111301).
 - `app/`: the application source and the installers (`app/empacotamento/`).
 - `LICENSE`: MIT.
 
@@ -41,13 +41,15 @@ curl -fsSL https://raw.githubusercontent.com/project-opentars/OpenTARS/main/app/
 Ubuntu, Debian and derivatives:
 
 ```bash
-wget -O /tmp/opentars.deb https://github.com/project-opentars/OpenTARS/raw/main/opentars_all.deb && sudo apt install -y --reinstall /tmp/opentars.deb
+wget -O /tmp/opentars.deb https://github.com/project-opentars/OpenTARS/releases/latest/download/opentars_all.deb && sudo apt install -y --reinstall /tmp/opentars.deb
 ```
 
-The Windows and macOS installers are still early and have only been tested in automated runs and on one Windows laptop. Read the script before running it: the install commands above download and run code from GitHub.
+The app downloads its engine (llama.cpp) and Gargantua 2.5 the first time it opens, each checked against a fixed SHA-256. The install commands above download and run code from GitHub; read the script first if you like. How to verify the package: https://project-opentars.github.io/OpenTARS/verify.html
 
 ## Models
 
-- [Gargantua 2](https://huggingface.co/OpenTARS/Gargantua-2): the main model (2B, with vision).
-- [Gargantua 2 Lite](https://huggingface.co/OpenTARS/Gargantua-2-Lite): the 0.8B model that runs on the CPU.
+- [Gargantua 2.5](https://huggingface.co/OpenTARS/Gargantua-2.5): the main model (Gemma 4 E4B, with vision and audio).
+- [Gargantua Lite Gen 3](https://huggingface.co/OpenTARS/Gargantua-2.5-Lite): the smaller model (Gemma 4 E2B).
+- [Gargantua Pro Gen 1](https://huggingface.co/OpenTARS/Gargantua-Pro): the largest model, for missions in a virtual machine (Gemma 4 12B).
+- [Gargantua Code Gen 2](https://huggingface.co/OpenTARS/Gargantua-Code-Gen2): for programming.
 - [Murph](https://huggingface.co/OpenTARS/Murph): the tiny request classifier built into the app.

app/empacotamento/conferir.sh

@@ -42,8 +42,9 @@ fi
 
 echo "== 4/4 REVISAO"
 nova=$(grep -oP '^REVISAO = \K\d+' tars.py)
-publicado="../../opentars_all.deb"
-if [ -f "$publicado" ]; then
+# desde 12/11 os pacotes ficam em pacotes/atual (o mais novo do app é a entrega a superar)
+publicado=$(ls -t ../../pacotes/atual/opentars_*_all.deb ../../opentars_all.deb 2>/dev/null | head -1)
+if [ -n "$publicado" ] && [ -f "$publicado" ]; then
     antiga=$(dpkg-deb -f "$publicado" Version 2>/dev/null | grep -oP '\+\K\d+$' || echo 0)
     if [ "${nova:-0}" -le "${antiga:-0}" ]; then
         problemas+=("REVISAO $nova não é maior que a do opentars_all.deb da entrega ($antiga): suba em tars.py")

app/empacotamento/debian/control

@@ -12,19 +12,15 @@ Provides: tars
 Installed-Size: @TAMANHO@
 Maintainer: Enzo <enzorcasao@gmail.com>
 Homepage: https://github.com/project-opentars/OpenTARS
-Description: 100% local AI assistant for the Linux desktop
- openTARS is an AI assistant that runs entirely on your machine (through
- Ollama), with no cloud. It understands requests in Portuguese and English
- and controls the desktop: opens and closes
- apps, clicks buttons by name, types, searches the web, looks at the screen
- and runs terminal commands.
+Description: local AI assistant for your desktop
+ openTARS is an AI assistant that runs on your own machine. It understands
+ requests in English and Portuguese and works on the desktop: opens and
+ closes apps, clicks buttons by name, types, searches the web, looks at the
+ screen and runs terminal commands, asking before anything risky.
  .
- Its official AI is Gargantua (ollama pull ProjectOpenTARS/Gargantua), a
- small model trained to use openTARS tools, which the installer downloads.
- It also adapts to whatever AI models you already have in Ollama, picking
- the best one for each kind of task. Comes with a window ("opentars-gui"), a
- quick bar opened by a global shortcut ("opentars-gui --rapido") and a
- terminal mode ("opentars --chat") that also works on WSL and on Linux
- without a graphical session. Files (images, text, PDF...) can be attached
- to a request. The optional Cooper model (ollama pull ProjectOpenTARS/cooper)
- helps it look at the screen.
+ Its official AI is Gargantua 2.5 (Gemma 4), trained to use the openTARS
+ tools, which sees images and understands speech. It runs on the llama.cpp
+ engine, downloaded with the models the first time the app opens. Comes with
+ a window ("opentars-gui"), a quick bar opened by a global shortcut, text
+ actions in any app and a terminal mode ("opentars --chat"). Local by
+ default; cloud models are optional and use your own key.

app/empacotamento/debian/postinst

@@ -19,6 +19,8 @@ case "$1" in
         fi
 
         bash /usr/share/opentars/setup.sh || true
+        # sem isto cada abertura recompila tudo: quem usa o app não escreve em /usr/share (-12% ao abrir, medido em 06/11)
+        /usr/share/opentars/venv/bin/python3 -m compileall -q -x /venv/ /usr/share/opentars || true
 
         if command -v update-desktop-database >/dev/null 2>&1; then
             update-desktop-database -q /usr/share/applications || true

app/empacotamento/doc/changelog

@@ -1,3 +1,10 @@
+opentars (5.3) unstable; urgency=medium
+
+  5.3 Tesseract
+  * Em preparo (ainda não publicado): a API do motor mora em tars_motor.py, para a troca do Ollama
+    pelo llama.cpp ter um lugar só; Gargantua Pro e Pi reconhecidos como variantes, com o Pi fora
+    da conversa do app grande (ele tem contrato próprio); Gargantua Code Gen 2 em "Mais modelos".
+
 opentars (5.2) unstable; urgency=medium
 
   5.2 Ranger

app/empacotamento/linux/instalar.sh

@@ -6,9 +6,8 @@
 #
 # O que faz: instala os pacotes do sistema que o openTARS usa pelo gerenciador da distribuição (dnf, pacman, zypper ou
 # apt; é a única parte que pede a senha), baixa o código do app (pasta app/ do repositório) para a pasta do usuário, cria
-# um ambiente Python com o Python do sistema (que enxerga o PyGObject e o tkinter da distribuição), instala o Ollama pelo
-# instalador oficial se faltar, e cria os comandos opentars e opentars-gui em ~/.local/bin e o atalho no menu. O modelo
-# (Gargantua 2) é baixado na primeira abertura, com barra. Rodar de novo atualiza. Remover: "| bash -s -- --remover".
+# um ambiente Python com o Python do sistema (que enxerga o PyGObject e o tkinter da distribuição), e cria os comandos opentars e opentars-gui em ~/.local/bin e o atalho no menu. O motor llama.cpp e o
+# Gargantua 2.5 vêm na primeira abertura (--com-ollama instala o Ollama também). Rodar de novo atualiza. Remover: "| bash -s -- --remover".
 # Suas conversas e configurações (em ~/.config/opentars e ~/.local/share/opentars) ficam; apague as pastas se quiser.
 set -euo pipefail
 
@@ -22,7 +21,7 @@ ICONE="$DADOS/icons/hicolor/scalable/apps/opentars.svg"
 INICIO="${XDG_CONFIG_HOME:-$HOME/.config}/autostart"
 ZIP="https://github.com/project-opentars/OpenTARS/archive/refs/heads/main.zip"
 FONTE=""            # --fonte PASTA: a pasta app/ local em vez de baixar (o CI usa)
-SEM_OLLAMA=0        # --sem-ollama: não instala o Ollama (o CI usa)
+SEM_OLLAMA=1        # 5.3: o motor é o llama.cpp (o app baixa); --com-ollama instala o Ollama também; --sem-ollama fica aceito
 SEM_SISTEMA=0       # --sem-sistema: não instala pacotes do sistema (quem já instalou à mão, ou sem sudo)
 REMOVER=0
 while [ $# -gt 0 ]; do
@@ -30,6 +29,7 @@ while [ $# -gt 0 ]; do
         --remover) REMOVER=1 ;;
         --fonte) FONTE="$2"; shift ;;
         --sem-ollama) SEM_OLLAMA=1 ;;
+        --com-ollama) SEM_OLLAMA=0 ;;
         --sem-sistema) SEM_SISTEMA=1 ;;
     esac
     shift
@@ -129,7 +129,14 @@ if ! "$VENV/bin/python3" -c "import sys" >/dev/null 2>&1; then
         exit 1; }
 fi
 "$VENV/bin/python3" -m pip install --quiet --upgrade pip
-"$VENV/bin/python3" -m pip install --quiet requests psutil pyautogui pillow PySide6-Essentials numpy onnxruntime
+"$VENV/bin/python3" -m pip install --quiet requests psutil pyautogui pillow PySide6-Essentials numpy
+# 07/11: o Fedora passou ao Python 3.15 e o onnxruntime ainda não tem pacote para ele; sem ele o app roda, só as
+# edições de foto com modelinho (tirar o fundo, aumentar, remover objeto) ficam de fora
+"$VENV/bin/python3" -m pip install --quiet onnxruntime || dizer "Aviso: o onnxruntime não instala neste Python; tirar o fundo e as outras edições com modelinho ficam desligadas." \
+    "Warning: onnxruntime does not install on this Python; background removal and the other model-based photo edits are off."
+# 08/11 (5.3): o cofre de senhas para o e-mail do assistente; sem ele o app roda, só o e-mail fica desligado
+"$VENV/bin/python3" -m pip install --quiet keyring || dizer "Aviso: o keyring não instala neste Python; o e-mail do assistente fica desligado." \
+    "Warning: keyring does not install on this Python; the assistant's email stays off."
 
 # 4. O Ollama, pelo instalador oficial (ele mesmo pede a senha). Sem ele o openTARS abre, mas não tem IA local.
 if [ "$SEM_OLLAMA" = 0 ]; then
@@ -165,8 +172,8 @@ sed "s|/usr/bin/opentars-gui|\"$BIN/opentars-gui\"|" "$TEMP/desktop/opentars.des
 cp "$APP/empacotamento/icone/opentars.svg" "$ICONE"
 command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q "$(dirname "$ATALHO")" || true
 
-dizer "Pronto. Abra o openTARS pelo menu de aplicativos (na primeira vez ele baixa o Gargantua 2, com barra)." \
-      "Done. Open openTARS from the application menu (the first time it downloads Gargantua 2, with a progress bar)."
+dizer "Pronto. Abra o openTARS pelo menu de aplicativos (na primeira vez ele baixa o Gargantua 2.5, com barra)." \
+      "Done. Open openTARS from the application menu (the first time it downloads Gargantua 2.5, with a progress bar)."
 case ":$PATH:" in *":$BIN:"*) ;; *) dizer "Os comandos ficaram em $BIN; para usar no terminal: export PATH=\"$BIN:\$PATH\"" \
                                            "The commands are in $BIN; to use them in a terminal: export PATH=\"$BIN:\$PATH\"" ;; esac
 dizer "Para conferir e medir: 'opentars --diagnostico' e 'opentars --prova'; mande os relatórios que eles salvam." \

app/empacotamento/macos/instalar.sh

@@ -4,9 +4,9 @@
 #   curl -fsSL https://raw.githubusercontent.com/project-opentars/OpenTARS/main/app/empacotamento/macos/instalar.sh | bash
 #
 # O que faz: baixa o código do app (pasta app/ do repositório), instala o uv (traz o Python), cria um ambiente Python com
-# as dependências, instala o Ollama se faltar (o app oficial, em ~/Applications), monta o openTARS.app em ~/Applications e
+# as dependências, monta o openTARS.app em ~/Applications e
 # o assina ad-hoc (grátis, sem conta da Apple; um app montado no próprio Mac não ganha a marca de quarentena), e cria os
-# comandos opentars e opentars-gui em ~/.local/bin. O modelo (Gargantua 2) é baixado na primeira abertura, com barra.
+# comandos opentars e opentars-gui em ~/.local/bin. O motor llama.cpp e o Gargantua 2.5 vêm na primeira abertura.
 # Rodar de novo atualiza. Remover: o mesmo comando com "| bash -s -- --remover".
 # Suas conversas e configurações (em ~/Library/Application Support/opentars) ficam; apague a pasta se quiser.
 set -euo pipefail
@@ -18,13 +18,14 @@ BIN="$HOME/.local/bin"
 APP_MAC="$HOME/Applications/openTARS.app"
 ZIP="https://github.com/project-opentars/OpenTARS/archive/refs/heads/main.zip"
 FONTE=""            # --fonte PASTA: a pasta app/ local em vez de baixar (o CI usa)
-SEM_OLLAMA=0        # --sem-ollama: não instala o Ollama (o CI usa)
+SEM_OLLAMA=1        # 5.3: o motor é o llama.cpp (o app baixa); --com-ollama instala o Ollama também; --sem-ollama fica aceito
 REMOVER=0
 while [ $# -gt 0 ]; do
     case "$1" in
         --remover) REMOVER=1 ;;
         --fonte) FONTE="$2"; shift ;;
         --sem-ollama) SEM_OLLAMA=1 ;;
+        --com-ollama) SEM_OLLAMA=0 ;;
     esac
     shift
 done
@@ -73,7 +74,7 @@ fi
 dizer "Preparando o Python e as dependências (alguns minutos na primeira vez)..." \
       "Setting up Python and the dependencies (a few minutes the first time)..."
 [ -x "$VENV/bin/python3" ] || "$UV" venv --python 3.12 "$VENV"
-"$UV" pip install --python "$VENV/bin/python3" requests psutil pyautogui pillow PySide6-Essentials numpy onnxruntime pyobjc-framework-ApplicationServices pip
+"$UV" pip install --python "$VENV/bin/python3" requests psutil pyautogui pillow PySide6-Essentials numpy onnxruntime keyring pyobjc-framework-ApplicationServices pip
 
 # 3. O Ollama (o app oficial). Sem ele o openTARS abre, mas não tem IA local.
 if [ "$SEM_OLLAMA" = 0 ]; then
@@ -118,8 +119,8 @@ printf '#!/bin/bash\nexec "%s/bin/python3" "%s/tars.py" "$@"\n' "$VENV" "$APP_CO
 printf '#!/bin/bash\ncd "%s" && exec "%s/bin/python3" -m tars_qt "$@"\n' "$APP_CODIGO" "$VENV" > "$BIN/opentars-gui"
 chmod +x "$BIN/opentars" "$BIN/opentars-gui"
 
-dizer "Pronto. Abra o openTARS em ~/Applications (na primeira vez ele baixa o Gargantua 2, com barra)." \
-      "Done. Open openTARS from ~/Applications (the first time it downloads Gargantua 2, with a progress bar)."
+dizer "Pronto. Abra o openTARS em ~/Applications (na primeira vez ele baixa o Gargantua 2.5, com barra)." \
+      "Done. Open openTARS from ~/Applications (the first time it downloads Gargantua 2.5, with a progress bar)."
 dizer "O macOS vai pedir Acessibilidade e Gravação de Tela para o openTARS clicar e ver a tela: libere em Ajustes do Sistema > Privacidade e Segurança." \
       "macOS will ask for Accessibility and Screen Recording so openTARS can click and see the screen: allow it in System Settings > Privacy & Security."
 # o Terminal do macOS (zsh) não tem ~/.local/bin no PATH: sem isto, "opentars" dá "command not found". Uma linha marcada,

app/empacotamento/setup.sh

@@ -20,7 +20,7 @@ MODELO_AJUDANTE="qwen2.5:0.5b"
 MODELO_AJUDANTE_ANTIGO="gemma3:270m"
 DIR_OPENTARS="/usr/share/opentars"
 VENV="$DIR_OPENTARS/venv"
-DEPENDENCIAS=("requests:requests" "psutil:psutil" "pyautogui:pyautogui" "PIL:pillow" "PySide6:PySide6-Essentials" "numpy:numpy" "onnxruntime:onnxruntime")
+DEPENDENCIAS=("requests:requests" "psutil:psutil" "pyautogui:pyautogui" "PIL:pillow" "PySide6:PySide6-Essentials" "numpy:numpy" "onnxruntime:onnxruntime" "keyring:keyring")
 
 # Textos no idioma do sistema: vêm de idiomas/*.json, pelo mesmo módulo
 # que o openTARS usa (tars_i18n.py). Se algo falhar, aparecem as chaves
@@ -100,7 +100,15 @@ modelos_instalados() {
 # em Docker, via Snap...) conta como instalado: instalar outro por cima
 # criaria um segundo serviço brigando pela mesma porta.
 # ------------------------------------------------------------------
-if command -v ollama >/dev/null 2>&1; then
+# 5.3: o motor padrão é o llama.cpp, que o próprio app baixa no primeiro uso (sem senha), junto com o Gargantua 2.5.
+# O Ollama só entra se a pessoa escolher: TARS_MOTOR=ollama, ou "motor": "ollama" na config (Configurações > Avançado).
+USAR_OLLAMA=0
+if [ "${TARS_MOTOR:-}" = "ollama" ] || grep -qs '"motor": *"ollama"' "$HOME/.config/opentars/config.json"; then
+    USAR_OLLAMA=1
+fi
+if [ "$USAR_OLLAMA" != 1 ]; then
+    msg "$(t motor_llamacpp)"
+elif command -v ollama >/dev/null 2>&1; then
     msg "$(t ollama_ja)"
 elif ollama_responde; then
     msg "$(t ollama_existente url="$OLLAMA_URL")"
@@ -222,12 +230,13 @@ servico_pronto=0
 # Recém-instalado, o serviço leva um instante pra subir. Se o Ollama
 # existe mas o serviço está parado (sem systemd, por exemplo), tenta
 # iniciar.
-if ! ollama_responde && command -v systemctl >/dev/null 2>&1 \
+if [ "$USAR_OLLAMA" = 1 ] && ! ollama_responde && command -v systemctl >/dev/null 2>&1 \
         && systemctl list-unit-files ollama.service >/dev/null 2>&1; then
     systemctl start ollama >/dev/null 2>&1 || true
 fi
 
 for _ in $(seq 1 10); do
+    [ "$USAR_OLLAMA" = 1 ] || break          # com o llama.cpp os modelos vêm pelo app (passos 3d e 4 ficam de fora)
     if ollama_responde; then
         servico_pronto=1
         break
@@ -238,7 +247,7 @@ done
 # 3.0.5: nenhum modelo ajudante é baixado. Quem decide o tipo de cada
 # pedido é a helper Murph, que já vem no pacote (modelos/murph.json).
 msg "$(t helper_murph versao="1.0")"
-if [ "$servico_pronto" -eq 0 ]; then
+if [ "$servico_pronto" -eq 0 ] && [ "$USAR_OLLAMA" = 1 ]; then
     aviso "$(t ollama_nao_respondeu url="$OLLAMA_URL")"
     # 4.5: WSL (e contêiner) costuma não ter systemd: o serviço não sobe sozinho
     if em_wsl || ! command -v systemctl >/dev/null 2>&1; then
@@ -253,10 +262,10 @@ fi
 #     Com ele instalado, o passo 4 não baixa outro modelo de conversa.
 #     TARS_SEM_GARGANTUA=1 pula; TARS_MODELO_GARGANTUA=<nome> troca.
 # ------------------------------------------------------------------
-MODELO_GARGANTUA="${TARS_MODELO_GARGANTUA:-ProjectOpenTARS/Gargantua-2}"
+MODELO_GARGANTUA="${TARS_MODELO_GARGANTUA:-ProjectOpenTARS/Gargantua-2.5}"
 
 # 5.1: máquina fraca (sem placa NVIDIA com 4 GB E com até 6 GB de RAM OU menos de 4 threads) recebe o Gargantua Lite
-# (Qwen3.5 0,8B com visão, 0,6 GB, Gargantua-2:lite). TARS_GARGANTUA=lite|completo força. A mesma regra do primeiro uso (tars_primeiro_uso.py).
+# (Gemma 4 E2B com visão e áudio, 4,4 GB, Gargantua-2.5:lite). TARS_GARGANTUA=lite|completo força. A mesma regra do primeiro uso (tars_primeiro_uso.py).
 maquina_fraca() {
     case "${TARS_GARGANTUA:-}" in lite) return 0 ;; completo) return 1 ;; esac
     local vram=0 ram threads
@@ -269,7 +278,7 @@ maquina_fraca() {
     [ "${ram:-99999}" -le 6200 ] || [ "${threads:-4}" -lt 4 ]
 }
 if [ -z "${TARS_MODELO_GARGANTUA:-}" ] && maquina_fraca; then
-    MODELO_GARGANTUA="ProjectOpenTARS/Gargantua-2:lite"
+    MODELO_GARGANTUA="ProjectOpenTARS/Gargantua-2.5:lite"
 fi
 
 gargantua_instalado() {

app/empacotamento/windows/instalar.ps1

@@ -3,15 +3,16 @@
 #   irm https://raw.githubusercontent.com/project-opentars/OpenTARS/main/app/empacotamento/windows/instalar.ps1 | iex
 #
 # O que faz: baixa o código do app (pasta app/ do repositório), instala o uv (um programa que traz o Python), cria um
-# ambiente Python com as dependências, instala o Ollama se faltar (o instalador oficial, por usuário), cria o atalho
-# no Menu Iniciar e os comandos opentars e opentars-gui. O modelo (Gargantua 2) é baixado na primeira abertura, com barra.
+# ambiente Python com as dependências, cria o atalho
+# no Menu Iniciar e os comandos opentars e opentars-gui. O motor llama.cpp e o modelo (Gargantua 2.5) são baixados na primeira abertura, com barra (-ComOllama instala o Ollama também).
 # Rodar de novo atualiza. Remover:
 #   & ([scriptblock]::Create((irm https://raw.githubusercontent.com/project-opentars/OpenTARS/main/app/empacotamento/windows/instalar.ps1))) -Remover
 # Suas conversas e configurações (em %APPDATA%\opentars) ficam; apague a pasta se quiser.
 param(
     [switch]$Remover,
     [string]$Fonte = "",        # pasta app/ local em vez de baixar (o CI usa)
-    [switch]$SemOllama          # não instala o Ollama (o CI usa)
+    [switch]$SemOllama,         # aceito por compatibilidade (CI, setup.exe): desde a 5.3 o Ollama não entra por padrão
+    [switch]$ComOllama          # 5.3: o motor é o llama.cpp (o app baixa); -ComOllama instala o Ollama também
 )
 $ErrorActionPreference = "Stop"
 $ProgressPreference = "SilentlyContinue"        # a barra do Invoke-WebRequest deixa o download muito lento no 5.1
@@ -87,11 +88,11 @@ if (-not (Test-Path (Join-Path $Venv "Scripts\python.exe"))) {
     & $uvExe venv --python 3.12 $Venv
     if ($LASTEXITCODE) { throw "uv venv failed ($LASTEXITCODE)" }
 }
-& $uvExe pip install --python (Join-Path $Venv "Scripts\python.exe") requests psutil pyautogui pillow PySide6-Essentials numpy onnxruntime uiautomation pip
+& $uvExe pip install --python (Join-Path $Venv "Scripts\python.exe") requests psutil pyautogui pillow PySide6-Essentials numpy onnxruntime keyring uiautomation pip
 if ($LASTEXITCODE) { throw "uv pip install failed ($LASTEXITCODE)" }
 
-# 3. O Ollama (por usuário). Sem ele o openTARS abre, mas não tem IA local.
-if (-not $SemOllama) {
+# 3. O Ollama (por usuário), só com -ComOllama: desde a 5.3 o app usa o motor llama.cpp, que ele mesmo baixa.
+if ($ComOllama -and -not $SemOllama) {
     $ollama = Get-Command ollama -ErrorAction SilentlyContinue
     $ollamaExe = Join-Path $env:LOCALAPPDATA "Programs\Ollama\ollama.exe"
     if (-not $ollama -and -not (Test-Path $ollamaExe)) {
@@ -146,7 +147,7 @@ $atalho.Description = "openTARS"
 $atalho.IconLocation = (Join-Path $App "empacotamento\windows\opentars.ico") + ",0"      # sem isto o atalho mostra o ícone do pythonw
 $atalho.Save()
 
-Dizer "Pronto. Abra o openTARS pelo Menu Iniciar (na primeira vez ele baixa o Gargantua 2, com barra)." `
-      "Done. Open openTARS from the Start menu (the first time it downloads Gargantua 2, with a progress bar)."
+Dizer "Pronto. Abra o openTARS pelo Menu Iniciar (na primeira vez ele baixa o Gargantua 2.5, com barra)." `
+      "Done. Open openTARS from the Start menu (the first time it downloads Gargantua 2.5, with a progress bar)."
 Dizer "Num terminal NOVO: 'opentars --diagnostico' confere tudo e 'opentars --prova' mede a IA; mande os relatórios que eles salvam." `
       "In a NEW terminal: 'opentars --diagnostico' checks everything and 'opentars --prova' measures the AI; send the reports they save."

app/empacotamento/windows/opentars.iss

@@ -0,0 +1,44 @@
+; Instalador .exe do openTARS para Windows: só embrulha o instalar.ps1 (que continua sendo a fonte de verdade), para o winget
+; ter um instalador de verdade e para o openTARS aparecer em "Aplicativos instalados". Sem administrador, sem assinatura paga.
+; Compilar (Windows, Inno Setup 6):  iscc /DVersao=5.3 windows\opentars.iss   (a saída vai para dist\opentars-setup.exe)
+#ifndef Versao
+  #define Versao "0.0"
+#endif
+[Setup]
+AppId={{C6BAED4F-7BE2-421A-A5D8-3516502824C6}
+AppName=openTARS
+UninstallDisplayName=openTARS
+AppVersion={#Versao}
+AppPublisher=project-opentars
+AppPublisherURL=https://project-opentars.github.io/OpenTARS/
+AppSupportURL=https://github.com/project-opentars/OpenTARS/issues
+DefaultDirName={localappdata}\openTARS-setup
+DisableDirPage=yes
+DisableProgramGroupPage=yes
+PrivilegesRequired=lowest
+OutputDir=..\..\dist
+OutputBaseFilename=opentars-setup
+SetupIconFile=opentars.ico
+UninstallDisplayIcon={localappdata}\openTARS\app\empacotamento\windows\opentars.ico
+Compression=lzma2
+SolidCompression=yes
+WizardStyle=modern
+ArchitecturesInstallIn64BitMode=x64compatible
+
+[Files]
+Source: "instalar.ps1"; DestDir: "{app}"; Flags: ignoreversion
+Source: "..\..\*"; DestDir: "{app}\app"; Excludes: "tests,gargantua,docs,dist,__pycache__,*.pyc,.git"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Run]
+; o instalar.ps1 faz o resto (Python pelo uv, dependências, atalhos, PATH); com /SemOllama o CI pula o download do Ollama
+Filename: "powershell.exe"; Parameters: "-NoProfile -ExecutionPolicy Bypass -File ""{app}\instalar.ps1"" -Fonte ""{app}\app""{code:SemOllama}"; \
+  StatusMsg: "Instalando o openTARS (alguns minutos na primeira vez)..."; Flags: runhidden waituntilterminated
+
+[UninstallRun]
+Filename: "powershell.exe"; Parameters: "-NoProfile -ExecutionPolicy Bypass -File ""{app}\instalar.ps1"" -Remover"; Flags: runhidden waituntilterminated; RunOnceId: "RemoverOpenTARS"
+
+[Code]
+function SemOllama(Param: String): String;
+begin
+  if WizardSilent and (ExpandConstant('{param:SemOllama|0}') = '1') then Result := ' -SemOllama' else Result := '';
+end;

app/empacotamento/winget/gerar.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Gera os 3 manifestos do winget para uma Release do openTARS.
+#   bash gerar.sh 5.3 CAMINHO/opentars-setup.exe [saida]
+# Depois: copiar a pasta para manifests/p/project-opentars/openTARS/<versao>/ de um fork de microsoft/winget-pkgs e abrir o PR.
+set -euo pipefail
+VERSAO="$1"; EXE="$2"; SAIDA="${3:-saida/$VERSAO}"
+SHA=$(sha256sum "$EXE" | cut -d' ' -f1 | tr a-f A-F)
+URL="https://github.com/project-opentars/OpenTARS/releases/download/$VERSAO/opentars-setup.exe"
+mkdir -p "$SAIDA"
+P=project-opentars.openTARS
+cat > "$SAIDA/$P.yaml" <<Y
+# yaml-language-server: \$schema=https://aka.ms/winget-manifest.version.1.6.0.schema.json
+PackageIdentifier: $P
+PackageVersion: $VERSAO
+DefaultLocale: en-US
+ManifestType: version
+ManifestVersion: 1.6.0
+Y
+cat > "$SAIDA/$P.installer.yaml" <<Y
+# yaml-language-server: \$schema=https://aka.ms/winget-manifest.installer.1.6.0.schema.json
+PackageIdentifier: $P
+PackageVersion: $VERSAO
+InstallerType: inno
+Scope: user
+InstallModes: [interactive, silent, silentWithProgress]
+InstallerSwitches:
+  Silent: /VERYSILENT /SUPPRESSMSGBOXES /NORESTART
+  SilentWithProgress: /SILENT /SUPPRESSMSGBOXES /NORESTART
+UpgradeBehavior: install
+ReleaseDate: $(date +%F)
+Installers:
+  - Architecture: x64
+    InstallerUrl: $URL
+    InstallerSha256: $SHA
+ManifestType: installer
+ManifestVersion: 1.6.0
+Y
+cat > "$SAIDA/$P.locale.en-US.yaml" <<Y
+# yaml-language-server: \$schema=https://aka.ms/winget-manifest.defaultLocale.1.6.0.schema.json
+PackageIdentifier: $P
+PackageVersion: $VERSAO
+PackageLocale: en-US
+Publisher: project-opentars
+PublisherUrl: https://project-opentars.github.io/OpenTARS/
+PublisherSupportUrl: https://github.com/project-opentars/OpenTARS/issues
+PackageName: openTARS
+PackageUrl: https://project-opentars.github.io/OpenTARS/
+License: MIT
+LicenseUrl: https://github.com/project-opentars/OpenTARS/blob/main/LICENSE
+ShortDescription: A 100% local AI assistant for your computer, local by default.
+Description: openTARS runs small AI models on your own machine (llama.cpp), controls apps, files and the screen with your approval, and keeps your data at home. Cloud is optional and off by default.
+Moniker: opentars
+Tags: [ai, assistant, local, llm, privacy, llama-cpp]
+ManifestType: defaultLocale
+ManifestVersion: 1.6.0
+Y
+echo "Manifestos em $SAIDA (SHA-256 $SHA)"

app/idiomas/en.json

@@ -466,7 +466,7 @@
  "term.modo_auto_explica": "openTARS picks the best AI for each task by itself.",
  "term.voce": "You",
  "term.conversa_carregada": "previous conversation: {n} request(s) · /clear starts over",
- "term.ajuda": "openTARS {versao} · local AI assistant for Linux\n\nChat\n  opentars                        open the chat in the terminal (continues the last one)\n  opentars --new                  start a new conversation\n  opentars --resume               pick a saved conversation to continue\n  opentars --plan                 plan mode: the AI only describes what it would do\n  opentars --auto                 edits in this folder without asking (delete, send and install still ask)\n  opentars --chat \"request\"       answer one request and exit\n  opentars -p \"request\"           for scripts: only the answer (or --output-format json); reads stdin\n  opentars-gui                    open the window\n  opentars-gui --rapido           open the quick bar (ctrl+alt+space)\n\nModels\n  opentars --model <name>         use this model with -p\n  opentars --explicar \"request\"   show how the task and the model are chosen\n  opentars --avaliar-classificador  measure how often Murph and automatic mode are right\n\nEnvironment\n  opentars --diagnostico          check Ollama, screen and accessibility (changes nothing)\n  opentars --autoteste            diagnosis + a real test with the calculator\n  opentars --setup                install whatever is missing (Ollama, models...)\n\nPreferences\n  opentars --idioma <code>        change the language (pt_BR or en)\n  opentars --atalho [keys|off]    show, change or remove the global shortcut\n  opentars --version              show the version\n\nInside the chat, /help lists the commands. An AGENTS.md in the folder goes into every conversation.",
+ "term.ajuda": "openTARS {versao} · local AI assistant\n\nChat\n  opentars                        open the chat in the terminal (continues the last one)\n  opentars --new                  start a new conversation\n  opentars --resume               pick a saved conversation to continue\n  opentars --plan                 plan mode: the AI only describes what it would do\n  opentars --auto                 edits in this folder without asking (delete, send and install still ask)\n  opentars --chat \"request\"       answer one request and exit\n  opentars -p \"request\"           for scripts: only the answer (or --output-format json); reads stdin\n  opentars-gui                    open the window\n  opentars-gui --rapido           open the quick bar (ctrl+alt+space)\n\nModels\n  opentars --model <name>         use this model with -p\n  opentars --explicar \"request\"   show how the task and the model are chosen\n  opentars --avaliar-classificador  measure how often Murph and automatic mode are right\n\nEnvironment\n  opentars --diagnostico          check the engine, screen and accessibility (changes nothing)\n  opentars --autoteste            diagnosis + a real test with the calculator\n  opentars --setup                install whatever is missing (engine, models...)\n  opentars --missao-vm \"task\"      run an agent mission inside a disposable virtual machine (needs the Pro model)\n\nPreferences\n  opentars --idioma <code>        change the language (pt_BR or en)\n  opentars --atalho [keys|off]    show, change or remove the global shortcut\n  opentars --version              show the version\n\nInside the chat, /help lists the commands. An AGENTS.md in the folder goes into every conversation.",
  "idioma.lista_titulo": "Available languages:",
  "idioma.como_trocar": "Change it with: /language <code>  (e.g. /language pt_BR)",
  "idioma.trocado": "Language: {nome}",
@@ -687,8 +687,8 @@
  "gargantua.desligado": "{modelo} installed, but TARS_SEM_GARGANTUA=1: AUTO does not prefer it",
  "gargantua.nao_instalado": "Gargantua is not installed. To get the official openTARS AI: ollama pull {modelo}",
  "setup.gargantua_ja": "Gargantua, the official openTARS AI, is already installed ({modelo}).",
- "setup.gargantua_baixando": "Downloading Gargantua, the official openTARS AI ({modelo}, ~1.6 GB)...",
- "setup.gargantua_segundo_plano": "There is no terminal here to show progress (install from the app store or an automatic install): the Gargantua download (~1.6 GB) continues in the background. openTARS shows the progress when you open it.",
+ "setup.gargantua_baixando": "Downloading Gargantua, the official openTARS AI ({modelo}, ~6.4 GB)...",
+ "setup.gargantua_segundo_plano": "There is no terminal here to show progress (install from the app store or an automatic install): the Gargantua download (~6.4 GB) continues in the background. openTARS shows the progress when you open it.",
  "setup.gargantua_pulado": "TARS_SEM_GARGANTUA=1: Gargantua was not downloaded.",
  "msg.folego": "long task: {etapas} steps, {acoes} actions done; continuing",
  "versao.nova": "openTARS {versao} is out! To update, run the install command again (it's in the GitHub README).",
@@ -717,7 +717,7 @@
  "pu.slogan": "Your assistant that uses your computer, without leaving it.",
  "pu.passo": "Step {n} of {total}",
  "pu.passo.idioma": "Language",
- "pu.passo.ollama": "Ollama",
+ "pu.passo.ollama": "AI engine",
  "pu.passo.nuvem": "Cloud (optional)",
  "pu.passo.gargantua": "Download the models",
  "pu.passo.teste": "Quick test",
@@ -726,16 +726,16 @@
  "pu.pausar": "Pause",
  "pu.retomar": "Resume",
  "pu.tentar_de_novo": "Try again",
- "pu.ollama.titulo": "Looking for Ollama",
- "pu.ollama.texto": "Ollama is the program that runs the AI model on your computer. TARS needs it to work.",
- "pu.ollama.procurando": "Looking for Ollama on this computer…",
- "pu.ollama.ok": "Ollama found on this computer (version {versao})",
+ "pu.ollama.titulo": "Setting up the AI engine",
+ "pu.ollama.texto": "The engine runs the AI model on your computer. openTARS uses llama.cpp; if you already have Ollama, that works too.",
+ "pu.ollama.procurando": "Looking for an AI engine on this computer…",
+ "pu.ollama.ok": "AI engine ready ({versao})",
  "pu.ollama.parado": "Ollama is installed, but not running.",
- "pu.ollama.faltando": "Ollama is not installed yet.",
- "pu.ollama.instalar": "Install Ollama",
+ "pu.ollama.faltando": "The AI engine is missing. It's about 35 MB, no password needed.",
+ "pu.ollama.instalar": "Install the engine",
  "pu.ollama.iniciar": "Start Ollama",
  "pu.ollama.procurar_de_novo": "Look again",
- "pu.ollama.instalando": "Installing Ollama. A system window may ask for your password.",
+ "pu.ollama.instalando": "Downloading the engine (llama.cpp)…",
  "pu.ollama.iniciando": "Starting Ollama…",
  "pu.ollama.erro_instalar": "I couldn't install it: {motivo}",
  "pu.ollama.abri_download": "I opened the Ollama download page in your browser. Install it, open Ollama and click Look again.",
@@ -983,6 +983,7 @@
  "cfg.voz.instalada": "Voice installed.",
  "cfg.voz.erro": "Couldn't install: {erro}",
  "cfg.voz.fala": "Speech",
+ "cfg.voz.resposta_completa": "Read long answers in full (by default only the first sentences are spoken; the rest stays on the screen)",
  "cfg.voz.responder_falando": "Answer out loud",
  "cfg.voz.voz": "Voice",
  "cfg.voz.velocidade": "Speed",
@@ -1126,9 +1127,15 @@
  "mascote.dica8": "Everything runs on your computer: nothing you write leaves it, unless you turn on the cloud.",
  "mascote.dica9": "In Settings you can create routines: TARS does a task by itself at the time you choose.",
  "mascote.dica10": "Type /modelo auto and TARS picks the best model for each request.",
- "term.slogan": "local AI assistant for Linux",
+ "term.slogan": "local AI assistant",
  "term.bem_vindo": "Welcome to openTARS!",
  "term.rotulo_ollama": "ollama:",
+ "term.rotulo_motor": "engine:",
+ "term.rotulo_pasta": "folder:",
+ "term.motor_offline": "offline ({host}) · restart openTARS to start the engine",
+ "cli.regua.perguntar": "ask",
+ "cli.regua.plano": "plan",
+ "cli.regua.automatico": "auto",
  "term.rotulo_modelo": "model:",
  "term.ollama_online": "connected ({host})",
  "term.ollama_offline": "offline ({host}) · start it with: sudo systemctl start ollama",
@@ -1137,18 +1144,12 @@
  "term.modo_fixo": "pinned",
  "term.parar": "ctrl+c to stop",
  "term.ate_logo": "See you.",
- "modo.lite.nome": "Lite",
- "modo.lite.desc": "Just the essentials: chat, talk and attach files. Everything else is automatic.",
  "modo.base.nome": "Base",
- "modo.base.desc": "Good for most people: history, memory, voice, routines and Probes.",
- "modo.pro.nome": "Pro",
- "modo.pro.desc": "Everything in Base, plus advanced settings and diagnostics.",
- "cfg.modo": "Mode",
- "cfg.modo_sub": "How much of the window you want to see. Switch any time; nothing is deleted.",
+ "modo.base.desc": "Everything for every day: history, memory, voice, routines, Probes and cloud.",
  "cfg.nav.avancado": "Advanced settings",
  "cfg.nav.diagnostico": "Diagnostics",
  "cfg.avancado.titulo": "Advanced settings",
- "cfg.avancado.sub": "Only used in Pro mode. Changing these can make the AI worse: Gargantua was trained with the defaults.",
+ "cfg.avancado.sub": "Only used with dev mode on. Changing these can make the AI worse: Gargantua was trained with the defaults.",
  "cfg.av.automatico": "Automatic",
  "cfg.av.temperatura": "Temperature",
  "cfg.av.temperatura_sub": "How much the answer varies. Lower is more predictable (the default is 0.1).",
@@ -1159,9 +1160,14 @@
  "cfg.av.ferramentas": "Tools",
  "cfg.av.ferramentas_sub": "Untick what the AI cannot use. It still sees the tool, but openTARS refuses to run it.",
  "cfg.av.salvar": "Save",
+ "cfg.av.motor": "AI engine",
+ "cfg.av.motor_sub": "llama.cpp is the default. Switch to Ollama if you prefer to keep using it. Takes effect the next time openTARS starts.",
+ "cfg.av.motor_llamacpp": "llama.cpp (default)",
+ "cfg.av.motor_ollama": "Ollama",
+ "cfg.av.motor_reiniciar": "Saved. Restart openTARS to switch the engine.",
  "cfg.av.salvo": "Saved.",
  "cfg.av.restaurar": "Back to defaults",
- "cfg.av.so_pro": "You are in {modo} mode: these settings are kept, but only used in Pro.",
+ "cfg.av.so_pro": "Dev mode is off: these settings are kept, but only used when it is on (Settings > General).",
  "cfg.diag.titulo": "Diagnostics",
  "cfg.diag.sub": "What openTARS did and whether the system is in order. Nothing here leaves your computer.",
  "cfg.diag.log": "Tools used",
@@ -1172,11 +1178,8 @@
  "cfg.diag.ambiente_sub": "Ollama, models, screen, microphone and permissions, the same as the opentars --diagnostico command.",
  "cfg.diag.conferir": "Check now",
  "cfg.diag.conferindo": "Checking…",
- "pu.passo.modo": "Mode",
- "pu.modo.titulo": "How much do you want to see?",
- "pu.modo.texto": "Choose the window mode. You can change it later in Settings > General.",
  "pu.garg.nome_lite": "Gargantua Lite",
- "pu.garg.lite_nota": "This computer has no graphics card with 4 GB and little memory: we download Gargantua Lite (0.6 GB, with vision), which is lighter and makes a few more mistakes. It looks at the screen to find buttons, with less precision than Gargantua 2 (1.6 GB).",
+ "pu.garg.lite_nota": "This computer has no graphics card with 4 GB and little memory: we download Gargantua 2.5 Lite (4.4 GB, with vision and audio), which is lighter. It reads the screen but does not point to small buttons by position; clicking by name works through the app's accessibility.",
  "cmd.sempre": [
   "always",
   "a"
@@ -1214,7 +1217,7 @@
  "probes.titulo": "Probes",
  "probes.sub": "Small watchers that run in the background, even with the window closed, and tell you when something matters. They only look: nothing on your computer changes unless you choose it.",
  "probes.servico": "On and off",
- "probes.baixar_lite": "Download Gargantua Lite (0.6 GB, with vision)",
+ "probes.baixar_lite": "Download Gargantua 2.5 Lite (4.4 GB, with vision and audio)",
  "probes.parar_tudo": "Stop all",
  "probes.nova": "Create a Probe",
  "probes.nova_sub": "Three steps: pick what to watch, fill in what it asks and check the sentence of what it will do.",
@@ -1422,16 +1425,15 @@
  "probes.pp.missao": "Tells you when {quando}.",
  "avisos.dica_sino": "Probe alerts: {n} new",
  "pu.ollama_antigo": "This model needs a newer Ollama. Update it with: curl -fsSL https://ollama.com/install.sh | sh (and try again).",
- "cooper.descontinuado": "Cooper was discontinued: Gargantua 2 already sees the screen. To install it: {comando}",
- "cfg.gargantua_novo": "You have Gargantua 1 or the Lite. Gargantua 2 is openTARS's main AI: 1.6 GB, more accurate, and it sees the screen more precisely (Gargantua 1 cannot see). Worth downloading.",
- "cfg.baixar_gargantua2": "Download Gargantua 2",
+ "cfg.gargantua_novo": "You have Gargantua 1 or an older model. Gargantua 2.5 is openTARS's main AI, on Gemma 4: 6.3 GB, with vision and audio support. Worth downloading.",
+ "cfg.baixar_gargantua2": "Download Gargantua 2.5",
  "msg.busca_nao_lida": "The search was opened in the browser, but the AI did not read the page: what it answered above comes from its own memory and may be out of date. Check the results in the browser.",
  "msg.pouca_confianca": "I am not sure about this answer: it came from the model's memory and may be wrong or made up. Check a source before relying on it.",
  "msg.verificando_fato": "Low confidence in the answer above: checking it with a web search.",
  "msg.busca_nada_aberto": "Nothing was opened on your computer: the answer came from SearXNG. If it says it opened something in the browser, that did not happen.",
  "visao.ok": "{modelo} (looks at the screen: finds buttons and describes windows)",
- "visao.nao_instalado": "not installed. To let openTARS see the screen, download Gargantua 2: {comando}",
- "visao.desligado": "{modelo} is installed but turned off (TARS_COOPER=0).",
+ "visao.nao_instalado": "not installed. To let openTARS see the screen, download Gargantua 2.5: {comando}",
+ "visao.desligado": "{modelo} is installed but turned off (TARS_VISAO=0).",
  "visao.sem_resposta": "The model that looks at the screen did not answer ({motivo}).",
  "cfg.nav.modelos": "More models",
  "cfg.modelos.titulo": "More models",
@@ -1440,9 +1442,9 @@
  "modelinhos.baixando": "Downloading the photo models (~300 MB): remove the background, upscale, select by clicking and remove an object.",
  "modelinhos.pronto": "The photo models are ready.",
  "modelinhos.erro": "I couldn't download the photo models ({erro}). I'll try again next time openTARS opens.",
- "lite.baixando": "Downloading Gargantua 2 Lite (0.6 GB), the AI that runs in the background for the assistant, text actions and Probes.",
- "lite.pronto": "Gargantua 2 Lite is ready.",
- "lite.erro": "I couldn't download Gargantua 2 Lite ({erro}). I'll try again next time openTARS opens.",
+ "lite.baixando": "Downloading Gargantua 2.5 Lite (4.4 GB), the AI that runs in the background for the assistant, text actions and Probes.",
+ "lite.pronto": "Gargantua 2.5 Lite is ready.",
+ "lite.erro": "I couldn't download Gargantua 2.5 Lite ({erro}). I'll try again next time openTARS opens.",
  "cfg.bonsai.sub": "Makes images from a sentence (\"draw a lighthouse at dusk\"). By PrismML, Apache 2.0. Optional: {tamanho} and an NVIDIA card with 6 GB (or a Mac with Apple Silicon). Works offline once installed.",
  "cfg.bonsai.instalar": "Install ({tamanho})",
  "cfg.bonsai.remover": "Remove",
@@ -1523,6 +1525,11 @@
  "acoes.resultado.resumir": "Summary",
  "acoes.resultado.traduzir": "Translation",
  "acoes.resultado.perguntar": "Answer",
+ "acoes.aba.responder": "Reply",
+ "acoes.opcao.curto": "Shorter",
+ "acoes.opcao.lista": "Bullet list",
+ "acoes.resultado.responder": "Draft reply",
+ "acoes.responder_dica": "What do you want to say? (e.g. I can make it tomorrow)",
  "acoes.pergunta_dica": "Ask something about the selection",
  "acoes.enviar_pergunta": "Send question",
  "acoes.substituir": "Replace in the text",
@@ -1533,6 +1540,7 @@
  "acoes.atalho_linux": "Ctrl+Alt+R",
  "acoes.atalho_windows": "Ctrl+Alt+R",
  "acoes.atalho_macos": "Ctrl+Option+R",
+ "acoes.da_janela": "Text read from the window: {janela}",
  "acoes.trecho": "Selected text: \"{trecho}\"",
  "acoes.cortado": "(only the first {n} characters are used)",
  "acoes.sem_texto": "No text selected. Select something in any app and press the shortcut again.",
@@ -1557,6 +1565,34 @@
  "cfg.assist.sistema_titulo": "Start with the system",
  "cfg.assist.sistema": "Open openTARS hidden when I log in",
  "cfg.assist.sistema_nota": "On by default: the shortcut answers right away from the start of the day and the icon stays near the clock. Untick it to keep openTARS from starting with the system.",
+ "cfg.assist.agenda_titulo": "Calendar",
+ "cfg.assist.agenda_sub": "Ask \"what do I have tomorrow?\". Point to a .ics file or a calendar link (Google, Outlook and Apple can export one). Read only; off until you set it.",
+ "cfg.assist.agenda_dica": "/path/to/calendar.ics or https://… (separate several with ;)",
+ "cfg.assist.agenda_ligada": "On: reading {n} calendar(s). openTARS never changes your calendar.",
+ "cfg.assist.agenda_nao_achei": "I can't find {fonte}: use a file that exists or a link that starts with https://",
+ "cfg.assist.desligada": "Off.",
+ "cfg.assist.notas_titulo": "Notes",
+ "cfg.assist.notas_sub": "Say \"create a note: …\" or \"my notes about …\". Notes are Markdown files in the folder you choose; off until you set it.",
+ "cfg.assist.notas_dica": "/path/to/Notes (Obsidian and Joplin folders work)",
+ "cfg.assist.notas_ligada": "On: notes are saved and searched in this folder. A note is never written over another one.",
+ "cfg.assist.salvar": "Save",
+ "cfg.assist.email_titulo": "Email",
+ "cfg.assist.email_sub": "Ask \"what email came in today?\", \"read the last email from Ana\" or \"send an email to ana@example.com saying…\". Reading never marks anything as read; sending always asks you first. Off until you set it.",
+ "cfg.assist.email_usuario": "Email address",
+ "cfg.assist.email_senha": "Password (Gmail and Outlook need an app password)",
+ "cfg.assist.email_senha_guardada": "Password saved in the system keychain (type a new one to change it)",
+ "cfg.assist.email_imap": "Incoming server (IMAP), blank for Gmail, Outlook, iCloud, Yahoo",
+ "cfg.assist.email_smtp": "Outgoing server (SMTP), blank for the same providers",
+ "cfg.assist.email_ligado": "On: {usuario}. The password stays in the system keychain, never in a file.",
+ "cfg.assist.email_servidores": "I don't know this provider: fill in the IMAP and SMTP servers.",
+ "cfg.assist.email_sem_senha": "Type the password.",
+ "cfg.assist.email_sem_cofre": "This computer has no password keychain for openTARS (install the keyring package). I did not save anything.",
+ "cfg.assist.email_testar": "Test",
+ "cfg.assist.email_desligar": "Turn off and forget",
+ "cfg.assist.email_testando": "Testing…",
+ "cfg.assist.email_ok": "Connected. Nothing was changed in your mailbox.",
+ "cfg.assist.email_erro": "It didn't work: {erro}",
+ "cfg.assist.email_salvar_antes": "Save the account first.",
  "cfg.assist.acoes_titulo": "Text actions",
  "cfg.assist.acoes_sub": "Rewrite, summarize, translate and ask about the selection. The selected text is only material: nothing written in it is run, and nothing leaves your computer.",
  "cfg.assist.acoes_modelo": "Text actions model: {modelo}.",
@@ -1653,6 +1689,12 @@
  "ctx.nota": "I only look at the name of the app in use and the window title. Nothing is recorded or sent. Turn it off in Settings > Assistant.",
  "ctx.selecione": "Select the text you want to check and click Check again (or use the text actions shortcut).",
  "cfg.assist.ctx_titulo": "Suggestions based on the app in use",
+ "cfg.assist.indice_titulo": "File search",
+ "cfg.assist.indice": "Index my files so search is instant (off by default)",
+ "cfg.assist.indice_nota": "The index keeps file names and the start of each text on this computer only, never sends them anywhere, and is erased when you turn this off.",
+ "cfg.assist.indice_montando": "Building the index in the background…",
+ "cfg.assist.indice_pronto": "Index ready: {n} files.",
+ "cfg.assist.indice_erro": "The index failed: {erro}",
  "cfg.assist.ctx": "Suggest help based on the app in use (for example, checking an email)",
  "ctx.nota_config": "On by default. Every 4 seconds openTARS looks only at the name of the app and the title of the window in use, records and sends nothing, and suggests once per window.",
  "arq.acao.foto": "Edit the photo",
@@ -1695,5 +1737,84 @@
  "foto.salvar": "Save a copy: {nome}",
  "foto.salvar_n": "Save {n} copies",
  "foto.aviso": "Always a copy in the same folder: the original stays as it is. The copy leaves out the location and device data. Cropping, rotating and brightening are instant; removing the background, upscaling and removing an object use small models on this computer and take a few seconds.",
- "foto.salvas": "Copy saved: {nomes}."
+ "foto.salvas": "Copy saved: {nomes}.",
+ "cfg.dev": "Dev mode",
+ "cfg.dev_sub": "For people who want to adjust what is automatic.",
+ "cfg.dev_ligar": "Show advanced settings and diagnostics",
+ "modo.dev.nome": "Dev",
+ "modo.dev.desc": "Everything in Base, plus advanced settings and diagnostics.",
+ "motor.preparando": "Setting up the new engine (llama.cpp) in the background. You can keep using openTARS.",
+ "motor.pronto": "New engine ready: openTARS now runs on llama.cpp.",
+ "motor.erro": "Couldn't set up the new engine ({erro}). openTARS keeps running on Ollama.",
+ "cfg.modelos.busca_ph": "Search models (name, vision, tools...)",
+ "cfg.modelos.busca_web": "Search the Ollama library",
+ "cfg.modelos.buscando": "Searching the Ollama library...",
+ "cfg.modelos.busca_nada": "Nothing found in the Ollama library for this search.",
+ "cfg.modelos.busca_erro": "Could not reach the Ollama library. Check your connection and try again.",
+ "cfg.modelos.g.web": "From the Ollama library",
+ "cfg.modelos.g.web_sub": "Results from ollama.com. The size shows when you click: it is checked before the download starts.",
+ "cfg.modelos.calculando": "Checking the download size...",
+ "cfg.assist.reabrir_titulo": "Apps that hide their buttons",
+ "cfg.assist.reabrir": "Let openTARS reopen an app so it can click its buttons",
+ "cfg.assist.reabrir_nota": "Chrome-based apps that were already open (Claude, Discord, VS Code, Slack, Chrome) hide their buttons from other programs. With this on, when openTARS needs to click in one of them, it closes the app and opens it again with accessibility on. Unsaved work in that app can be lost, and it never force-quits: if the app refuses to close, it stays open. Off by default.",
+ "vm.cli.uso": "Usage: opentars --missao-vm \"what the agent should do inside the virtual machine\"",
+ "vm.cli.falta": "The virtual machine is not ready: missing {falta}.",
+ "vm.cli.sem_base": "The virtual machine image is not built yet.",
+ "vm.cli.sem_pro": "This needs the Gargantua Pro model ({modelo}). Add it in Settings > More models.",
+ "vm.cli.comecando": "Starting in a disposable virtual machine: {pedido}",
+ "vm.cli.resultado": "Finished ({motivo}, {segundos} s): {resultado}",
+ "vm.cli.acesso": "  site visited: {acesso}",
+ "vm.cli.arquivos": "The agent left {n} file(s) in the output folder: {lista}",
+ "vm.cli.liberar": "Copy them to {pasta}? [y/N] ",
+ "vm.cli.descartados": "Not copied. They were deleted with the virtual machine.",
+ "vm.secao": "Missions in a virtual machine",
+ "vm.secao_sub": "Gargantua Pro works on an isolated, disposable computer: it opens programs, browses and types. Nothing on your PC is visible inside, and whatever it makes only reaches you if you approve it.",
+ "vm.abrir": "Open the VM window",
+ "vm.so_linux": "For now, VM missions work only on Linux with KVM.",
+ "vm.janela.titulo": "Mission in a virtual machine",
+ "vm.janela.sub": "Write what the agent should do. It uses the mouse and keyboard of a disposable VM; when it finishes, the VM is deleted.",
+ "vm.janela.falta": "The virtual machine is not ready: missing {falta}.",
+ "vm.janela.sem_base": "The VM image does not exist yet. Building it takes about 5 minutes and uses about 1.6 GB.",
+ "vm.janela.sem_pro": "VM missions use Gargantua Pro (about 7.6 GB).",
+ "vm.janela.conferindo": "Checking the model...",
+ "vm.janela.montar": "Build the image",
+ "vm.janela.montando": "Building the VM image...",
+ "vm.janela.montando_pct": "Downloading the VM system: {pct}%",
+ "vm.janela.baixar_pro": "Download Gargantua Pro",
+ "vm.janela.baixando": "Downloading Gargantua Pro...",
+ "vm.janela.erro": "That did not work: {erro}",
+ "vm.janela.pedido_ph": "E.g.: open the terminal and create notes.txt in the output folder with the shopping list",
+ "vm.janela.comecar": "Start",
+ "vm.janela.parar": "Stop",
+ "vm.janela.internet": "Internet (every site is logged)",
+ "vm.janela.sem_tela": "The VM screen shows up here.",
+ "vm.janela.tela": "Virtual machine screen",
+ "vm.janela.passos": "Steps",
+ "vm.janela.sites": "Sites visited",
+ "vm.janela.ligando": "Starting the VM...",
+ "vm.janela.trabalhando": "The agent is working.",
+ "vm.janela.parando": "Stopping...",
+ "vm.janela.fim": "Finished ({motivo}, {segundos} s): {resultado}",
+ "vm.janela.arquivos": "The agent left {n} file(s) in the output folder. Check what should come to your PC:",
+ "vm.janela.trazer": "Bring to {pasta}",
+ "vm.janela.descartar": "Discard all",
+ "vm.janela.trazidos": "{n} file(s) copied to {pasta}. The rest was deleted.",
+ "vm.janela.descartados": "Nothing was copied. The files were deleted with the VM.",
+ "vm.motivo.terminou": "done",
+ "vm.motivo.cancelada": "stopped by you",
+ "vm.motivo.tempo": "time ran out",
+ "vm.motivo.passos": "step limit",
+ "vm.passo.clicar": "clicked at {detalhe}",
+ "vm.passo.duplo": "double-clicked at {detalhe}",
+ "vm.passo.direito": "right-clicked at {detalhe}",
+ "vm.passo.atalho": "pressed {detalhe}",
+ "vm.passo.digitou": "typed text",
+ "vm.passo.rolou": "scrolled",
+ "vm.passo.esperou": "waited",
+ "cli.barra_dica": "/help · ctrl+c stops",
+ "jp.atualizando_script": "Updating with the installer... openTARS reopens on its own when it is done.",
+ "jp.erro_script": "The update did not finish. The log is in {arquivo}.",
+ "setup.motor_llamacpp": "Engine: llama.cpp. openTARS downloads the engine and Gargantua 2.5 the first time it opens, with a progress bar and no password.",
+ "g25.oferta": "Gargantua 2.5 is here, the new openTARS AI: it sees your screen and understands your voice.",
+ "g25.ver": "Get Gargantua 2.5"
 }

app/idiomas/pt_BR.json

@@ -504,7 +504,7 @@
  "term.modo_auto_explica": "o openTARS escolhe sozinho a IA mais adequada pra cada tarefa.",
  "term.voce": "Você",
  "term.conversa_carregada": "conversa anterior: {n} pedido(s) · /limpar começa do zero",
- "term.ajuda": "openTARS {versao} · assistente de IA local para Linux\n\nConversa\n  opentars                        abre a conversa no terminal (continua a última)\n  opentars --new                  começa uma conversa nova\n  opentars --resume               escolhe uma conversa salva para continuar\n  opentars --plan                 modo plano: a IA só descreve o que faria\n  opentars --auto                 edições nesta pasta sem perguntar (apagar, enviar e instalar ainda perguntam)\n  opentars --chat \"pedido\"        responde um pedido e sai\n  opentars -p \"pedido\"            para scripts: só a resposta (ou --output-format json); lê o stdin\n  opentars-gui                    abre a janela\n  opentars-gui --rapido           abre a barra rápida (ctrl+alt+espaço)\n\nModelos\n  opentars --model <nome>         usa este modelo no -p\n  opentars --explicar \"pedido\"    mostra como a tarefa e o modelo são escolhidos\n  opentars --avaliar-classificador  mede o acerto da Murph e do modo automático\n\nAmbiente\n  opentars --diagnostico          confere Ollama, tela e acessibilidade (não muda nada)\n  opentars --autoteste            diagnóstico + um teste real com a calculadora\n  opentars --setup                instala o que estiver faltando (Ollama, modelos...)\n\nPreferências\n  opentars --idioma <código>      troca o idioma (pt_BR ou en)\n  opentars --atalho [teclas|off]  mostra, troca ou remove o atalho global\n  opentars --version              mostra a versão\n\nDentro da conversa, /ajuda lista os comandos. Um AGENTS.md na pasta entra em toda conversa.",
+ "term.ajuda": "openTARS {versao} · assistente de IA local\n\nConversa\n  opentars                        abre a conversa no terminal (continua a última)\n  opentars --new                  começa uma conversa nova\n  opentars --resume               escolhe uma conversa salva para continuar\n  opentars --plan                 modo plano: a IA só descreve o que faria\n  opentars --auto                 edições nesta pasta sem perguntar (apagar, enviar e instalar ainda perguntam)\n  opentars --chat \"pedido\"        responde um pedido e sai\n  opentars -p \"pedido\"            para scripts: só a resposta (ou --output-format json); lê o stdin\n  opentars-gui                    abre a janela\n  opentars-gui --rapido           abre a barra rápida (ctrl+alt+espaço)\n\nModelos\n  opentars --model <nome>         usa este modelo no -p\n  opentars --explicar \"pedido\"    mostra como a tarefa e o modelo são escolhidos\n  opentars --avaliar-classificador  mede o acerto da Murph e do modo automático\n\nAmbiente\n  opentars --diagnostico          confere o motor, a tela e a acessibilidade (não muda nada)\n  opentars --autoteste            diagnóstico + um teste real com a calculadora\n  opentars --setup                instala o que estiver faltando (motor, modelos...)\n  opentars --missao-vm \"tarefa\"    roda uma missão de agente numa máquina virtual descartável (precisa do modelo Pro)\n\nPreferências\n  opentars --idioma <código>      troca o idioma (pt_BR ou en)\n  opentars --atalho [teclas|off]  mostra, troca ou remove o atalho global\n  opentars --version              mostra a versão\n\nDentro da conversa, /ajuda lista os comandos. Um AGENTS.md na pasta entra em toda conversa.",
  "idioma.lista_titulo": "Idiomas disponíveis:",
  "idioma.como_trocar": "Troque com: /idioma <código>  (ex: /idioma en)",
  "idioma.trocado": "Idioma: {nome}",
@@ -755,8 +755,8 @@
  "gargantua.desligado": "{modelo} instalado, mas TARS_SEM_GARGANTUA=1: o AUTO não dá preferência pra ele",
  "gargantua.nao_instalado": "Gargantua não instalado. Pra baixar a IA oficial do openTARS: ollama pull {modelo}",
  "setup.gargantua_ja": "Gargantua, a IA oficial do openTARS, já está instalado ({modelo}).",
- "setup.gargantua_baixando": "Baixando o Gargantua, a IA oficial do openTARS ({modelo}, ~1,6 GB)...",
- "setup.gargantua_segundo_plano": "Sem terminal aqui para mostrar o andamento (instalação pela loja de aplicativos ou automática): o download do Gargantua (~1,6 GB) continua em segundo plano. O openTARS mostra o progresso quando você abrir.",
+ "setup.gargantua_baixando": "Baixando o Gargantua, a IA oficial do openTARS ({modelo}, ~6,4 GB)...",
+ "setup.gargantua_segundo_plano": "Sem terminal aqui para mostrar o andamento (instalação pela loja de aplicativos ou automática): o download do Gargantua (~6,4 GB) continua em segundo plano. O openTARS mostra o progresso quando você abrir.",
  "setup.gargantua_pulado": "TARS_SEM_GARGANTUA=1: o Gargantua não foi baixado.",
  "msg.folego": "tarefa longa: {etapas} etapas, {acoes} ações feitas; continuando",
  "versao.nova": "Saiu o openTARS {versao}! Pra atualizar, rode de novo o comando de instalação (está no README do GitHub).",
@@ -785,7 +785,7 @@
  "pu.slogan": "Seu assistente que mexe no computador, sem sair dele.",
  "pu.passo": "Passo {n} de {total}",
  "pu.passo.idioma": "Idioma",
- "pu.passo.ollama": "Ollama",
+ "pu.passo.ollama": "Motor de IA",
  "pu.passo.nuvem": "Nuvem (opcional)",
  "pu.passo.gargantua": "Baixar os modelos",
  "pu.passo.teste": "Teste rápido",
@@ -794,16 +794,16 @@
  "pu.pausar": "Pausar",
  "pu.retomar": "Retomar",
  "pu.tentar_de_novo": "Tentar de novo",
- "pu.ollama.titulo": "Procurando o Ollama",
- "pu.ollama.texto": "O Ollama é o programa que roda o modelo de IA no seu computador. O TARS precisa dele para funcionar.",
- "pu.ollama.procurando": "Procurando o Ollama neste computador…",
- "pu.ollama.ok": "Ollama encontrado neste computador (versão {versao})",
+ "pu.ollama.titulo": "Preparando o motor de IA",
+ "pu.ollama.texto": "O motor roda o modelo de IA no seu computador. O openTARS usa o llama.cpp; se você já tem o Ollama, ele também serve.",
+ "pu.ollama.procurando": "Procurando um motor de IA neste computador…",
+ "pu.ollama.ok": "Motor de IA pronto ({versao})",
  "pu.ollama.parado": "O Ollama está instalado, mas parado.",
- "pu.ollama.faltando": "O Ollama ainda não está instalado.",
- "pu.ollama.instalar": "Instalar o Ollama",
+ "pu.ollama.faltando": "Falta o motor de IA. São uns 35 MB, sem pedir senha.",
+ "pu.ollama.instalar": "Instalar o motor",
  "pu.ollama.iniciar": "Iniciar o Ollama",
  "pu.ollama.procurar_de_novo": "Procurar de novo",
- "pu.ollama.instalando": "Instalando o Ollama. Uma janela do sistema pode pedir a sua senha.",
+ "pu.ollama.instalando": "Baixando o motor (llama.cpp)…",
  "pu.ollama.iniciando": "Iniciando o Ollama…",
  "pu.ollama.erro_instalar": "Não consegui instalar: {motivo}",
  "pu.ollama.abri_download": "Abri a página de download do Ollama no navegador. Instale, abra o Ollama e clique em Procurar de novo.",
@@ -1051,6 +1051,7 @@
  "cfg.voz.instalada": "Voz instalada.",
  "cfg.voz.erro": "Não deu pra instalar: {erro}",
  "cfg.voz.fala": "Fala",
+ "cfg.voz.resposta_completa": "Ler as respostas longas inteiras (por padrão só as primeiras frases são faladas; o resto fica na tela)",
  "cfg.voz.responder_falando": "Responder falando",
  "cfg.voz.voz": "Voz",
  "cfg.voz.velocidade": "Velocidade",
@@ -1194,9 +1195,15 @@
  "mascote.dica8": "Tudo roda no seu computador: nada do que você escreve sai daqui, a menos que você ligue a nuvem.",
  "mascote.dica9": "Em Configurações dá pra criar rotinas: o TARS faz uma tarefa sozinho no horário que você escolher.",
  "mascote.dica10": "Escreva /modelo auto pro TARS escolher o melhor modelo pra cada pedido.",
- "term.slogan": "assistente de IA local para Linux",
+ "term.slogan": "assistente de IA local",
  "term.bem_vindo": "Bem-vindo ao openTARS!",
  "term.rotulo_ollama": "ollama:",
+ "term.rotulo_motor": "motor:",
+ "term.rotulo_pasta": "pasta:",
+ "term.motor_offline": "fora do ar ({host}) · reinicie o openTARS para ligar o motor",
+ "cli.regua.perguntar": "perguntar",
+ "cli.regua.plano": "plano",
+ "cli.regua.automatico": "automático",
  "term.rotulo_modelo": "modelo:",
  "term.ollama_online": "conectado ({host})",
  "term.ollama_offline": "desligado ({host}) · inicie com: sudo systemctl start ollama",
@@ -1205,18 +1212,12 @@
  "term.modo_fixo": "fixo",
  "term.parar": "ctrl+c para parar",
  "term.ate_logo": "Até mais.",
- "modo.lite.nome": "Lite",
- "modo.lite.desc": "Só o essencial: conversar, falar e anexar. Tudo fica no automático.",
  "modo.base.nome": "Base",
- "modo.base.desc": "Bom para a maioria: histórico, memória, voz, rotinas e Probes.",
- "modo.pro.nome": "Pro",
- "modo.pro.desc": "Tudo do Base, mais ajustes avançados e diagnóstico.",
- "cfg.modo": "Modo",
- "cfg.modo_sub": "Quanto da janela você quer ver. Dá para trocar a qualquer hora; nada é apagado.",
+ "modo.base.desc": "Tudo para o dia a dia: histórico, memória, voz, rotinas, Probes e nuvem.",
  "cfg.nav.avancado": "Ajustes avançados",
  "cfg.nav.diagnostico": "Diagnóstico",
  "cfg.avancado.titulo": "Ajustes avançados",
- "cfg.avancado.sub": "Só valem no modo Pro. Mudar estes valores pode deixar a IA pior: o Gargantua foi treinado com os padrões.",
+ "cfg.avancado.sub": "Só valem com o modo dev ligado. Mudar estes valores pode deixar a IA pior: o Gargantua foi treinado com os padrões.",
  "cfg.av.automatico": "Automático",
  "cfg.av.temperatura": "Temperatura",
  "cfg.av.temperatura_sub": "Quanto a resposta varia. Mais baixa é mais previsível (o padrão é 0,1).",
@@ -1227,9 +1228,14 @@
  "cfg.av.ferramentas": "Ferramentas",
  "cfg.av.ferramentas_sub": "Desmarque o que a IA não pode usar. Ela ainda vê a ferramenta, mas o openTARS recusa.",
  "cfg.av.salvar": "Salvar",
+ "cfg.av.motor": "Motor de IA",
+ "cfg.av.motor_sub": "O llama.cpp é o padrão. Troque para o Ollama se preferir continuar com ele. Vale na próxima vez que o openTARS abrir.",
+ "cfg.av.motor_llamacpp": "llama.cpp (padrão)",
+ "cfg.av.motor_ollama": "Ollama",
+ "cfg.av.motor_reiniciar": "Salvo. Reinicie o openTARS para trocar o motor.",
  "cfg.av.salvo": "Salvo.",
  "cfg.av.restaurar": "Voltar aos padrões",
- "cfg.av.so_pro": "Você está no modo {modo}: estes ajustes ficam guardados, mas só valem no Pro.",
+ "cfg.av.so_pro": "O modo dev está desligado: estes ajustes ficam guardados, mas só valem com ele ligado (Configurações > Geral).",
  "cfg.diag.titulo": "Diagnóstico",
  "cfg.diag.sub": "O que o openTARS fez e se o ambiente está em ordem. Nada daqui sai do seu computador.",
  "cfg.diag.log": "Ferramentas usadas",
@@ -1240,11 +1246,8 @@
  "cfg.diag.ambiente_sub": "Ollama, modelos, tela, microfone e permissões, o mesmo do comando opentars --diagnostico.",
  "cfg.diag.conferir": "Conferir agora",
  "cfg.diag.conferindo": "Conferindo…",
- "pu.passo.modo": "Modo",
- "pu.modo.titulo": "Quanto você quer ver?",
- "pu.modo.texto": "Escolha o modo da janela. Dá para trocar depois, em Configurações > Geral.",
  "pu.garg.nome_lite": "Gargantua Lite",
- "pu.garg.lite_nota": "Este computador não tem placa de vídeo com 4 GB e tem pouca memória: baixamos o Gargantua Lite (0,6 GB, com visão), que é mais leve e erra um pouco mais. Ele olha a tela para achar botões, só que com menos precisão que o Gargantua 2 (1,6 GB).",
+ "pu.garg.lite_nota": "Este computador não tem placa de vídeo com 4 GB e tem pouca memória: baixamos o Gargantua 2.5 Lite (4,4 GB, com visão e áudio), que é mais leve. Ele lê a tela, mas não aponta botões pequenos pela posição; o clique pelo nome funciona pela acessibilidade do app.",
  "cmd.sempre": [
   "sempre",
   "a"
@@ -1282,7 +1285,7 @@
  "probes.titulo": "Probes",
  "probes.sub": "Pequenos vigias que rodam em segundo plano, mesmo com a janela fechada, e avisam quando algo importa. Eles só olham: nada muda no seu computador sem você escolher.",
  "probes.servico": "Ligar e desligar",
- "probes.baixar_lite": "Baixar o Gargantua Lite (0,6 GB, com visão)",
+ "probes.baixar_lite": "Baixar o Gargantua 2.5 Lite (4,4 GB, com visão e áudio)",
  "probes.parar_tudo": "Parar tudo",
  "probes.nova": "Criar um Probe",
  "probes.nova_sub": "Três passos: escolha o que vigiar, preencha o que pedir e confira a frase do que ele vai fazer.",
@@ -1490,16 +1493,15 @@
  "probes.pp.missao": "Avisa quando {quando}.",
  "avisos.dica_sino": "Avisos dos Probes: {n} novo(s)",
  "pu.ollama_antigo": "Este modelo pede um Ollama mais novo. Atualize com: curl -fsSL https://ollama.com/install.sh | sh (e tente de novo).",
- "cooper.descontinuado": "O Cooper foi descontinuado: o Gargantua 2 já enxerga a tela. Para instalar: {comando}",
- "cfg.gargantua_novo": "Você tem o Gargantua 1 ou o Lite. O Gargantua 2 é a IA principal do openTARS: 1,6 GB, acerta mais e enxerga a tela com mais precisão (o Gargantua 1 não enxerga). Vale baixar.",
- "cfg.baixar_gargantua2": "Baixar o Gargantua 2",
+ "cfg.gargantua_novo": "Você tem o Gargantua 1 ou um modelo mais antigo. O Gargantua 2.5 é a IA principal do openTARS, em Gemma 4: 6,3 GB, com visão e suporte a áudio. Vale baixar.",
+ "cfg.baixar_gargantua2": "Baixar o Gargantua 2.5",
  "msg.busca_nao_lida": "A busca foi aberta no navegador, mas a IA não leu a página: o que ela respondeu acima vem da memória dela e pode estar desatualizado. Confira os resultados no navegador.",
  "msg.pouca_confianca": "Não tenho certeza dessa resposta: ela veio da memória do modelo e pode estar errada ou inventada. Confira numa fonte antes de usar.",
  "msg.verificando_fato": "Pouca confiança na resposta acima: vou conferir pela busca na web.",
  "msg.busca_nada_aberto": "Nada foi aberto no seu computador: a resposta veio do SearXNG. Se ela diz que abriu algo no navegador, isso não aconteceu.",
  "visao.ok": "{modelo} (olha a tela: acha botões e descreve janelas)",
- "visao.nao_instalado": "não instalado. Para o openTARS enxergar a tela, baixe o Gargantua 2: {comando}",
- "visao.desligado": "{modelo} está instalado, mas desligado (TARS_COOPER=0).",
+ "visao.nao_instalado": "não instalado. Para o openTARS enxergar a tela, baixe o Gargantua 2.5: {comando}",
+ "visao.desligado": "{modelo} está instalado, mas desligado (TARS_VISAO=0).",
  "visao.sem_resposta": "O modelo que olha a tela não respondeu ({motivo}).",
  "cfg.nav.modelos": "Mais modelos",
  "cfg.modelos.titulo": "Mais modelos",
@@ -1508,9 +1510,9 @@
  "modelinhos.baixando": "Baixando os modelinhos de foto (~300 MB): tirar o fundo, aumentar a resolução, selecionar por clique e remover um objeto.",
  "modelinhos.pronto": "Os modelinhos de foto estão prontos.",
  "modelinhos.erro": "Não consegui baixar os modelinhos de foto ({erro}). Tento de novo na próxima abertura.",
- "lite.baixando": "Baixando o Gargantua 2 Lite (0,6 GB), a IA que fica em segundo plano para o assistente, as ações de texto e os Probes.",
- "lite.pronto": "O Gargantua 2 Lite está pronto.",
- "lite.erro": "Não consegui baixar o Gargantua 2 Lite ({erro}). Tento de novo na próxima abertura.",
+ "lite.baixando": "Baixando o Gargantua 2.5 Lite (4,4 GB), a IA que fica em segundo plano para o assistente, as ações de texto e os Probes.",
+ "lite.pronto": "O Gargantua 2.5 Lite está pronto.",
+ "lite.erro": "Não consegui baixar o Gargantua 2.5 Lite ({erro}). Tento de novo na próxima abertura.",
  "cfg.bonsai.sub": "Gera imagens a partir de uma frase (\"desenhe um farol ao entardecer\"). Da PrismML, Apache 2.0. Opcional: {tamanho} e uma placa NVIDIA com 6 GB (ou um Mac com Apple Silicon). Roda sem internet depois de instalado.",
  "cfg.bonsai.instalar": "Instalar ({tamanho})",
  "cfg.bonsai.remover": "Remover",
@@ -1591,6 +1593,11 @@
  "acoes.resultado.resumir": "Resumo",
  "acoes.resultado.traduzir": "Tradução",
  "acoes.resultado.perguntar": "Resposta",
+ "acoes.aba.responder": "Responder",
+ "acoes.opcao.curto": "Mais curto",
+ "acoes.opcao.lista": "Em tópicos",
+ "acoes.resultado.responder": "Rascunho da resposta",
+ "acoes.responder_dica": "O que você quer dizer? (ex.: topo amanhã)",
  "acoes.pergunta_dica": "Pergunte algo sobre o trecho",
  "acoes.enviar_pergunta": "Enviar pergunta",
  "acoes.substituir": "Substituir no texto",
@@ -1601,6 +1608,7 @@
  "acoes.atalho_linux": "Ctrl+Alt+R",
  "acoes.atalho_windows": "Ctrl+Alt+R",
  "acoes.atalho_macos": "Ctrl+Option+R",
+ "acoes.da_janela": "Texto lido da janela: {janela}",
  "acoes.trecho": "Texto selecionado: \"{trecho}\"",
  "acoes.cortado": "(só os primeiros {n} caracteres entram)",
  "acoes.sem_texto": "Nenhum texto selecionado. Marque um trecho em qualquer programa e aperte o atalho de novo.",
@@ -1625,6 +1633,34 @@
  "cfg.assist.sistema_titulo": "Iniciar com o sistema",
  "cfg.assist.sistema": "Abrir o openTARS escondido quando eu entrar no computador",
  "cfg.assist.sistema_nota": "Ligado por padrão: o atalho responde na hora desde o começo do dia e o ícone fica perto do relógio. Desmarque para o openTARS não abrir com o sistema.",
+ "cfg.assist.agenda_titulo": "Agenda",
+ "cfg.assist.agenda_sub": "Pergunte \"o que tenho amanhã?\". Aponte um arquivo .ics ou o link de um calendário (Google, Outlook e Apple exportam). Só leitura; desligada até você configurar.",
+ "cfg.assist.agenda_dica": "/caminho/agenda.ics ou https://… (vários separados por ;)",
+ "cfg.assist.agenda_ligada": "Ligada: lendo {n} calendário(s). O openTARS nunca altera o seu calendário.",
+ "cfg.assist.agenda_nao_achei": "Não achei {fonte}: use um arquivo que existe ou um link que comece com https://",
+ "cfg.assist.desligada": "Desligada.",
+ "cfg.assist.notas_titulo": "Notas",
+ "cfg.assist.notas_sub": "Diga \"cria uma nota: …\" ou \"minhas notas sobre …\". As notas são arquivos Markdown na pasta que você escolher; desligadas até você configurar.",
+ "cfg.assist.notas_dica": "/caminho/Notas (pastas do Obsidian e do Joplin servem)",
+ "cfg.assist.notas_ligada": "Ligadas: as notas são salvas e procuradas nesta pasta. Uma nota nunca é escrita por cima de outra.",
+ "cfg.assist.salvar": "Salvar",
+ "cfg.assist.email_titulo": "E-mail",
+ "cfg.assist.email_sub": "Pergunte \"que e-mails chegaram hoje?\", \"lê o último e-mail da Ana\" ou \"envia um e-mail para ana@exemplo.com dizendo…\". Ler nunca marca nada como lido; enviar sempre pergunta antes. Desligado até você configurar.",
+ "cfg.assist.email_usuario": "Endereço de e-mail",
+ "cfg.assist.email_senha": "Senha (Gmail e Outlook pedem uma senha de app)",
+ "cfg.assist.email_senha_guardada": "Senha guardada no cofre do sistema (digite outra para trocar)",
+ "cfg.assist.email_imap": "Servidor de entrada (IMAP); vazio para Gmail, Outlook, iCloud e Yahoo",
+ "cfg.assist.email_smtp": "Servidor de saída (SMTP); vazio para os mesmos",
+ "cfg.assist.email_ligado": "Ligado: {usuario}. A senha fica no cofre do sistema, nunca em arquivo.",
+ "cfg.assist.email_servidores": "Não conheço este provedor: preencha os servidores IMAP e SMTP.",
+ "cfg.assist.email_sem_senha": "Digite a senha.",
+ "cfg.assist.email_sem_cofre": "Este computador não tem cofre de senhas para o openTARS (instale o pacote keyring). Não guardei nada.",
+ "cfg.assist.email_testar": "Testar",
+ "cfg.assist.email_desligar": "Desligar e esquecer",
+ "cfg.assist.email_testando": "Testando…",
+ "cfg.assist.email_ok": "Conectou. Nada foi alterado na sua caixa.",
+ "cfg.assist.email_erro": "Não deu: {erro}",
+ "cfg.assist.email_salvar_antes": "Salve a conta primeiro.",
  "cfg.assist.acoes_titulo": "Ações de texto",
  "cfg.assist.acoes_sub": "Reescrever, resumir, traduzir e perguntar sobre o trecho. O texto selecionado é só material: nada do que está escrito nele é executado, e nada sai do seu computador.",
  "cfg.assist.acoes_modelo": "Modelo das ações: {modelo}.",
@@ -1721,6 +1757,12 @@
  "ctx.nota": "Só olho o nome do programa em uso e o título da janela. Nada é gravado nem enviado. Desligue em Configurações > Assistente.",
  "ctx.selecione": "Selecione o texto que quer revisar e clique em Revisar de novo (ou use o atalho das ações de texto).",
  "cfg.assist.ctx_titulo": "Sugestões pelo programa em uso",
+ "cfg.assist.indice_titulo": "Busca de arquivos",
+ "cfg.assist.indice": "Indexar meus arquivos para a busca ser instantânea (desligado por padrão)",
+ "cfg.assist.indice_nota": "O índice guarda só neste computador os nomes dos arquivos e o começo de cada texto, nunca envia nada e é apagado quando você desliga.",
+ "cfg.assist.indice_montando": "Montando o índice em segundo plano…",
+ "cfg.assist.indice_pronto": "Índice pronto: {n} arquivos.",
+ "cfg.assist.indice_erro": "O índice falhou: {erro}",
  "cfg.assist.ctx": "Sugerir ajuda conforme o programa em uso (por exemplo, revisar um e-mail)",
  "ctx.nota_config": "Ligado por padrão. O openTARS olha a cada 4 segundos só o nome do programa e o título da janela em uso, sem gravar nem enviar nada, e sugere uma vez por janela.",
  "arq.acao.foto": "Editar a foto",
@@ -1763,5 +1805,84 @@
  "foto.salvar": "Salvar cópia: {nome}",
  "foto.salvar_n": "Salvar {n} cópias",
  "foto.aviso": "Sempre uma cópia na mesma pasta: a original fica como está. A cópia sai sem os dados de localização e do aparelho. Cortar, girar e clarear são na hora; tirar o fundo, aumentar e remover um objeto usam modelinhos neste computador e levam alguns segundos.",
- "foto.salvas": "Cópia salva: {nomes}."
+ "foto.salvas": "Cópia salva: {nomes}.",
+ "cfg.dev": "Modo dev",
+ "cfg.dev_sub": "Para quem quer mexer no que fica no automático.",
+ "cfg.dev_ligar": "Mostrar os ajustes avançados e o diagnóstico",
+ "modo.dev.nome": "Dev",
+ "modo.dev.desc": "Tudo do Base, mais ajustes avançados e diagnóstico.",
+ "motor.preparando": "Preparando o motor novo (llama.cpp) em segundo plano. Pode continuar usando o openTARS.",
+ "motor.pronto": "Motor novo pronto: o openTARS agora roda no llama.cpp.",
+ "motor.erro": "Não deu para preparar o motor novo ({erro}). O openTARS continua no Ollama.",
+ "cfg.modelos.busca_ph": "Pesquisar modelos (nome, visão, ferramentas...)",
+ "cfg.modelos.busca_web": "Procurar na biblioteca do Ollama",
+ "cfg.modelos.buscando": "Procurando na biblioteca do Ollama...",
+ "cfg.modelos.busca_nada": "Nada encontrado na biblioteca do Ollama para essa pesquisa.",
+ "cfg.modelos.busca_erro": "Não deu para acessar a biblioteca do Ollama. Confira a conexão e tente de novo.",
+ "cfg.modelos.g.web": "Da biblioteca do Ollama",
+ "cfg.modelos.g.web_sub": "Resultados do ollama.com. O tamanho aparece ao clicar: ele é conferido antes de começar o download.",
+ "cfg.modelos.calculando": "Conferindo o tamanho do download...",
+ "cfg.assist.reabrir_titulo": "Apps que escondem os botões",
+ "cfg.assist.reabrir": "Deixar o openTARS reabrir um app para conseguir clicar nos botões dele",
+ "cfg.assist.reabrir_nota": "Apps baseados no Chrome que já estavam abertos (Claude, Discord, VS Code, Slack, Chrome) escondem os botões de outros programas. Com isto ligado, quando o openTARS precisar clicar em um deles, fecha o app e abre de novo com a acessibilidade ligada. O que não foi salvo nesse app pode se perder, e o app nunca é forçado a fechar: se ele recusar, continua aberto. Desligado por padrão.",
+ "vm.cli.uso": "Uso: opentars --missao-vm \"o que o agente deve fazer dentro da máquina virtual\"",
+ "vm.cli.falta": "A máquina virtual não está pronta: falta {falta}.",
+ "vm.cli.sem_base": "A imagem da máquina virtual ainda não foi montada.",
+ "vm.cli.sem_pro": "Isto precisa do modelo Gargantua Pro ({modelo}). Adicione em Configurações > Mais modelos.",
+ "vm.cli.comecando": "Começando numa máquina virtual descartável: {pedido}",
+ "vm.cli.resultado": "Terminou ({motivo}, {segundos} s): {resultado}",
+ "vm.cli.acesso": "  site visitado: {acesso}",
+ "vm.cli.arquivos": "O agente deixou {n} arquivo(s) na pasta de saída: {lista}",
+ "vm.cli.liberar": "Copiar para {pasta}? [s/N] ",
+ "vm.cli.descartados": "Não copiados. Foram apagados com a máquina virtual.",
+ "vm.secao": "Missões numa máquina virtual",
+ "vm.secao_sub": "O Gargantua Pro trabalha num computador isolado e descartável: abre programas, navega e escreve. Nada do seu PC fica visível lá dentro, e o que ele produzir só chega aqui se você aprovar.",
+ "vm.abrir": "Abrir a janela da VM",
+ "vm.so_linux": "Por enquanto, as missões em VM funcionam só no Linux com KVM.",
+ "vm.janela.titulo": "Missão numa máquina virtual",
+ "vm.janela.sub": "Escreva o que o agente deve fazer. Ele usa o mouse e o teclado de uma VM descartável; ao terminar, a VM é apagada.",
+ "vm.janela.falta": "A máquina virtual não está pronta: falta {falta}.",
+ "vm.janela.sem_base": "A imagem da VM ainda não existe. Montar leva uns 5 minutos e ocupa cerca de 1,6 GB.",
+ "vm.janela.sem_pro": "As missões em VM usam o Gargantua Pro (cerca de 7,6 GB).",
+ "vm.janela.conferindo": "Conferindo o modelo...",
+ "vm.janela.montar": "Montar a imagem",
+ "vm.janela.montando": "Montando a imagem da VM...",
+ "vm.janela.montando_pct": "Baixando o sistema da VM: {pct}%",
+ "vm.janela.baixar_pro": "Baixar o Gargantua Pro",
+ "vm.janela.baixando": "Baixando o Gargantua Pro...",
+ "vm.janela.erro": "Não deu certo: {erro}",
+ "vm.janela.pedido_ph": "Ex.: abra o terminal e crie o arquivo notas.txt na pasta de saída com a lista de compras",
+ "vm.janela.comecar": "Começar",
+ "vm.janela.parar": "Parar",
+ "vm.janela.internet": "Internet (cada site fica registrado)",
+ "vm.janela.sem_tela": "A tela da VM aparece aqui.",
+ "vm.janela.tela": "Tela da máquina virtual",
+ "vm.janela.passos": "Passos",
+ "vm.janela.sites": "Sites visitados",
+ "vm.janela.ligando": "Ligando a VM...",
+ "vm.janela.trabalhando": "O agente está trabalhando.",
+ "vm.janela.parando": "Parando...",
+ "vm.janela.fim": "Terminou ({motivo}, {segundos} s): {resultado}",
+ "vm.janela.arquivos": "O agente deixou {n} arquivo(s) na pasta de saída. Marque o que deve vir para o seu PC:",
+ "vm.janela.trazer": "Trazer para {pasta}",
+ "vm.janela.descartar": "Descartar tudo",
+ "vm.janela.trazidos": "{n} arquivo(s) copiado(s) para {pasta}. O resto foi apagado.",
+ "vm.janela.descartados": "Nada foi copiado. Os arquivos foram apagados com a VM.",
+ "vm.motivo.terminou": "concluída",
+ "vm.motivo.cancelada": "parada por você",
+ "vm.motivo.tempo": "tempo esgotado",
+ "vm.motivo.passos": "limite de passos",
+ "vm.passo.clicar": "clicou em {detalhe}",
+ "vm.passo.duplo": "clique duplo em {detalhe}",
+ "vm.passo.direito": "clique direito em {detalhe}",
+ "vm.passo.atalho": "apertou {detalhe}",
+ "vm.passo.digitou": "digitou um texto",
+ "vm.passo.rolou": "rolou a tela",
+ "vm.passo.esperou": "esperou",
+ "cli.barra_dica": "/ajuda · ctrl+c para",
+ "jp.atualizando_script": "Atualizando pelo instalador... o openTARS reabre sozinho quando terminar.",
+ "jp.erro_script": "A atualização não terminou. O registro está em {arquivo}.",
+ "setup.motor_llamacpp": "Motor: llama.cpp. O openTARS baixa o motor e o Gargantua 2.5 na primeira abertura, com barra e sem pedir senha.",
+ "g25.oferta": "Chegou o Gargantua 2.5, a IA nova do openTARS: vê a tela e entende a sua voz.",
+ "g25.ver": "Baixar o Gargantua 2.5"
 }

app/nucleo/aplicacoes.py

@@ -820,6 +820,44 @@ def _eh_electron(comando):
     return False
 
 
+def comando_com_acessibilidade(argv):
+    """O mesmo comando com a opção que faz o Chromium/Electron montar a árvore de acessibilidade (sem repetir se já tem)."""
+    argv = list(argv)
+    return argv if OPCAO_ACESSIBILIDADE_CHROMIUM in argv else argv[:1] + [OPCAO_ACESSIBILIDADE_CHROMIUM] + argv[1:]
+
+
+def reabrir_com_acessibilidade(pid, esperar=10):
+    """11/11 (F11): um app Electron/Chromium que já estava aberto não expõe seus botões (medido: ligar a acessibilidade da sessão,
+    registrar ouvinte AT-SPI e ligar ScreenReaderEnabled não acordam um app aberto). O único caminho que funciona é abrir de novo
+    com a opção. Fecha o app com SIGTERM (nunca SIGKILL: se ele não sair, desiste) e abre igual, com a opção.
+    Só chamar com a permissão da pessoa (config reabrir_com_acessibilidade). Devolve (ok, mensagem)."""
+    import signal
+    try:
+        argv = [a.decode() for a in open(f"/proc/{pid}/cmdline", "rb").read().split(b"\0") if a]
+        pasta = os.readlink(f"/proc/{pid}/cwd")
+        ambiente = dict(os.environ)
+    except (OSError, UnicodeDecodeError):
+        return False, "could not read the app's command line"
+    if len(argv) == 1 and " " in argv[0]:       # o Chromium reescreve o título do processo: tudo vem numa palavra só
+        # shortcut: separa por espaço, então um argumento com espaço no valor quebra; trocar por leitura do `ps -o args` se aparecer
+        argv = [os.path.realpath(f"/proc/{pid}/exe")] + argv[0].split(" ")[1:]
+    if not argv or not _eh_electron(argv):
+        return False, "not an Electron/Chromium app"
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except OSError as erro:
+        return False, f"could not close it: {erro}"
+    limite = time.time() + esperar
+    while time.time() < limite and os.path.exists(f"/proc/{pid}"):
+        time.sleep(0.2)
+    if os.path.exists(f"/proc/{pid}") and "zombie" not in open(f"/proc/{pid}/status").read().lower():
+        return False, "the app did not close (maybe it is asking to save something); it was left open"
+    ambiente["ACCESSIBILITY_ENABLED"] = "1"
+    subprocess.Popen(comando_com_acessibilidade(argv), cwd=pasta, env=ambiente, stdin=subprocess.DEVNULL,
+                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+    return True, "reopened with accessibility on"
+
+
 # Nomes que são SITES, não programas (18/10: open_application("google") abria o Google Chrome, que só tem "google" no
 # nome). Só vira site quando não há um programa com exatamente esse nome: um Spotify ou Discord instalado continua app.
 _SITES_NAO_APPS = frozenset({"google", "youtube", "gmail", "wikipedia", "reddit", "amazon", "github", "facebook",

app/nucleo/chat.py

@@ -103,7 +103,7 @@ def _print_em_texto(imagem_b64, pedido, modelo, janela=None, arquivo=None):
             f"'{arquivo}' was loaded, but you cannot see images and the vision model "
             + ("did not answer this time" if visao_instalada() else "is not installed")
             + ". Don't retry. Tell the user plainly that you could not look at the image, and that Gargantua 2 "
-            "is the model that lets you see it (ollama pull ProjectOpenTARS/Gargantua-2). "
+            "is the model that lets you see it (ollama pull ProjectOpenTARS/Gargantua-2.5). "
             f"The user's request was: \"{pedido}\"."
         )
     return (
@@ -463,6 +463,11 @@ def _mensagens_sem_pensar(mensagens):
     return copia
 
 
+# Famílias do Gargantua que obedecem ao think=false e não conhecem o "/no_think" do Qwen3: o Qwen3.5 (2 e Lite de hoje) e o
+# Gemma 4 (Gargantua 2.5, 10/11: o molde do Gemma 4 põe o pensamento vazio sozinho quando enable_thinking é falso).
+_FAMILIAS_THINK_FALSE = ("qwen35", "gemma4")
+
+
 def _familia_do_modelo(modelo):
     """A família que o Ollama informa ('qwen3', 'qwen35', ...). Lê o catálogo se ainda não foi lido: no modo de modelo fixo
     (o da prova do Lab) ele não era, a família vinha vazia, o Gargantua em Qwen3.5 ia sem think=false, pensava em vez de
@@ -490,7 +495,7 @@ def _executar_turno_streaming(modelo, mensagens, tools, pensar=True):
     _carregar_pensa_sem_pedir()
     # o "/no_think" é truque do Qwen3; o Qwen3.5 não conhece e o lê como parte do pedido (17/10: abriu o site "/no_think" e
     # tentou "apt install no_think"). Ele obedece ao think=false.
-    forcar_nothink = (not pensar) and modelo in _PENSA_MESMO_SEM_PEDIR and _familia_do_modelo(modelo) != "qwen35"
+    forcar_nothink = (not pensar) and modelo in _PENSA_MESMO_SEM_PEDIR and _familia_do_modelo(modelo) not in _FAMILIAS_THINK_FALSE
     payload = {
         "model": modelo,
         "messages": _mensagens_sem_pensar(mensagens) if forcar_nothink else mensagens,
@@ -499,7 +504,7 @@ def _executar_turno_streaming(modelo, mensagens, tools, pensar=True):
         "think": bool(pensar),
         "options": {"temperature": temperatura_conversa(), "num_ctx": contexto_ia()},
     }
-    if eh_gargantua(modelo) and not pensar and _familia_do_modelo(modelo) != "qwen35":
+    if eh_gargantua(modelo) and not pensar and _familia_do_modelo(modelo) not in _FAMILIAS_THINK_FALSE:
         # Treinado sem raciocínio: com think=false o molde do .gguf abre a resposta com "<think></think>", que no treino só
         # vinha antes da resposta final em texto, e o modelo respondia sem chamar ferramenta (prova de 14/10/2026).
         # 17/10: o Gargantua em Qwen3.5 é o contrário: o molde dele põe o <think> vazio também antes das ferramentas e o
@@ -831,6 +836,7 @@ _PERGUNTA_DE_IDENTIDADE = re.compile(
     r"who (?:are you|made you|created you|built you|developed you|trained you|is your (?:creator|developer|founder|maker))|"
     r"what(?:'s| is) your name|your (?:name|creator|developer|founder)|who (?:is|are) (?:the )?(?:founder|creator) of opentars|"
     r"(?:fundador|criador|dono|founder|creator) (?:do |da |of )?opentars)\b")
+_PEDE_CALCULADORA = re.compile(r"\b(?:calculadora|calculator)\b")
 _VERBOS_DE_BUSCA = re.compile(r"\b(?:pesquis\w*|busc\w*|procur\w*|search\w*|find|look up|look for|ache|achar)\b")
 
 
@@ -860,6 +866,10 @@ def _contexto_do_pedido(texto, tarefa, multi_etapas, retoma=None):
         linhas.append("About you: your name is Gargantua. You were developed by Enzo, the founder of openTARS, and you run "
                       "inside the openTARS app (openTARS is the app, Gargantua is you). Say so in your own words; never "
                       "name another company or model as your maker.")
+    if _PEDE_CALCULADORA.search(texto_n):
+        # 10/11: o Gemma 4 trocava "quanto é 310 mais 506? usa a calculadora" por search_web (3 de 3); o Lite de 23/10 também
+        linhas.append("The user wants the Calculator app: call open_application with name=\"calculator\" and do the math "
+                      "there. Do not use search_web for it.")
     sites = _sites_citados_na_busca(texto_n)
     if sites:
         linhas.append("To search INSIDE a site, call search_web with query = only the search terms and service = the site "
@@ -1649,6 +1659,17 @@ def _gerar_imagem_pelo_chat(texto):
     return _responder_sem_modelo(texto, t("imagem.pronta", arquivo=arquivo.name, pasta=arquivo.parent) + f"\n\n![{o_que}]({arquivo})")
 
 
+def _resolver_sem_modelo(texto):
+    """5.3 (F4): o que sai por regra, sem o modelo (tars_atalhos): estado do PC, memória, contas, arquivos, vários passos e
+    perguntas sobre o mundo pelo SearXNG. None: segue para o modelo. Um erro aqui nunca impede a conversa."""
+    try:
+        import tars_atalhos
+        return tars_atalhos.resolver(texto, sys.modules[__name__])
+    except Exception as e:  # noqa: BLE001
+        logging.warning("atalhos sem modelo falharam: %s", e)
+        return None
+
+
 def processar_mensagem(texto, anexos=None):
     """Um pedido do usuário do começo ao fim: comandos (/modelo,
     /limpar...), escolha do modelo, resposta e salvamento. Usado pelo
@@ -1684,6 +1705,10 @@ def processar_mensagem(texto, anexos=None):
         return gerada
     import tars_imagem
     tars_imagem.parar()        # o Bonsai segura a placa; a conversa (Ollama) precisa dela agora
+    if not anexos:
+        direta = _resolver_sem_modelo(texto)
+        if direta is not None:
+            return _responder_sem_modelo(texto, direta)
 
     # "use a ferramenta", "faz de verdade", "try again": a tarefa e o modelo saem do pedido anterior, que é o que vai ser feito
     retoma = _ultimo_pedido_real() if not anexos and escolha.eh_retomada(normalizar(texto)) else None

app/nucleo/controle.py

@@ -264,7 +264,17 @@ def _abrir_em_janela_de_terminal(comando, nome):
         "Use a non-interactive command instead (for example 'top -bn1' or 'free -h').")}
 
 
+def til_entre_aspas(comando):
+    """O modelo escreve mkdir -p "~/Documentos/Jogos": o bash não expande o ~ entre aspas e cria uma pasta chamada "~" na pasta
+    atual, e a ferramenta ainda diz que deu certo (Gargantua 2.5 em Gemma 4, 10/11: 4 tarefas de pasta da prova de 80). O ~ sai
+    das aspas e o resto fica entre elas (~/"Área de Trabalho/x"): vale no bash e no mini-shell."""
+    comando = re.sub(r'"~/([^"]*)"', r'~/"\1"', comando)
+    comando = re.sub(r"'~/([^']*)'", r"~/'\1'", comando)
+    return re.sub(r'(["\'])~\1', "~", comando)
+
+
 def _executar_terminal_de_fato(comando):
+    comando = til_entre_aspas(comando)
 
     # 5.2: fora do Linux, os comandos de bash que o Gargantua aprendeu rodam no mini-shell em Python (tars_shell), com a
     # saída no formato GNU do treino. No Windows o resto não roda; no macOS vai para o shell do sistema.
@@ -563,7 +573,7 @@ def _mirar_bruto(x=None, y=None, alvo=None, janela=None):
         return ox + nx, oy + ny, como
     if not visao_instalada():
         return None, None, (f"Could not find '{alvo}': it is not in the accessibility tree and no vision model is "
-                            "installed (ollama pull ProjectOpenTARS/Gargantua-2). Pass x/y from a screenshot.")
+                            "installed (ollama pull ProjectOpenTARS/Gargantua-2.5). Pass x/y from a screenshot.")
     return None, None, (f"The vision model could not find '{alvo}' ({motivo_da_falha_da_visao()}). "
                         "Pass x/y from a screenshot.")
 

app/nucleo/elementos.py

@@ -218,6 +218,16 @@ def _janela_acessivel(nome):
             if alvo is not None:
                 alvo = dict(alvo, aberto_agora=True)
 
+    # 11/11 (F11): app Electron já aberto sem árvore: com a permissão da pessoa, reabre com a acessibilidade ligada e procura de novo
+    if alvo is None and nome and i18n.ler_config().get("reabrir_com_acessibilidade") and not _sem_arvore(nome):
+        janela_x = encontrar_janela_por_nome(nome)
+        if janela_x and janela_x.get("pid"):
+            ok, _ = reabrir_com_acessibilidade(janela_x["pid"])
+            limite = time.time() + (TIMEOUT_JANELA_ACESSIVEL_SEG if ok else 0)
+            while ok and alvo is None and time.time() < limite:
+                time.sleep(0.5)
+                alvo = procurar()
+
     if alvo is None:
         if nome and (aberta_no_x or encontrar_janela_por_nome(nome) is not None):
             _marcar_sem_arvore(nome)

app/nucleo/gargantua.py

@@ -19,7 +19,7 @@
 
 # ollama pull ProjectOpenTARS/Gargantua-2   (18/10: o Gargantua 2, Qwen3.5 2B com visão, é o principal; o repositório
 # antigo, ProjectOpenTARS/Gargantua, continua servindo quem já o tem e os apps antigos)
-MODELO_GARGANTUA = os.environ.get("TARS_MODELO_GARGANTUA", "ProjectOpenTARS/Gargantua-2")
+MODELO_GARGANTUA = os.environ.get("TARS_MODELO_GARGANTUA", "ProjectOpenTARS/Gargantua-2.5")
 REPOSITORIO_ANTIGO = "ProjectOpenTARS/Gargantua"
 VERSAO_GARGANTUA = "1.2"      # a do kit (gargantua/gargantua.py): 19 ferramentas
 
@@ -62,9 +62,16 @@ def gargantua_desligado():
     return normalizar(os.environ.get("TARS_SEM_GARGANTUA") or "") in ("1", "sim", "yes", "on", "true")
 
 
+def _segmento_gargantua(base):
+    """O pedaço do nome que diz Gargantua. Um nome local com barra ('Gargantua-lite-teste-4/11') vira namespace/modelo no
+    Ollama: olhando só o último pedaço, o app tratava o modelo como outro qualquer, ligava o raciocínio e trocava o prompt."""
+    partes = str(base or "").strip().lower().split("/")
+    return next((p for p in partes if p.startswith("gargantua")), partes[-1])
+
+
 def eh_gargantua(modelo):
-    """'gargantua', 'gargantua:1.0', 'ProjectOpenTARS/Gargantua:latest'..."""
-    return str(modelo or "").strip().lower().split("/")[-1].startswith("gargantua")
+    """'gargantua', 'gargantua:1.0', 'ProjectOpenTARS/Gargantua:latest', 'Gargantua-teste-4/11'..."""
+    return _segmento_gargantua(modelo).startswith("gargantua")
 
 
 def e_gargantua_2(modelo):
@@ -73,23 +80,23 @@ def e_gargantua_2(modelo):
 
 
 def variante_do_gargantua(modelo):
-    """'lite' ou 'code' se o nome ou a etiqueta dizem que é uma VARIANTE do Gargantua (gargantua-code,
+    """'lite', 'code', 'pro' ou 'pi' se o nome ou a etiqueta dizem que é uma VARIANTE do Gargantua (gargantua-code,
     ProjectOpenTARS/Gargantua:code, Gargantua:1.2-lite); '' se é o oficial (ou qualquer outro Gargantua).
     A mesma regra está no kit (gargantua.py: variante_do_nome) e em tars_primeiro_uso.py."""
     base, _, tag = str(modelo or "").strip().lower().partition(":")
-    segmento = base.split("/")[-1]
+    segmento = _segmento_gargantua(base)
     partes = re.split(r"[-_. ]", segmento[len("gargantua"):] if segmento.startswith("gargantua") else segmento)
     for parte in partes + re.split(r"[-_. ]", tag):
-        if parte in ("lite", "code"):
+        if parte in ("lite", "code", "pro", "pi"):
             return parte
     return ""
 
 
 def ordem_do_gargantua(tag):
-    """Quem vai na frente quando há vários Gargantua: o Gargantua 2, o oficial antigo, os outros, o Code e por fim o Lite."""
+    """Quem vai na frente quando há vários Gargantua: o Gargantua 2, o oficial antigo, os outros, o Code e o Pro, o Lite e por fim o Pi."""
     variante = variante_do_gargantua(tag)
     if variante:
-        return {"code": 3, "lite": 4}[variante]
+        return {"code": 3, "pro": 3, "lite": 4, "pi": 5}[variante]
     if e_gargantua_2(tag):
         return 0
     return 1 if str(tag).lower().startswith(REPOSITORIO_ANTIGO.lower()) else 2

app/nucleo/hardware.py

@@ -375,6 +375,9 @@ def _categorizar_modelo(tag, capacidades, parametros_b, familia):
         return "embedding"
     if re.search(r"(^|/)(flux|z-image)", nome):
         return "embedding"
+    # 5.3: o Gargantua Pi tem prompt e 4 ferramentas próprios, do openTARS Pi: com as 19 do app grande ele só atrapalharia.
+    if variante_do_gargantua(tag) == "pi":
+        return "embedding"
     # Ollama antigo não informa capacidades: reconhece pelo nome os modelos
     # de embeddings conhecidos (granite-embedding, nomic-embed-text...).
     if not capacidades and re.search(r"embed|minilm|bge-|paraphrase-multilingual|snowflake-arctic|e5-", nome):
@@ -494,9 +497,8 @@ def modelo_ajudante(catalogo=None):
     um nome fixo que pode nem estar instalado nesta máquina."""
 
     catalogo = catalogo if catalogo is not None else catalogar_modelos()
-    # O Cooper só olha a tela e embedding não conversa: nenhum dos dois resolve nome de app.
-    catalogo = {t_: m for t_, m in catalogo.items()
-                if m["categoria"] != "embedding" and not visao_lib.e_cooper(t_) and not m.get("nuvem")}
+    # Embedding não conversa: não resolve nome de app.
+    catalogo = {t_: m for t_, m in catalogo.items() if m["categoria"] != "embedding" and not m.get("nuvem")}
 
     candidatos = modelos_com_capacidade(catalogo, "tools") or [
         m for m in catalogo.values() if m["categoria"] != "embedding"
@@ -544,8 +546,6 @@ def construir_cadeia_fallback(tarefa, catalogo=None):
     candidatos = [m for m in catalogo.values() if m["categoria"] != "embedding" and not m.get("nuvem")]
     # Os ajudantes não conversam: só entram se não houver mais nada.
     candidatos = [m for m in candidatos if m["tag"] not in MODELOS_AJUDANTES] or candidatos
-    # O Cooper nunca conversa, nem como último recurso (ele só responde sobre prints).
-    candidatos = [m for m in candidatos if not visao_lib.e_cooper(m["tag"])]
     if not candidatos:
         return []
 

app/nucleo/nuvem.py

@@ -28,7 +28,7 @@ def servidor_api():
     dados = nuvem_config()
     if not (dados["ativa"] and dados["endereco"] and dados["chave"]):
         return ""
-    return dados["endereco"].rstrip("/")
+    return api.normalizar_url(dados["endereco"])   # "localhost:1234" escrito à mão não chegava a lugar nenhum
 
 
 def _cabecalhos_api():

app/nucleo/ollama.py

@@ -80,9 +80,8 @@ def _chat_unico(
         "keep_alive": keep_alive,
         "options": {"temperature": temperatura},
     }
-    if not visao_lib.e_cooper(modelo):
-        # mesmo num_ctx do chat: senão o Ollama recarrega o modelo a cada consulta de bastidor
-        corpo["options"]["num_ctx"] = contexto_ia()
+    # mesmo num_ctx do chat: senão o Ollama recarrega o modelo a cada consulta de bastidor
+    corpo["options"]["num_ctx"] = contexto_ia()
     if opcoes:
         corpo["options"].update(opcoes)
 
@@ -189,6 +188,26 @@ def aquecer_modelo_da_conversa():
     threading.Thread(target=_pedir, daemon=True).start()
 
 
+_KEEP_ALIVE_EM_SEGUNDO_PLANO = KEEP_ALIVE
+
+
+def manter_modelo_com_janela(aberta):
+    """Janela aberta: o modelo fica na memória e responder não recarrega. Janela escondida (bandeja) ou fechada: volta ao tempo
+    normal, para não gastar memória em segundo plano. TARS_KEEP_ALIVE escolhido à mão continua valendo."""
+    global KEEP_ALIVE
+    if os.environ.get("TARS_KEEP_ALIVE"):
+        return
+    # O número -1, não o texto "-1": o Ollama 0.40.13 recusa "-1" (HTTP 400, 'time: missing unit in duration') e todo pedido falhava.
+    KEEP_ALIVE = -1 if aberta else _KEEP_ALIVE_EM_SEGUNDO_PLANO
+    # o Ollama guarda o tempo do último pedido: sem este aviso, o modelo carregado com -1 nunca sairia da memória
+    for modelo in (listar_modelos_rodando() or set()) & (modelos_do_tars | ({modelo_atual} if modelo_atual else set())):
+        try:
+            _SESSION.post(OLLAMA_GENERATE_URL, json={"model": modelo, "prompt": "", "keep_alive": KEEP_ALIVE,
+                                                     "options": {"num_ctx": contexto_ia()}}, timeout=TIMEOUT_HTTP_DESCARREGAR)
+        except Exception:
+            pass
+
+
 def descarregar_modelo(modelo):
     """Pede ao Ollama para descarregar um modelo (keep_alive=0).
     Retorna True se a chamada foi aceita — isso NÃO garante que o
@@ -218,7 +237,7 @@ def descarregar_modelo(modelo):
 def ollama_online():
     """O servidor do Ollama responde no endereço configurado?"""
     try:
-        return _SESSION.get(f"{OLLAMA_HOST}/api/version", timeout=TIMEOUT_HTTP_CURTO).status_code == 200
+        return _SESSION.get(motor_lib.url("versao", OLLAMA_HOST), timeout=TIMEOUT_HTTP_CURTO).status_code == 200
     except Exception:
         return False
 

app/nucleo/registro.py

@@ -434,7 +434,7 @@ class _Girando:
                 quadro = self.QUADROS[i % len(self.QUADROS)]
                 segundos = int(time.time() - self.desde)
                 linha = (f"\r\033[K{Cor.MAGENTA}{quadro}{Cor.RESET} {self.texto}… "
-                         f"{Cor.CINZA}({segundos}s · {t('term.parar')}){Cor.RESET}")
+                         f"{Cor.CINZA}({_tempo_curto(segundos)} · {t('term.parar')}){Cor.RESET}")
                 self.saida.write(linha)
                 self.saida.flush()
                 self.visivel = True
@@ -519,7 +519,9 @@ def _term_resposta(d):
         if d.get("apos_pensamento"):
             print()
         print("\n" + c("● ", Cor.VERDE), end="")
-    print(_recuar(d["texto"]), end="", flush=True)
+        _MD.reiniciar()
+    texto = _MD.alimentar(d["texto"]) if _girando.ligado else d["texto"]      # 5.3: formatado só num terminal de verdade
+    print(_recuar(texto), end="", flush=True)
 
 
 def _term_tempo(d):
@@ -554,7 +556,7 @@ _TERMINAL = {
     "descarregando": _term_descarregando,
     "pensamento": _term_pensamento,
     "resposta": _term_resposta,
-    "fim_stream": lambda d: print(flush=True),
+    "fim_stream": lambda d: print(_recuar(_MD.terminar()) if _girando.ligado else "", flush=True),
     "tempo": _term_tempo,
     "folego": _term_folego,
     "analisando": _term_analisando,

app/nucleo/selecao.py

@@ -582,9 +582,9 @@ _CRITERIOS_MODELO = {
 
 
 def _so_de_conversa(catalogo):
-    """"/modelo o menor", "o de visão"...: só entra modelo que conversa (nem embedding, nem o Cooper)."""
+    """"/modelo o menor", "o de visão"...: só entra modelo que conversa (não embedding)."""
     return {t_: m for t_, m in catalogo.items()
-            if m["categoria"] != "embedding" and not visao_lib.e_cooper(t_) and not m.get("nuvem")}
+            if m["categoria"] != "embedding" and not m.get("nuvem")}
 
 
 def _extremo_por_tamanho(catalogo, menor):

app/nucleo/terminal.py

@@ -216,14 +216,7 @@ def _tratar_comando_do_chat(linha):
 
 
 def _linha_de_status():
-    modelo = modelo_atual or (modelo_manual if modo_modelo == "MANUAL" else "auto")
-    usados = estimar_tokens(conversa)
-    partes = [str(modelo), t("cli.status_contexto", pct=min(100, int(100 * usados / max(1, contexto_ia()))))]
-    if MODO_PERMISSAO != "perguntar":
-        partes.append(t(f"cli.status_modo.{MODO_PERMISSAO}"))
-    if CONTEXTO_PROJETO["caminho"]:
-        partes.append("AGENTS.md")
-    print(c("  " + " · ".join(partes), Cor.CINZA))
+    print(c("  " + " · ".join(_partes_do_status()), Cor.CINZA))
 
 
 def _mostrar_plano():
@@ -285,12 +278,16 @@ def _boas_vindas(pedidos):
     else:
         garg = gargantua_instalado() if online else None
         modelo = t("term.modelo_auto") + (f" · {garg.split('/')[-1]}" if garg else "")
-    ollama = (c("●", Cor.VERDE) + " " + t("term.ollama_online", host=OLLAMA_HOST) if online
-              else c("●", Cor.VERMELHO) + " " + t("term.ollama_offline", host=OLLAMA_HOST))
-    linhas = [c("✻ ", Cor.MAGENTA) + c(t("term.bem_vindo"), Cor.NEGRITO), "",
+    nome_motor = _nome_do_motor()
+    motor_linha = (c("●", Cor.VERDE) + " " + nome_motor + " · " + t("term.ollama_online", host=OLLAMA_HOST) if online
+                   else c("●", Cor.VERMELHO) + " " + nome_motor + " · "
+                   + t("term.ollama_offline" if nome_motor == "Ollama" else "term.motor_offline", host=OLLAMA_HOST))
+    ramo = _ramo_git()
+    linhas = [c("✻ ", Cor.MAGENTA) + c(t("term.bem_vindo"), Cor.NEGRITO) + c(f"  {VERSAO_EXIBIDA}", Cor.CINZA), "",
               c("  " + t("chat.dica"), Cor.CINZA), "",
-              c("  " + t("term.rotulo_ollama") + " ", Cor.CINZA) + ollama,
-              c("  " + t("term.rotulo_modelo") + " ", Cor.CINZA) + modelo]
+              c("  " + t("term.rotulo_motor") + " ", Cor.CINZA) + motor_linha,
+              c("  " + t("term.rotulo_modelo") + " ", Cor.CINZA) + modelo,
+              c("  " + t("term.rotulo_pasta") + " ", Cor.CINZA) + _pasta_curta() + (c(f"  ⎇ {ramo}", Cor.CINZA) if ramo else "")]
     if pedidos:
         linhas.append(c("  " + t("term.conversa_carregada", n=pedidos), Cor.CINZA))
     print()
@@ -376,14 +373,20 @@ def _conversar(pedido_unico, retomar=None):
     if retomar == "escolher":
         _escolher_conversa()
     interativo = sys.stdin.isatty()
+    # 5.3 (F8, só aparência): caixa de entrada do Claude Code com a barra do opencode; sem readline ou sem cor, a régua de antes
+    caixa = interativo and sys.stdout.isatty() and TEM_READLINE and not os.environ.get("NO_COLOR") and os.environ.get("TERM") != "dumb"
     ctrl_c = 0
     try:
         while True:
             try:
                 # \001..\002 avisam o readline que as cores não ocupam coluna (senão a edição da linha embaralha)
                 ini, fim = ("\001", "\002") if TEM_READLINE else ("", "")
-                linha = input("\n" + ini + Cor.NEGRITO + Cor.VERDE + fim + "❯ "
-                              + ini + Cor.RESET + fim if interativo else "").strip()
+                if caixa:
+                    linha = _pedir_na_caixa(ini, fim).strip()
+                else:
+                    if interativo:
+                        print("\n" + _regua(MODO_PERMISSAO))      # 5.3: régua com o modo da conversa, como a barra do opencode
+                    linha = input(ini + Cor.NEGRITO + Cor.VERDE + fim + "❯ " + ini + Cor.RESET + fim if interativo else "").strip()
             except EOFError:
                 print()
                 break
@@ -404,7 +407,7 @@ def _conversar(pedido_unico, retomar=None):
             _executar_pedido_no_terminal(linha)
             _mostrar_plano()
             _guardar_no_historico()
-            if interativo:
+            if interativo and not caixa:             # com a caixa, a barra de estado já vem embaixo dela
                 _linha_de_status()
     finally:
         if ollama_online():
@@ -508,13 +511,6 @@ def modo_print(pedido, formato="text", modelo=None):
     return 0 if ok else 1
 
 
-def comando_cooper(instalar=True):
-    """opentars --cooper: o Cooper foi descontinuado (18/10/2026); o Gargantua 2 enxerga a tela. Só avisa e diz como instalar."""
-    print(c(t("cooper.descontinuado", comando=visao_lib.COMANDO_INSTALAR), Cor.AMARELO))
-    return 0
-
-
-
 # ------------------------------------------------------------
 # Logo no terminal: o monólito do TARS (quatro colunas e a faixa verde, como o ícone) com o nome ao lado.
 # Só aparece num terminal de verdade (não em pipe nem em script) e respeita NO_COLOR.
@@ -598,6 +594,10 @@ def main():
         import tars_prova
         sys.exit(tars_prova.executar(sys.modules[__name__], argumentos))
 
+    if "--missao-vm" in argumentos:                       # 5.3 (F7): missão do Gargantua Pro numa VM descartável
+        import tars_vm_cli
+        sys.exit(tars_vm_cli.executar(OLLAMA_HOST, argumentos, t, instalados=lambda: primeiro_uso.modelos_instalados(OLLAMA_HOST)))
+
     if any(a in ("--desinstalar", "--uninstall") for a in argumentos):
         import tars_desinstalar
         sys.exit(tars_desinstalar.executar(OLLAMA_HOST, t))
@@ -627,10 +627,6 @@ def main():
     if "--searxng" in argumentos:
         sys.exit(comando_searxng())
 
-    # --cooper: o Cooper foi descontinuado, o comando só avisa
-    if any(a in ("--cooper",) for a in argumentos):
-        sys.exit(comando_cooper())
-
     # 5.1: modo de permissão (perguntar, plano, automático) e qual conversa retomar
     global MODO_PERMISSAO
     if any(a in ("--plan", "--plano") for a in argumentos):
@@ -665,6 +661,8 @@ def main():
             palavras.append(arg)
             i += 1
         pedido = " ".join(palavras).strip()
+        if not pedido and sys.stdin.isatty():
+            _mostrar_logo()                  # 5.3: a conversa abre com o logo, como sem argumento
         sys.exit(modo_chat_terminal(pedido_unico=pedido or None, retomar=retomar))
 
     # --voz: fica ouvindo "TARS" e responde falando (nucleo/voz.py)

app/nucleo/visao.py

@@ -76,7 +76,7 @@ def _visao_cabe_junto(tag):
         catalogo = catalogar_modelos()
         meu = (catalogo.get(tag) or {}).get("vram_estimado_gb")
         outros = [m.get("vram_estimado_gb") for m in catalogo.values()
-                  if not visao_lib.e_cooper(m["tag"]) and m.get("categoria") != "embedding"
+                  if m.get("categoria") != "embedding"
                   and m.get("vram_estimado_gb") is not None]
         if not gpu or meu is None or not outros:
             return False

app/nucleo/visual.py

@@ -0,0 +1,165 @@
+# openTARS — nucleo/visual.py
+# Aparência do terminal novo da 5.3 (F8): um híbrido do CLI do Claude Code (● passo, ⎿ resultado, resposta formatada, aviso
+# de contexto) com o do opencode (régua com o modo da conversa e barra de estado com pasta e ramo). Só desenho: nada aqui
+# decide o que a IA faz. Parte do núcleo: roda dentro do namespace do tars.py, como as outras (ver _carregar_nucleo).
+# flake8: noqa
+
+import re as _re
+import shutil as _shutil
+
+
+def _largura_do_terminal(maximo=100):
+    return max(40, min(maximo, _shutil.get_terminal_size((80, 20)).columns))
+
+
+def _tempo_curto(segundos):
+    """12 -> "12s"; 65 -> "1m 05s"."""
+    segundos = int(segundos)
+    return f"{segundos}s" if segundos < 60 else f"{segundos // 60}m {segundos % 60:02d}s"
+
+
+def _nome_do_motor():
+    """"llama.cpp" se o app fala com o motor próprio (porta 11435); senão "Ollama"."""
+    try:
+        import tars_motor_local
+        if str(OLLAMA_HOST).rstrip("/") == tars_motor_local.URL:
+            return "llama.cpp"
+    except Exception:  # noqa: BLE001
+        pass
+    return "Ollama"
+
+
+def _pasta_curta():
+    """A pasta atual, com ~ no lugar da pasta pessoal."""
+    try:
+        pasta = os.path.realpath(os.getcwd())          # realpath dos dois lados: no macOS /var é /private/var e o ~ não casava
+    except OSError:                                    # a pasta atual foi apagada: o enfeite não derruba o chat
+        return ""
+    casa = os.path.realpath(os.path.expanduser("~"))
+    if pasta == casa or pasta.startswith(casa + os.sep):
+        pasta = "~" + pasta[len(casa):]
+    return pasta if len(pasta) <= 40 else "…" + pasta[-39:]
+
+
+def _ramo_git():
+    """O ramo do git da pasta atual, ou "" (sem git, fora de repositório, ou demorou)."""
+    try:
+        r = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True, timeout=1.0,
+                           cwd=os.getcwd(), env=_env_filho() if "_env_filho" in globals() else None)
+        return r.stdout.strip() if r.returncode == 0 else ""
+    except Exception:  # noqa: BLE001  (sem git, ou um teste que troca o subprocess: o enfeite nunca derruba o chat)
+        return ""
+
+
+def _regua(modo):
+    """A linha que separa um pedido do outro, com o modo da conversa à direita (como a barra do opencode)."""
+    rotulo = " " + t(f"cli.regua.{modo}") + " "
+    largura = _largura_do_terminal()
+    return c("─" * max(4, largura - len(rotulo) - 2), Cor.CINZA) + c(rotulo, Cor.CINZA) + c("──", Cor.CINZA)
+
+
+def _partes_do_status():
+    """Modelo, contexto usado, pasta com o ramo, modo (quando não é o padrão) e AGENTS.md: a mesma conta da linha de status."""
+    modelo = modelo_atual or (modelo_manual if modo_modelo == "MANUAL" else "auto")
+    usados = estimar_tokens(conversa)
+    partes = [str(modelo).split("/")[-1], t("cli.status_contexto", pct=min(100, int(100 * usados / max(1, contexto_ia()))))]
+    ramo = _ramo_git()
+    partes.append(_pasta_curta() + (f" ⎇ {ramo}" if ramo else ""))
+    if MODO_PERMISSAO != "perguntar":
+        partes.append(t(f"cli.status_modo.{MODO_PERMISSAO}"))
+    if CONTEXTO_PROJETO["caminho"]:
+        partes.append("AGENTS.md")
+    return partes
+
+
+_SELO = "\033[1;38;5;16;48;5;78m"   # preto em negrito sobre verde (256 cores): o selo do openTARS na barra (como o do modo no opencode)
+
+
+def _barra_de_estado(largura):
+    """A barra do opencode embaixo da caixa: selo "openTARS", modelo · motor · contexto · pasta ⎇ ramo, e a dica à direita."""
+    partes = _partes_do_status()
+    partes.insert(1, _nome_do_motor())
+    esquerda = " openTARS "
+    meio = "  " + "  ·  ".join(partes)
+    dica = t("cli.barra_dica")
+    sobra = largura - len(esquerda) - len(meio) - len(dica) - 1
+    if sobra < 1:
+        meio, sobra = meio[:max(0, largura - len(esquerda) - 2)], 0
+        dica = ""
+    return _SELO + esquerda + Cor.RESET + c(meio, Cor.CINZA) + " " * sobra + c(dica, Cor.CINZA)
+
+
+def _pedir_na_caixa(ini, fim):
+    """Claude Code: o pedido é digitado dentro de uma caixa de cantos redondos, com a barra de estado logo abaixo. A caixa e a
+    barra são desenhadas antes e o cursor sobe para dentro; depois do Enter a linha ganha a borda da direita e o cursor desce
+    além da barra. Só num terminal de verdade com readline (as marcas \\001 e \\002 mantêm a edição da linha certa)."""
+    largura = _largura_do_terminal() - 1
+    borda = lambda s: c(s, Cor.CINZA)
+    sys.stdout.write("\n" + borda("╭" + "─" * (largura - 2) + "╮") + "\n" + borda("│") + " " * (largura - 2) + borda("│") + "\n"
+                     + borda("╰" + "─" * (largura - 2) + "╯") + "\n" + _barra_de_estado(largura) + "\033[2A\r")
+    sys.stdout.flush()
+    try:
+        linha = input(ini + Cor.CINZA + fim + "│ " + ini + Cor.NEGRITO + Cor.VERDE + fim + "❯ " + ini + Cor.RESET + fim)
+    except BaseException:
+        sys.stdout.write("\r\n\033[J")      # Ctrl+C ou Ctrl+D: some a caixa de baixo e a barra, a mensagem sai limpa
+        sys.stdout.flush()
+        raise
+    visivel = "│ ❯ " + linha
+    if len(visivel) <= largura - 2:          # coube numa linha: fecha a borda da direita e pula a borda de baixo e a barra
+        sys.stdout.write("\033[1A\r" + borda("│") + " " + c("❯ ", Cor.NEGRITO + Cor.VERDE) + linha
+                         + " " * (largura - 1 - len(visivel)) + borda("│") + "\n\033[1B\n")
+    else:                                     # quebrou em várias linhas: a caixa já se desfez; só limpa o que sobrou embaixo
+        sys.stdout.write("\033[J")
+    sys.stdout.flush()
+    return linha
+
+
+class _MarkdownTerminal:
+    """Formata a resposta, que chega aos pedaços, linha por linha: títulos em negrito, listas com •, **negrito**, `código` em
+    ciano e blocos de código com uma barra. Só vale num terminal de verdade (a janela e os pipes recebem o texto puro)."""
+
+    def __init__(self):
+        self.buf = ""
+        self.em_codigo = False
+
+    def reiniciar(self):
+        self.buf, self.em_codigo = "", False
+
+    def alimentar(self, texto):
+        """Devolve o que já pode ser impresso (as linhas completas); o resto espera a próxima quebra de linha."""
+        self.buf += texto
+        if "\n" not in self.buf:
+            return ""
+        *linhas, self.buf = self.buf.split("\n")
+        return "".join(self._linha(l) + "\n" for l in linhas)
+
+    def terminar(self):
+        resto, self.buf = self.buf, ""
+        saida = self._linha(resto) if resto else ""
+        self.em_codigo = False
+        return saida
+
+    @staticmethod
+    def _inline(linha):
+        linha = _re.sub(r"\*\*(.+?)\*\*", lambda m: Cor.NEGRITO + m.group(1) + Cor.RESET, linha)
+        return _re.sub(r"`([^`\n]+)`", lambda m: Cor.CIANO + m.group(1) + Cor.RESET, linha)
+
+    def _linha(self, linha):
+        if linha.lstrip().startswith("```"):
+            self.em_codigo = not self.em_codigo
+            rotulo = linha.strip().strip("`").strip()
+            return c("╭─ " + rotulo if self.em_codigo and rotulo else "╭─" if self.em_codigo else "╰─", Cor.CINZA)
+        if self.em_codigo:
+            return c("│ ", Cor.CINZA) + linha
+        m = _re.match(r"^(#{1,6})\s+(.*)$", linha)
+        if m:
+            return Cor.NEGRITO + (Cor.CIANO if len(m.group(1)) == 1 else "") + self._inline(m.group(2)) + Cor.RESET
+        m = _re.match(r"^(\s*)[-*]\s+(.*)$", linha)
+        if m:
+            return m.group(1) + c("•", Cor.CINZA) + " " + self._inline(m.group(2))
+        if linha.startswith("> "):
+            return c("│ ", Cor.CINZA) + c(self._inline(linha[2:]), Cor.ITALICO)
+        return self._inline(linha)
+
+
+_MD = _MarkdownTerminal()

app/nucleo/voz.py

@@ -61,12 +61,12 @@ def preferencias_voz():
         velocidade = float(dados.get("voz_velocidade") or 1.0)
     except (TypeError, ValueError):
         velocidade = 1.0
-    return {"vozes": vozes, "velocidade": velocidade}
+    return {"vozes": vozes, "velocidade": velocidade, "curta": not dados.get("voz_resposta_completa")}
 
 
 def aplicar_preferencias_voz():
     p = preferencias_voz()
-    voz_lib.configurar(vozes=p["vozes"], velocidade=p["velocidade"], idioma=i18n.idioma_atual())
+    voz_lib.configurar(vozes=p["vozes"], velocidade=p["velocidade"], idioma=i18n.idioma_atual(), curta=p["curta"])
 
 
 def voz_atual(idioma=None):

app/tars.py

@@ -29,6 +29,7 @@ import requests
 import psutil
 from PIL import Image
 
+import tars_motor as motor_lib
 import tars_i18n as i18n
 from tars_i18n import t
 import tars_acessibilidade as acess
@@ -160,7 +161,7 @@ if SESSAO_GRAFICA == "wayland" and os.environ.get("TARS_YDOTOOL", "1") not in ("
 # CONFIGURAÇÃO
 # ============================================================
 
-VERSAO = "5.2"
+VERSAO = "5.3"
 # 3.0 Miller: o classificador Murph e o modo AUTO.
 # 4.0 Endurance: o Gargantua (IA oficial); Endurance Neo: aviso de versão nova, tarefas longas.
 # 4.5 Endurance: o Cooper (visão da tela), WSL e Linux sem interface gráfica.
@@ -171,11 +172,11 @@ VERSAO = "5.2"
 #     conta do Ollama e pesquisa web pelo SearXNG.
 # 5.2 Ranger: Windows, macOS e outros Linux; o assistente do sistema (lançador, ações de texto, arquivos e fotos);
 #     Gargantua 2 retreinado com os dados da 5.2.
-CODINOME = "Ranger"
+CODINOME = "Tesseract"
 VERSAO_EXIBIDA = f"{VERSAO} {CODINOME}"
 # Endurance Neo: sobe a cada pacote publicado (AAAAMMDDNN). O aviso de versão
 # nova compara com a REVISAO do tars.py do GitHub (tars_atualizacao.py).
-REVISAO = 2026110101
+REVISAO = 2026111301
 
 # Endereço do servidor Ollama — respeita a variável de ambiente padrão
 # do próprio Ollama (OLLAMA_HOST), pra funcionar sem editar o código
@@ -224,11 +225,18 @@ def _normalizar_ollama_host(valor):
 
 
 OLLAMA_HOST = _normalizar_ollama_host(os.environ.get("OLLAMA_HOST"))
+if not os.environ.get("OLLAMA_HOST"):   # 5.3: o motor llama.cpp é o padrão (se já instalado); senão, ou se a config de dev escolheu o Ollama, o Ollama
+    try:
+        import tars_motor_local
+        if tars_motor_local.escolhido() == "llamacpp":
+            OLLAMA_HOST = tars_motor_local.garantir() or OLLAMA_HOST
+    except Exception:
+        pass
 
 
 def _ollama_responde(url, espera=0.8):
     try:
-        return requests.get(f"{url}/api/version", timeout=espera).status_code == 200
+        return requests.get(motor_lib.url("versao", url), timeout=espera).status_code == 200
     except Exception:
         return False
 
@@ -244,11 +252,11 @@ if EM_WSL and not os.environ.get("OLLAMA_HOST") and not _ollama_responde(OLLAMA_
             OLLAMA_HOST, OLLAMA_NO_WINDOWS = _candidato, True
             break
 
-OLLAMA_URL = f"{OLLAMA_HOST}/api/chat"
-OLLAMA_TAGS_URL = f"{OLLAMA_HOST}/api/tags"
-OLLAMA_SHOW_URL = f"{OLLAMA_HOST}/api/show"
-OLLAMA_GENERATE_URL = f"{OLLAMA_HOST}/api/generate"
-OLLAMA_PS_URL = f"{OLLAMA_HOST}/api/ps"
+OLLAMA_URL = motor_lib.url("conversa", OLLAMA_HOST)
+OLLAMA_TAGS_URL = motor_lib.url("modelos", OLLAMA_HOST)
+OLLAMA_SHOW_URL = motor_lib.url("detalhes", OLLAMA_HOST)
+OLLAMA_GENERATE_URL = motor_lib.url("gerar", OLLAMA_HOST)
+OLLAMA_PS_URL = motor_lib.url("rodando", OLLAMA_HOST)
 
 # Quanto tempo cada modelo fica na memória (RAM/VRAM) depois do último uso: o
 # Ollama o descarrega sozinho. Curto = PC fraco liberado mais cedo; o modelo
@@ -273,15 +281,7 @@ MODELO_PADRAO = os.environ.get("TARS_MODELO_PADRAO", "qwen3:0.6b")
 # Neo: o classificador por IA (qwen2.5:0.5b) saiu; quem decide o tipo do
 # pedido é a helper Murph. Os ajudantes das versões antigas, se ainda
 # estiverem instalados, ficam fora da escolha de conversa.
-class _Ajudantes(set):
-    """Modelos que não entram na escolha de conversa: os ajudantes antigos e
-    o Cooper (4.5), que só olha a tela."""
-
-    def __contains__(self, tag):
-        return set.__contains__(self, tag) or visao_lib.e_cooper(tag)
-
-
-MODELOS_AJUDANTES = _Ajudantes({"qwen2.5:0.5b", "gemma3:270m"})
+MODELOS_AJUDANTES = {"qwen2.5:0.5b", "gemma3:270m"}
 
 # ------------------------------------------------------------
 # Timeouts de rede (segundos) — nomeados por propósito, não por valor,
@@ -390,6 +390,7 @@ _CAPACIDADES_RELEVANTES = {"tools", "vision", "thinking"}
 PASTA_NUCLEO = Path(__file__).resolve().parent / "nucleo"
 PARTES_NUCLEO = (
     "registro",
+    "visual",
     "ollama",
     "hardware",
     "aplicacoes",

app/tars_acessibilidade.py

@@ -314,15 +314,15 @@ def achar_janela(pid=None, titulo=None, termos=(), ativa=False, ignorar_pids=())
 # Elementos
 # ------------------------------------------------------------
 
-def _texto_do_no(no, papel):
+def _texto_do_no(no, papel, limite=LIMITE_CHARS_TEXTO):
     Atspi = _modulo()
     if papel in PAPEIS_CAMPO or papel in ("document-text", "paragraph"):
         try:
             if _nativo is not None:
-                return _nativo.texto(no)[:LIMITE_CHARS_TEXTO] or _nome(no)
+                return _nativo.texto(no)[:limite] or _nome(no)
             n = Atspi.Text.get_character_count(no)
             if n:
-                return Atspi.Text.get_text(no, 0, min(n, LIMITE_CHARS_TEXTO))
+                return Atspi.Text.get_text(no, 0, min(n, limite))
         except Exception:
             pass
     return _nome(no)
@@ -611,3 +611,51 @@ def preencher(janela, nome, texto):
     except Exception:
         pass
     return {"sucesso": False, "achou": True, "elemento": rotulo, "precisa_digitar": True}
+
+
+# ------------------------------------------------------------
+# 5.3 (F4+): ler o que a janela mostra, como texto, para perguntar sobre ela SEM imagem (o texto entra no mesmo contrato das
+# ações de texto). Nunca lê campo de senha e não guarda nada.
+# ------------------------------------------------------------
+LIMITE_TEXTO_JANELA = 6000        # caracteres, o mesmo corte das ações de texto
+LIMITE_CHARS_BLOCO = 1500         # um parágrafo ou campo; o resto do bloco é cortado
+
+
+def montar_texto_da_janela(blocos, botoes, limite=LIMITE_TEXTO_JANELA):
+    """Junta os blocos de texto da janela (na ordem de leitura, sem repetir) e, no fim, os nomes dos botões e links, para
+    perguntas como "onde clico para exportar?". Corta no limite."""
+    vistos, partes = set(), []
+    for bloco in blocos:
+        limpo = " ".join(str(bloco or "").split())
+        if limpo and limpo not in vistos:
+            vistos.add(limpo)
+            partes.append(limpo)
+    nomes = []
+    for nome in botoes:
+        limpo = " ".join(str(nome or "").split())[:60]
+        if limpo and limpo not in nomes:
+            nomes.append(limpo)
+    texto = "\n".join(partes)
+    if nomes:
+        texto += ("\n\n" if texto else "") + "Buttons and links: " + ", ".join(nomes[:60])
+    return texto[:limite]
+
+
+def texto_da_janela(pid=None, titulo=None, limite=LIMITE_TEXTO_JANELA):
+    """{"titulo", "app", "texto"} da janela pedida (ou da ativa, sem contar o próprio openTARS), lido pela acessibilidade; None
+    se não há acessibilidade, janela ou texto."""
+    if indisponivel():
+        return None
+    janela = achar_janela(pid=pid, titulo=titulo, ativa=not (pid or titulo), ignorar_pids=(os.getpid(),))
+    if not janela:
+        return None
+    blocos, botoes = [], []
+    for no, papel, nome, _estados, tipo in _itens(janela, forcar=True):
+        if "password" in papel:                     # campo de senha: nem o nome vira texto
+            continue
+        if tipo in ("texto", "campo"):
+            blocos.append(_texto_do_no(no, papel, LIMITE_CHARS_BLOCO))
+        elif tipo == "clicavel" and nome:
+            botoes.append(nome)
+    texto = montar_texto_da_janela(blocos, botoes, limite)
+    return {"titulo": janela["titulo"], "app": janela["app"], "texto": texto} if texto.strip() else None

app/tars_acoes_texto.py

@@ -18,6 +18,7 @@ import unicodedata
 import requests
 
 import tars_plataforma as plataforma
+import tars_motor as motor
 
 SISTEMA_ACAO_TEXTO = (
     "You are Gargantua, the AI of openTARS. You transform the text the user selected and answer with ONLY the result: "
@@ -37,6 +38,11 @@ INSTRUCOES = {
     "para_pt": {"pt_BR": "Traduza o texto para o português.", "en": "Translate the text into Portuguese."},
     "perguntar": {"pt_BR": "Responda à pergunta usando só o texto. Se o texto não trouxer a resposta, diga isso.",
                   "en": "Answer the question using only the text. If the text doesn't say, say so."},
+    "curto": {"pt_BR": "Reescreva o texto de forma mais curta, mantendo as informações importantes.",
+              "en": "Rewrite the text to be shorter, keeping the important information."},
+    "lista": {"pt_BR": "Transforme o texto em uma lista de tópicos curtos.", "en": "Turn the text into a list of short bullet points."},
+    "responder": {"pt_BR": "Escreva uma resposta curta e educada a esta mensagem, dizendo o que a linha Dizer pede.",
+                  "en": "Write a short, polite reply to this message that says what the Say line asks."},
 }
 
 LIMITE_TEXTO = 6000          # caracteres do trecho; mais que isso é cortado (e a janela avisa)
@@ -51,7 +57,8 @@ def pedido(acao, idioma, texto, pergunta=None):
     """A mensagem do usuário, no formato do treino."""
     instrucao = INSTRUCOES[acao][idioma if idioma in ("pt_BR", "en") else "en"]
     if pergunta:
-        instrucao += f"\n{'Pergunta' if idioma == 'pt_BR' else 'Question'}: {pergunta}"
+        rotulo = ("Dizer", "Say") if acao == "responder" else ("Pergunta", "Question")      # 5.3: responder mensagem
+        instrucao += f"\n{rotulo[0] if idioma == 'pt_BR' else rotulo[1]}: {pergunta}"
     return f"{instrucao}\n\n<texto>\n{texto}\n</texto>"
 
 
@@ -89,13 +96,15 @@ def rodar(acao, texto, modelo, host, pergunta=None, ao_pedaco=None, cancelar=Non
           manter=False):
     """Pede ao Ollama e devolve o texto inteiro; `ao_pedaco(trecho)` recebe a resposta enquanto chega. `manter`: o assistente
     está ligado, o modelo fica na memória só por 3 minutos depois do uso (keep_alive "3m") e sai sozinho."""
+    if cancelar and cancelar.is_set():      # a pessoa já trocou de opção: nem pede ao modelo (antes o pedido velho ainda saía)
+        return ""
     sessao = sessao or requests
     corpo = {"model": modelo, "stream": True, "think": False, "messages": mensagens(acao, texto, pergunta, padrao),
              "options": {"temperature": 0.1, "num_predict": 1200}}
     if manter:
         corpo["keep_alive"] = "3m"
     partes = []
-    with sessao.post(f"{host}/api/chat", json=corpo, stream=True, timeout=(5, 300)) as r:
+    with sessao.post(motor.url("conversa", host), json=corpo, stream=True, timeout=(5, 300)) as r:
         if r.status_code != 200:        # o Ollama explica no corpo ("model 'x' not found"); o status sozinho não diz nada
             try:
                 motivo = r.json().get("error")

app/tars_anexos.py

@@ -341,10 +341,6 @@ def montar_bloco(anexos, descricoes=None, limite_total=None):
     return "\n\n".join(partes)
 
 
-def imagens_b64(anexos):
-    return [a.imagem_b64 for a in anexos if a.tipo == "imagem" and a.imagem_b64]
-
-
 # ------------------------------------------------------------
 # Terminal: achar caminhos numa linha ("@arquivo", arrastar e soltar)
 # ------------------------------------------------------------
@@ -352,45 +348,6 @@ def imagens_b64(anexos):
 _ARROBA = re.compile(r"(?<!\S)@(\"[^\"]+\"|'[^']+'|\S+)")
 
 
-def separar_arrobas(linha):
-    """'resuma @notas.txt e @"meu doc.pdf"' -> ('resuma e', ['notas.txt', 'meu doc.pdf']),
-    só dos '@caminho' que existem de fato (o resto continua no texto)."""
-    achados = []
-
-    def troca(m):
-        bruto = m.group(1)
-        if bruto[0] in "\"'" and bruto[-1] == bruto[0]:
-            bruto = bruto[1:-1]
-        if bruto and _existe(normalizar_caminho(bruto)):
-            achados.append(bruto)
-            return ""
-        return m.group(0)
-
-    texto = _ARROBA.sub(troca, linha)
-    return re.sub(r"\s{2,}", " ", texto).strip(), achados
-
-
-def linha_e_so_caminho(linha):
-    """Quem arrasta um arquivo pro terminal cola só o caminho: se a linha
-    inteira (com ou sem aspas) é um arquivo/pasta que existe, devolve-o."""
-    t = str(linha or "").strip()
-    if not t or "\n" in t or len(t) > 1000:
-        return None
-    candidatos = [t]
-    # vários arrastados de uma vez: 'a.png' 'b.txt'
-    entre_aspas = re.findall(r"'([^']+)'|\"([^\"]+)\"", t)
-    if len(entre_aspas) > 1 and not re.sub(r"'[^']*'|\"[^\"]*\"|\s+", "", t):
-        candidatos = [a or b for a, b in entre_aspas]
-    caminhos = []
-    for c in candidatos:
-        if not (c.startswith(("/", "~", "file://", "'", '"', ".")) or ambiente.parece_caminho_windows(c)):
-            return None
-        p = normalizar_caminho(c)
-        if not _existe(p):
-            return None
-        caminhos.append(c)
-    return caminhos
-
 # ------------------------------------------------------------
 # Imagens citadas no texto do pedido ("veja home/pictures/foto.png")
 # ------------------------------------------------------------

app/tars_assistente.py

@@ -14,6 +14,7 @@ import requests
 
 import tars_i18n as i18n
 import tars_plataforma as plataforma
+import tars_motor as motor
 
 NOME_AUTOSTART = "opentars-assistente"
 
@@ -27,7 +28,7 @@ KEEP_ALIVE_OCIOSO = "3m"       # quanto o modelo do assistente fica na memória
 
 def manter_carregado(host, modelo, carregar, sessao=None):
     """Um pedido sem prompt carrega o modelo por KEEP_ALIVE_OCIOSO (e o Ollama descarrega sozinho) ou descarrega já (0)."""
-    r = (sessao or requests).post(f"{host}/api/generate", json={"model": modelo, "keep_alive": KEEP_ALIVE_OCIOSO if carregar else 0},
+    r = (sessao or requests).post(motor.url("gerar", host), json={"model": modelo, "keep_alive": KEEP_ALIVE_OCIOSO if carregar else 0},
                                   timeout=(5, 180))
     if r.status_code != 200:
         try:

app/tars_atalhos.py

@@ -0,0 +1,316 @@
+"""O que o assistente resolve sem o modelo (F4 do PLANO_5.3.md, 07/11): vem das camadas do openTARS Pi, onde levaram a prova
+de 19 para 30 de 40 tarefas inéditas, e modelos maiores não ganharam do pequeno depois disso.
+
+- estado do computador com avaliação ("está tranquilo") e capacidade ("cabe um arquivo de 10 GB?");
+- memória: "guarda que...", "esquece...", "o que você sabe de mim?";
+- contas;
+- operações de arquivo com os nomes ligados ao disco e a resposta em palavras (tars_operacoes, tars_nomes);
+- pedidos de vários passos (tars_passos);
+- perguntas sobre o mundo respondidas por um resultado do SearXNG, com o site (tars_resposta_web).
+
+resolver() devolve o texto da resposta, ou None: aí o pedido segue para o modelo, como antes. Os comandos passam por
+executar_ferramenta, então valem as mesmas regras de segurança e o mesmo cartão de aprovação do resto do app.
+As operações de arquivo só valem no Linux (os comandos são de bash e GNU); no Windows e no macOS o modelo continua com elas.
+"""
+import os
+import re
+import shlex
+import time
+import unicodedata
+
+import tars_conta
+import tars_email
+import tars_integracoes
+import tars_lembretes
+import tars_midia
+import tars_operacoes as operacoes
+import tars_passos as passos
+import tars_regras_terminal as regras_terminal
+import tars_sistema_frases as sistema_frases
+import tars_resposta_web as resposta_web
+from tars_atalhos_textos import t
+
+_MARCAS_PT = re.compile(r"[ãõçáéíóúâêô]|\b(o|os|as|um|uma|de|do|da|que|qual|quanto|quanta|quem|como|onde|por|para|pra|meu|minha|tem|tenho|e|é|cria|faz|lembra|esquece|"
+                        r"em|no|na|foi|isso|voce|você|eu|quando|sim|não|nao|tá|ta|está|esta|mostra|apaga|copia|move|abre)\b", re.IGNORECASE)
+_MARCAS_EN = re.compile(r"\b(the|an|of|what|which|who|how|where|is|are|my|me|do|does|can|please|create|make|remember|forget|search|and|in|to|when|did|was|"
+                        r"were|has|have|it|this|that|you|your|i|show|delete|copy|move|open|file|folder)\b", re.IGNORECASE)
+
+
+def idioma_do(texto):
+    pt, en = len(_MARCAS_PT.findall(texto)), len(_MARCAS_EN.findall(texto))
+    return "en" if en > pt else "pt"
+
+
+def normalizar(texto):
+    return "".join(c for c in unicodedata.normalize("NFKD", texto) if not unicodedata.combining(c)).lower().strip()
+
+
+# ---------------- estado do computador ----------------
+_DA_ASSISTENTE = re.compile(r"\b(sua memoria|your memory|na memoria|da memoria|in memory|from memory|to memory|de mim|about me)\b")
+_MEMORIA = re.compile(r"\b(ram|memoria|memory)\b")
+_QUANTO = re.compile(r"\b(quanta|quanto|livre|disponivel|sobrando|sobrou|usada|uso|usando|how much|free|usage|used|left|available)\b")
+_AVALIA = re.compile(r"\b(acabando|acabou|cheia|cheio|lotad[oa]|pouca|pouco|suficiente|enough|running out|low|full|tranquil\w*|apertad[oa]|limite|limit|"
+                     r"sobrecarregad[oa]|ocupad[oa]|busy|pesad[oa]|heavy|alta|alto|high|ok|bem|fine|aguenta|aguentando|handle|almost|quase)\b")
+_DISCO = re.compile(r"\b(disco|disk|armazenamento|storage|ssd|hd|espaco livre|espaco no|espaco em disco|free space|drive)\b")
+_TAMANHO = re.compile(r"(\d+(?:[.,]\d+)?)\s*(tb|gb|g|giga\w*|mb|m|mega\w*|kb)\b")
+_CABE = re.compile(r"\b(da pra|da para|cabe|caberia|cabem|consigo|posso|tem espaco|tem lugar|sobra espaco|is there (?:enough )?(?:room|space|memory)|"
+                   r"enough (?:space|room|memory|ram)|can i (?:download|fit|store|save|run|keep|open)|fits?|would fit|aguenta|can it (?:run|handle))\b")
+_USA_RAM = re.compile(r"\b(ram|memoria|memory|rodar|roda|run|running|abrir|open|programa|program|processo|process|app|aplicativo|servico|service|jogo|game)\b")
+_CPU = re.compile(r"\b(uso|carga|usage|load|busy|ocupad[oa])\b.{0,15}\b(cpu|processador|processor)\b|\b(cpu|processador|processor)\b.{0,20}"
+                  r"\b(uso|carga|usage|load|ocupad[oa]|busy|sobrecarregad[oa]|pesad[oa]|aguenta\w*)\b|\b(quantos nucleos|how many (cpu )?cores)\b")
+_LIGADO = re.compile(r"\buptime\b|\b(ha )?quanto tempo\b.{0,30}\b(ligad|rodando)|\bhow long\b.{0,30}\b(running|been on|been up|up)\b")
+_DE_PROCESSO = re.compile(r"\b(processos?|process(es)?|programas?|apps?|aplicativos?|quem esta|what'?s|whats|which program|o que esta)\b.{0,30}"
+                          r"\b(usando|comendo|gastando|consumindo|using|eating|hogging|taking)\b")
+
+
+def _folga(livre, total, idioma):
+    parte = livre / total if total else 1
+    return t("folga_boa" if parte > 0.3 else "folga_media" if parte > 0.1 else "folga_pouca", idioma)
+
+
+def _memoria_mb():
+    import psutil
+    m = psutil.virtual_memory()
+    return m.total // 2**20, m.available // 2**20       # disponível, não a coluna "free" (o cache conta como livre)
+
+
+def _disco_gb():
+    import shutil
+    d = shutil.disk_usage(os.path.expanduser("~"))
+    return d.total / 1e9, d.free / 1e9
+
+
+def estado(n, idioma):
+    if _DA_ASSISTENTE.search(n) or _DE_PROCESSO.search(n):
+        return None
+    tamanho = _TAMANHO.search(n)
+    if tamanho and _CABE.search(n):
+        valor = float(tamanho.group(1).replace(",", "."))
+        mb = valor * {"t": 1024 * 1024, "g": 1024, "m": 1, "k": 1 / 1024}[tamanho.group(2)[0]]
+        pedido = f"{tamanho.group(1)} {tamanho.group(2).upper()}"
+        if _USA_RAM.search(n) and not re.search(r"\b(baixar|download|salvar|save|guardar|store|disco|disk|arquivo|file)\b", n):
+            total, livre = _memoria_mb()
+            return t("cabe_ram" if mb < livre * 0.9 else "nao_cabe_ram", idioma, livre=livre, pedido=pedido)
+        total, livre = _disco_gb()
+        return t("cabe_disco" if mb < livre * 1000 * 0.95 else "nao_cabe_disco", idioma, livre=livre, pedido=pedido)
+    if _MEMORIA.search(n) and (_QUANTO.search(n) or _AVALIA.search(n)):
+        total, livre = _memoria_mb()
+        texto = t("mem", idioma, total=total, livre=livre, usada=total - livre)
+        return texto + " " + _folga(livre, total, idioma) if _AVALIA.search(n) else texto
+    if _DISCO.search(n) and (_QUANTO.search(n) or _AVALIA.search(n) or re.search(r"\b(espaco|space)\b", n)):
+        total, livre = _disco_gb()
+        texto = t("disco", idioma, total=total, livre=livre, usado=total - livre)
+        return texto + " " + _folga(livre, total, idioma) if _AVALIA.search(n) else texto
+    if _CPU.search(n):
+        import psutil
+        nucleos, carga = os.cpu_count() or 1, psutil.getloadavg()[0]      # os.getloadavg não existe no Windows
+        return t("cpu", idioma, nucleos=nucleos, carga=carga) + " " + t("cpu_folga" if carga < 0.7 * nucleos else "cpu_media" if carga < nucleos else "cpu_cheia", idioma)
+    if _LIGADO.search(n):
+        import psutil
+        segundos = int(time.time() - psutil.boot_time())
+        dias, resto = divmod(segundos, 86400)
+        horas, minutos = resto // 3600, resto % 3600 // 60
+        return t("ligada", idioma, tempo=" ".join(p for p in (f"{dias} d" if dias else "", f"{horas} h" if horas else "", f"{minutos} min") if p))
+    return None
+
+
+# ---------------- memória da pessoa ----------------
+_POLIDEZ = r"^(por favor,? |please,? |pode |voce pode |can you |could you |from now on,? |a partir de agora,? )?"
+# 13/11 (revisão): "salva/grava/guarda/save" também querem dizer salvar um arquivo ou gravar a tela ("salva meu arquivo na pasta X"
+# virava um fato na memória); esses só valem com "que", "that", ":" ou "na memória". Os que só querem dizer lembrar aceitam "meu/my" direto.
+_LEMBRAR = re.compile(_POLIDEZ + r"(?:(lembra|lembre|anota|anote|memoriza|memorize|nao esquece|nao esqueca|remember|keep in mind|don'?t forget|"
+                      r"jot down|make a note)\b( ai| isso| disso| this| na memoria| to memory)?( que| that|:|(?= (my|meu|minha|eu|i)\b))|"
+                      r"(grava|grave|guarda|guarde|salva|salve|save|note|write down)\b(( ai| isso| this)? (na memoria|to memory|in memory))?"
+                      r"( ai| isso| this)?( que| that|:))\s*")
+_LEMBRAR_NO_FIM = re.compile(r"^(.+?)[,.]?\s+(keep that|remember that|remember this|guarda isso|lembra disso|anota isso|anota ai)[.!]?$")
+_ESQUECER_TUDO = re.compile(r"^(esquece|esqueca|forget)\s+(tudo|everything)( que voce sabe( sobre mim)?| about me| you know( about me)?)?[.!]*$|"
+                            r"\b(apaga|apague|limpa|limpe|zera|clear|wipe|erase|reset)\s+(toda |a |sua |your |the |all )*(memoria|memory)\b")
+_ESQUECER = re.compile(_POLIDEZ + r"(esquece|esqueca|esquecer|forget)\b\s*(isso|that)?\s*(d[aeo]s?|que|about|sobre)?\s*(?P<alvo>.*)$")
+_VER_MEMORIA = re.compile(r"\bo que (voce )?(lembra|guardou|sabe) (de|sobre) mim\b|\bwhat do you (remember|know)( about me)?\b|"
+                          r"\b(mostra|mostre|show)( a| your)? (sua )?(memoria|memory)\b")
+_VAZIAS = {"o", "a", "os", "as", "de", "do", "da", "que", "eu", "meu", "minha", "the", "of", "my", "i", "that", "isso", "about", "sobre", "is", "e"}
+
+
+def memoria(pedido, n, idioma, core):
+    mem = core.memoria
+    if _VER_MEMORIA.search(n):
+        fatos = mem.listar()
+        return t("memoria", idioma, fatos="\n".join("- " + f for f in fatos)) if fatos else t("memoria_vazia", idioma)
+    if _ESQUECER_TUDO.search(n):
+        mem.esquecer("*")
+        return t("esqueci_tudo", idioma)
+    achado = _LEMBRAR.search(n) or None
+    if achado:
+        fato = pedido.strip()[achado.end():].strip(" .") if len(pedido.strip()) == len(n) else n[achado.end():].strip(" .")
+        ok, _ = mem.lembrar(fato) if fato else (False, None)
+        return t("anotado", idioma, fato=fato) if ok else None
+    achado = _LEMBRAR_NO_FIM.search(n)
+    if achado:
+        fato = (pedido.strip() if len(pedido.strip()) == len(n) else n)[:achado.end(1)]
+        ok, _ = mem.lembrar(fato)
+        return t("anotado", idioma, fato=fato) if ok else None
+    achado = _ESQUECER.search(n)
+    if achado and achado.group("alvo"):
+        palavras = [p for p in re.findall(r"[\w-]+", achado.group("alvo")) if p not in _VAZIAS and len(p) > 2]
+        fatos = mem.listar()
+        notas = [(sum(normalizar(p) in normalizar(f) for p in palavras), f) for f in fatos]
+        melhor = max((x for x, _ in notas), default=0)
+        if not melhor:
+            return t("nada_guardado", idioma)
+        saiu = [f for x, f in notas if x == melhor]
+        for f in saiu:
+            mem.esquecer(f)
+        return t("esqueci", idioma, fato="; ".join(saiu))
+    return None
+
+
+# ---------------- comandos (operações de arquivo) ----------------
+def _rodar(core, comando):
+    """O resultado no formato que tars_operacoes.resumir lê (o do openTARS Pi)."""
+    r = core.executar_ferramenta("execute_terminal", {"command": comando})
+    r = r if isinstance(r, dict) else {}
+    return {"success": bool(r.get("sucesso")), "exit_code": r.get("codigo"), "stdout": r.get("stdout") or "",
+            "stderr": r.get("stderr") or "", "message": r.get("mensagem") or ""}
+
+
+def _com_saida(texto, saida):
+    linhas = [l for l in (saida or "").rstrip().splitlines()][:40]
+    bloco = "```\n" + "\n".join(linhas) + "\n```" if linhas else ""
+    return "\n\n".join(p for p in (texto, bloco) if p)
+
+
+def comando(plano, idioma, core, estado_passos):
+    """Roda o comando de uma operação e devolve (resposta, deu_certo)."""
+    r = _rodar(core, plano["comando"])
+    estado_passos["resultado"], estado_passos["comando"] = r, plano["comando"]
+    if "did not confirm" in r["message"] or "cancelled by the user" in r["message"].lower():
+        return t("negado", idioma), False           # a pessoa disse não: sem o texto em inglês do controle
+    nada_achado = plano.get("resumo") in ("ocorrencias", "arquivos_com") and r["exit_code"] == 1 and not r["stderr"].strip()
+    if not r["success"] and not nada_achado:
+        erro = (r["stderr"] or r["message"] or "?").strip().splitlines()
+        return t("falhou", idioma, erro=erro[-1] if erro else "?"), False
+    if plano.get("lugar"):
+        estado_passos["lugar"] = plano["lugar"]
+    elif plano["comando"].startswith("mkdir -p ") and "&&" not in plano["comando"]:
+        estado_passos["lugar"] = shlex.split(plano["comando"])[-1]          # a pasta criada vira o "ela" do passo seguinte
+    if plano.get("alvo"):
+        estado_passos["alvo"] = plano["alvo"]
+    resumo = operacoes.resumir(plano, r, idioma)
+    if resumo:
+        return " ".join(p for p in (plano.get("nota"), resumo) if p), True
+    if not r["stdout"].strip():
+        return " ".join(p for p in (plano.get("nota"), plano.get("feito") or t("feito", idioma)) if p), True
+    return _com_saida(plano.get("nota") or "", r["stdout"]), True
+
+
+def _plano(pedido, n, idioma, linux):
+    if not linux:
+        return None
+    p = operacoes.plano(pedido, n, idioma) or regras_terminal.plano(pedido, n, idioma)
+    return {"comando": p} if isinstance(p, str) else p
+
+
+def _uma_parte(pedido, idioma, core, estado_passos, linux, permitir_mundo=True):
+    """(resposta, deu_certo) de uma frase, ou None se é com o modelo."""
+    import tars_plataforma
+    n = normalizar(pedido)
+    fala = (tars_lembretes.resposta_da_rotina(pedido) or tars_lembretes.agendar(pedido, idioma) or tars_integracoes.responder(pedido, idioma)
+            or tars_midia.responder(pedido, idioma)
+            or tars_email.responder(pedido, idioma, core)
+            or memoria(pedido, n, idioma, core))
+    if fala:
+        return fala, True
+    if not linux:                    # 5.3: Windows e macOS: as mesmas frases, executadas direto (volume, brilho, tema, Wi-Fi, bloquear)
+        fala = sistema_frases.responder_outros(n, idioma, tars_plataforma.sistema(), core)
+        if fala:
+            return fala, True
+    plano = sistema_frases.plano(n, idioma) if linux else None
+    plano = plano or _plano(pedido, n, idioma, linux)
+    if plano:
+        if "fala" in plano:
+            return plano["fala"], True
+        return comando(plano, idioma, core, estado_passos)
+    fala = estado(n, idioma) or tars_conta.resolver(n, idioma)
+    if fala:
+        return fala, True
+    if permitir_mundo:
+        fala = mundo(pedido, n, idioma)
+        if fala:
+            return fala, True
+    return None
+
+
+# ---------------- perguntas sobre o mundo ----------------
+_PERGUNTA = re.compile(r"^(quem|qual|quais|quando|onde|quanto|quanta|quantos|quantas|em que ano|o que e|o que foi|what|who|which|when|where|how (tall|far|high|long|big|many|much|old)|"
+                       r"in what year|what year)\b")
+_PESSOAL = re.compile(r"\b(voce|seu|sua|you|your|eu|meu|minha|meus|minhas|me|mim|my|i|computador|computer|pc|arquivo|arquivos|file|files|pasta|folder|disco|disk|"
+                      r"memoria|memory|ram|cpu|processador|processor|wifi|internet|placa|ip|senha|password|lembr|remind|timer|alarme|alarm)\b")
+
+
+def mundo(pedido, n, idioma):
+    """Uma frase de um resultado do SearXNG que responde, com o site. None: sem SearXNG ligado, sem resultado bom, ou não é pergunta sobre o mundo."""
+    if not _PERGUNTA.search(n) or _PESSOAL.search(n):
+        return None
+    try:
+        import tars_web
+        if not tars_web.config()["ligada"]:
+            return None
+        achado = resposta_web.responder(pedido.strip(" ?"))
+    except Exception:  # noqa: BLE001 - sem busca, o modelo responde como antes
+        return None
+    if not achado:
+        return None
+    import urllib.parse
+    site = urllib.parse.urlsplit(achado["url"]).hostname or achado["url"]
+    return t("de_onde", idioma, site=site, trecho=achado["trecho"])
+
+
+# ---------------- entrada ----------------
+def resolver(texto, core):
+    """A resposta sem o modelo, ou None. core: o módulo tars (memória, executar_ferramenta)."""
+    texto = (texto or "").strip()
+    if not texto or len(texto) > 400 or os.environ.get("TARS_SEM_ATALHOS"):
+        return None
+    import tars_plataforma
+    linux = tars_plataforma.sistema() == "linux"
+    idioma = idioma_do(texto)
+    estado_passos = {"lugar": None, "resultado": None, "comando": None, "alvo": None}
+    partes = passos.dividir(texto, normalizar(texto))
+    if partes:
+        falas = []
+        for i, parte in enumerate(partes):
+            n = normalizar(parte)
+            if i and passos.pede_contagem(n) and estado_passos["resultado"]:
+                saida = estado_passos["resultado"].get("stdout") or ""
+                quantos = len([l for l in saida.splitlines() if l.strip()])
+                falas.append(t("r_e_um", idioma) if quantos == 1 else t("r_sao", idioma, n=quantos))
+                continue
+            destino = passos.salvar_em(n) if i else None
+            if destino:
+                anterior = estado_passos["comando"] if (estado_passos["resultado"] or {}).get("success") else None
+                if not anterior or not linux:
+                    if i == 1 and not falas:
+                        return None
+                    falas.append(t("nada_para_salvar", idioma))
+                    break
+                comeco = n.rfind(destino)
+                destino = parte[comeco:comeco + len(destino)] if comeco >= 0 else destino
+                resposta, ok = comando({"comando": f"{anterior} > {operacoes._q(destino)}"}, idioma, core, estado_passos)
+            else:
+                parte = passos.com_lugar(parte, estado_passos["lugar"]) if i else parte
+                feito = _uma_parte(parte, idioma, core, estado_passos, linux, permitir_mundo=False)
+                if feito is None and i and estado_passos["alvo"]:
+                    feito = _uma_parte(f"{parte} {'de' if idioma == 'pt' else 'of'} {estado_passos['alvo']}", idioma, core, estado_passos, linux, False)
+                if feito is None:
+                    if i == 0:
+                        return None          # o primeiro passo não é de regra: o pedido inteiro vai para o modelo
+                    falas.append(t("falhou", idioma, erro=parte))
+                    break
+                resposta, ok = feito
+            if resposta and (not falas or resposta != falas[-1]):
+                falas.append(resposta)
+            if not ok:
+                break
+        return "\n".join(falas) if falas else None
+    feito = _uma_parte(texto, idioma, core, estado_passos, linux)
+    return feito[0] if feito else None

app/tars_atalhos_textos.py

@@ -0,0 +1,114 @@
+"""As frases das respostas que saem sem o modelo (tars_atalhos, tars_operacoes), em pt e en: a resposta segue o idioma do pedido.
+Vieram do openTARS Pi (opentars_pi/textos.py) em 07/11; "mem" fala da memória disponível, não da coluna "free" do `free`."""
+
+TEXTOS = {'pt': {'r_e_um': 'É só 1.','htop_falta': 'O htop não está instalado (sudo apt install htop). Mostrando o top:','achei_em': '(Achei em {real}.)',
+        'nome_corrigido': '(Não existe {pedido}; usei {real}.)',
+        'nao_achei_arquivo': 'Não achei {nome} aqui.',
+        'nao_achei_arquivo_sugestao': 'Não achei {nome}. Você quis dizer: {sugestoes}?',
+        'apagar_parecido': 'Não existe {nome}. Você quis dizer {real}? Se for, diga: apaga {real}',
+        'nenhum_tipo': 'Não há arquivos desse tipo em {pasta}.',
+        'nao_instalado': 'O {programa} não está instalado. Para instalar: sudo apt install {pacote}',
+        'r_linhas': '{alvo} tem {n} linhas.',
+        'r_ocorrencias': '"{termo}" aparece {n} vezes em {alvo}.',
+        'r_arquivos': '{alvo} tem {n} arquivos.',
+        'r_nenhum_arquivo': 'Nenhum arquivo aqui fala de "{termo}".',
+        'r_esta_em': 'Está em: {lista}',
+        'r_maior': 'O maior arquivo de {alvo} é {nome} ({tamanho}).',
+        'r_menor': 'O menor arquivo de {alvo} é {nome} ({tamanho}).',
+        'r_tamanho': '{alvo} ocupa {tamanho}.',
+        'r_achados': 'Achei {n} em {alvo}.',
+        'r_nada_achado': 'Nada assim em {alvo}.',
+        'r_sao': 'São {n}.',
+        'r_loc': '{alvo} tem {n} linhas de código.',
+        'mem': '{livre} MB de memória disponíveis, de {total} MB ({usada} MB em uso).',
+        'disco': '{usado:.1f} GB usados no disco, {livre:.1f} GB livres, de {total:.1f} GB.',
+        'temp': 'A placa está a {temp:.0f} °C.',
+        'sem_temp': 'Esta placa não tem um sensor de temperatura que eu consiga ler.',
+        'ligada': 'Ligada há {tempo}.',
+        'cpu': '{nucleos} núcleos, carga {carga:.2f}.',
+        'processador': 'O processador é um {nome}, com {nucleos} núcleos.',
+        'folga_boa': 'Está tranquilo.',
+        'folga_media': 'Ainda dá, mas está apertando.',
+        'folga_pouca': 'Está apertado: vale liberar espaço.',
+        'cabe_disco': 'Sim: o disco tem {livre:.1f} GB livres, então {pedido} cabem.',
+        'nao_cabe_disco': 'Não: o disco tem só {livre:.1f} GB livres, não cabem {pedido}.',
+        'cabe_ram': 'Sim: há {livre} MB de memória livres, então {pedido} cabem.',
+        'nao_cabe_ram': 'Não: só há {livre} MB de memória livres, não cabem {pedido}.',
+        'temp_ok': 'Está normal.',
+        'temp_morna': 'Está morna, mas dentro do limite.',
+        'temp_quente': 'Está quente: vale olhar a ventilação.',
+        'cpu_folga': 'Está folgado.',
+        'cpu_media': 'Está ocupado, mas dando conta.',
+        'cpu_cheia': 'Está sobrecarregado agora.',
+        'anotado': 'Anotado: {fato}.',
+        'esqueci': 'Esquecido: {fato}.',
+        'esqueci_tudo': 'Pronto, minha memória está vazia.',
+        'nada_guardado': 'Não tenho nada guardado sobre isso.',
+        'memoria': 'Isto é o que eu lembro:\n{fatos}',
+        'memoria_vazia': 'Minha memória está vazia.',
+        'lembro': 'Você me disse: {fato}.',
+        'feito': 'Pronto.',
+        'falhou': 'Não deu certo: {erro}',
+        'negado': 'Certo, não rodei.',
+        'de_onde': 'Segundo {site}: {trecho}',
+        'tambem': 'Também: {site} ({titulo})',
+        'nao_achei': 'Não achei uma boa resposta. O mais perto que encontrei: {titulo} ({site}).',
+        'nada_para_salvar': 'Não tenho o que salvar do passo anterior.'},
+ 'en': {'r_e_um': 'Just 1.','htop_falta': 'htop is not installed (sudo apt install htop). Here is top instead:','achei_em': '(Found it at {real}.)',
+        'nome_corrigido': '(There is no {pedido}; I used {real}.)',
+        'nao_achei_arquivo': 'I could not find {nome} here.',
+        'nao_achei_arquivo_sugestao': 'I could not find {nome}. Did you mean: {sugestoes}?',
+        'apagar_parecido': 'There is no {nome}. Did you mean {real}? If so, say: delete {real}',
+        'nenhum_tipo': 'There are no files of that kind in {pasta}.',
+        'nao_instalado': '{programa} is not installed. Install it with: sudo apt install {pacote}',
+        'r_linhas': '{alvo} has {n} lines.',
+        'r_ocorrencias': '"{termo}" appears {n} times in {alvo}.',
+        'r_arquivos': '{alvo} has {n} files.',
+        'r_nenhum_arquivo': 'No file here mentions "{termo}".',
+        'r_esta_em': 'It is in: {lista}',
+        'r_maior': 'The biggest file in {alvo} is {nome} ({tamanho}).',
+        'r_menor': 'The smallest file in {alvo} is {nome} ({tamanho}).',
+        'r_tamanho': '{alvo} takes up {tamanho}.',
+        'r_achados': 'Found {n} in {alvo}.',
+        'r_nada_achado': 'Nothing like that in {alvo}.',
+        'r_sao': 'That makes {n}.',
+        'r_loc': '{alvo} has {n} lines of code.',
+        'mem': '{livre} MB of memory available, out of {total} MB ({usada} MB in use).',
+        'disco': '{usado:.1f} GB used on the disk, {livre:.1f} GB free, out of {total:.1f} GB.',
+        'temp': 'The board is at {temp:.0f} °C.',
+        'sem_temp': 'This board has no temperature sensor I can read.',
+        'ligada': 'Running for {tempo}.',
+        'cpu': '{nucleos} cores, load {carga:.2f}.',
+        'processador': 'The processor is a {nome}, with {nucleos} cores.',
+        'folga_boa': 'Plenty of room.',
+        'folga_media': 'Still fine, but getting tighter.',
+        'folga_pouca': 'That is tight: worth freeing some up.',
+        'cabe_disco': 'Yes: the disk has {livre:.1f} GB free, so {pedido} fits.',
+        'nao_cabe_disco': 'No: the disk has only {livre:.1f} GB free, not enough for {pedido}.',
+        'cabe_ram': 'Yes: {livre} MB of memory are free, so {pedido} fits.',
+        'nao_cabe_ram': 'No: only {livre} MB of memory are free, not enough for {pedido}.',
+        'temp_ok': 'That is normal.',
+        'temp_morna': 'Warm, but within limits.',
+        'temp_quente': 'That is hot: check the cooling.',
+        'cpu_folga': 'It is relaxed.',
+        'cpu_media': 'Busy, but coping.',
+        'cpu_cheia': 'It is overloaded right now.',
+        'anotado': 'Noted: {fato}.',
+        'esqueci': 'Forgotten: {fato}.',
+        'esqueci_tudo': 'Done, my memory is empty now.',
+        'nada_guardado': 'I have nothing saved about that.',
+        'memoria': 'Here is what I remember:\n{fatos}',
+        'memoria_vazia': 'My memory is empty.',
+        'lembro': 'You told me: {fato}.',
+        'feito': 'Done.',
+        'falhou': 'That did not work: {erro}',
+        'negado': 'Okay, I did not run it.',
+        'de_onde': 'From {site}: {trecho}',
+        'tambem': 'Also: {site} ({titulo})',
+        'nao_achei': 'I could not find a good answer. The closest I found: {titulo} ({site}).',
+        'nada_para_salvar': 'I have nothing to save from the step before.'}}
+
+
+def t(chave, idioma, **campos):
+    texto = TEXTOS["pt" if str(idioma).startswith("pt") else "en"][chave]
+    return texto.format(**campos) if campos else texto

app/tars_atualizacao.py

@@ -58,6 +58,16 @@ def pelo_script():
     return plataforma.sistema() != "linux" or MARCA_SCRIPT.exists()
 
 
+def argumentos_um_clique(sistema=None):
+    """5.3 (F5): o "Atualizar" de quem instalou por script roda o próprio instalador. No Windows abre o PowerShell visível (o
+    instalador fecha o app aberto e o reabre no fim); no macOS e nos outros Linux o script roda escondido e o app reinicia."""
+    sistema = sistema or plataforma.sistema()
+    if sistema == "windows":
+        reabrir = '; & (Join-Path $env:LOCALAPPDATA "openTARS\\bin\\opentars-gui.cmd")'
+        return ["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", COMANDO_REINSTALAR["windows"] + reabrir]
+    return ["bash", "-c", "set -o pipefail; " + COMANDO_REINSTALAR[sistema]]
+
+
 def versao_publicada(agora=None, buscar=None, cache=None):
     """A versão publicada (do cache de até 24 h, ou buscada agora), ou None."""
     if _desligado():
@@ -153,21 +163,47 @@ def _estado_arquivo():
     return Path(os.environ.get("TARS_ARQUIVO_ATUALIZACAO") or os.path.expanduser("~/.config/opentars/atualizacao.json"))
 
 
-def marcar_instalada(sha256):
-    """Guarda o hash do arquivo que o usuário instalou por aqui (para não oferecer o mesmo de novo)."""
+def marcar_instalada(*ids):
+    """Guarda os identificadores do arquivo que o usuário instalou por aqui (para não oferecer o mesmo de novo). O mesmo .deb
+    chega por dois caminhos, o upload no repositório (hash git) e a Release (SHA-256); guardando só um, o outro caminho achava
+    o arquivo "novo" e oferecia a atualização para sempre (10/11), então vão todos."""
+    ids = [str(i).lower() for i in ids if i]
     try:
         arq = _estado_arquivo()
         arq.parent.mkdir(parents=True, exist_ok=True)
-        arq.write_text(json.dumps({"sha256": str(sha256).lower()}), encoding="utf-8")
+        arq.write_text(json.dumps({"sha256": ids[0] if ids else "", "ids": sorted(set(ids))}), encoding="utf-8")
     except Exception:
         pass
 
 
+def ids_do_arquivo(caminho):
+    """[sha256, hash git] de um arquivo, os dois identificadores com que ele aparece no GitHub; [] se não der para ler."""
+    try:
+        dados = Path(caminho).read_bytes()
+    except Exception:
+        return []
+    return [hashlib.sha256(dados).hexdigest(), hashlib.sha1(b"blob %d\0" % len(dados) + dados).hexdigest()]
+
+
 def _ultima_instalada():
+    """Os identificadores já instalados (conjunto)."""
     try:
-        return str(json.loads(_estado_arquivo().read_text(encoding="utf-8")).get("sha256") or "")
+        dados = json.loads(_estado_arquivo().read_text(encoding="utf-8"))
     except Exception:
-        return ""
+        return set()
+    ids = {str(i).lower() for i in dados.get("ids") or []}
+    if dados.get("sha256"):
+        ids.add(str(dados["sha256"]).lower())
+    return ids
+
+
+def _ids_instalados(valor):
+    """`valor` None = o que está guardado; texto ou lista = o que o chamador (os testes) passou."""
+    if valor is None:
+        return _ultima_instalada()
+    if isinstance(valor, str):
+        return {valor.lower()} if valor else set()
+    return {str(i).lower() for i in valor if i}
 
 
 def _epoch(iso):
@@ -238,8 +274,7 @@ def procurar_no_repositorio(obter_json=None, extras=(), compilado=None, ultima=N
     blob = str(arq.get("sha") or "").lower()
     if not url or not host_permitido(url, extras) or not re.fullmatch(r"[0-9a-f]{40}", blob):
         return None
-    instalada = _ultima_instalada() if ultima is None else ultima
-    if blob == instalada:
+    if blob in _ids_instalados(ultima):
         return None
     try:
         commits = obter_json(URL_COMMITS + "&path=" + quote(str(arq.get("name"))))
@@ -297,7 +332,7 @@ def procurar_em_release(versao_local, obter_json=None, obter_texto=None, extras=
         except Exception:
             somas = {}
     meu_pacote = compilado_em() if compilado is None else compilado
-    instalada = _ultima_instalada() if ultima is None else ultima
+    instaladas = _ids_instalados(ultima)
     arquivos, mais_recente = {}, 0.0
     for nome, a in ativos.items():
         tipo = "appimage" if str(nome).endswith(".AppImage") else "deb" if str(nome).endswith(".deb") else None
@@ -309,7 +344,7 @@ def procurar_em_release(versao_local, obter_json=None, obter_texto=None, extras=
             continue
         enviado = _epoch(a.get("created_at") or a.get("updated_at"))
         novo = (nova_versao > local) or (enviado > meu_pacote + 60)
-        if novo and sha != instalada:
+        if novo and sha not in instaladas:
             arquivos[tipo] = {"nome": nome, "url": url, "sha256": sha, "id": sha}
             mais_recente = max(mais_recente, enviado)
     if not arquivos:

app/tars_autoteste.py

@@ -64,7 +64,7 @@ class _Relatorio:
 
 def _versao_ollama(core):
     try:
-        r = core._SESSION.get(f"{core.OLLAMA_HOST}/api/version", timeout=core.TIMEOUT_HTTP_CURTO)
+        r = core._SESSION.get(core.motor_lib.url("versao", core.OLLAMA_HOST), timeout=core.TIMEOUT_HTTP_CURTO)
         return r.json().get("version") if r.status_code == 200 else None
     except Exception:
         return None

app/tars_busca_arquivos.py

@@ -6,12 +6,16 @@ Só leitura: não abre, não move, não apaga. Igual nos três sistemas; só bib
 import os
 import re
 import shutil
+import sqlite3
 import subprocess
 import time
 import unicodedata
 import zipfile
 from pathlib import Path
 
+import tars_i18n
+import tars_plataforma as plataforma
+
 VAZIAS = set("""o a os as um uma uns umas de da do das dos e em no na nos nas para pra por com que meu minha meus minhas
 onde esta está esse essa este aquele aquela ao aos qual quais tem sobre ache acha achar encontre encontrar procure procurar
 busque buscar busca arquivo arquivos documento documentos pasta the an of in on for my where is are file files find search
@@ -80,7 +84,144 @@ def _trecho(texto, palavras, largura=140):
     return ("…" if inicio else "") + plano[inicio:inicio + largura].strip() + "…"
 
 
-def buscar(frase, raiz=None, limite=5, ler=texto_do_arquivo):
+# ---------------------------------------------------------------- índice local (5.3, F4+): opcional, desligado por padrão
+# Um arquivo SQLite na pasta de dados do openTARS com o nome, a pasta e o começo do texto de cada arquivo, para a busca ser
+# instantânea em pastas grandes. Fica só neste computador, nunca é enviado, e se apaga ao desligar. Sem embeddings: continua
+# sendo nome e palavras, como a busca sem índice.
+TEXTO_NO_INDICE = 8000            # caracteres do começo de cada arquivo
+VALIDADE_INDICE_S = 3600          # a busca atualiza o índice (em segundo plano) se ele tem mais de uma hora
+
+
+def indice_ligado():
+    return bool(tars_i18n.ler_config().get("indice_arquivos"))
+
+
+def caminho_do_indice():
+    return plataforma.pastas()["dados"] / "indice-arquivos.db"
+
+
+def ligar_indice(ligado):
+    """Liga ou desliga. Desligar apaga o arquivo do índice: nada fica guardado."""
+    tars_i18n.salvar_config(indice_arquivos=bool(ligado))
+    if not ligado:
+        try:
+            caminho_do_indice().unlink()
+        except OSError:
+            pass
+
+
+def _abrir_indice(caminho):
+    caminho.parent.mkdir(parents=True, exist_ok=True)
+    banco = sqlite3.connect(str(caminho), timeout=10)
+    banco.execute("CREATE TABLE IF NOT EXISTS arquivos (caminho TEXT PRIMARY KEY, mtime REAL, nome TEXT, texto TEXT, busca TEXT)")
+    banco.execute("CREATE TABLE IF NOT EXISTS meta (chave TEXT PRIMARY KEY, valor TEXT)")
+    return banco
+
+
+def atualizar_indice(raiz=None, tempo=25.0, ler=texto_do_arquivo, caminho=None):
+    """Põe no índice os arquivos novos ou mudados (por data de modificação) e tira os que sumiram. Devolve
+    {"arquivos": n, "lidos": n, "removidos": n}. Corta no tempo: o que não deu volta na próxima atualização."""
+    global LIMITE_TEMPO_S
+    raiz = Path(raiz or Path.home())
+    banco = _abrir_indice(caminho or caminho_do_indice())
+    inicio = time.monotonic()
+    guardados = {c: m for c, m in banco.execute("SELECT caminho, mtime FROM arquivos")}
+    vistos, lidos = set(), 0
+    antes, LIMITE_TEMPO_S = LIMITE_TEMPO_S, tempo      # a varredura do índice pode demorar mais que a busca sem índice
+    try:
+        for arquivo in _arquivos(raiz, inicio):
+            chave = str(arquivo)
+            try:
+                st = arquivo.stat()
+            except OSError:
+                continue
+            vistos.add(chave)
+            if guardados.get(chave) == st.st_mtime:
+                continue
+            texto = ""
+            if arquivo.suffix.lower() in LEGIVEIS and st.st_size <= LIMITE_TAMANHO:
+                texto = (ler(arquivo) or "")[:TEXTO_NO_INDICE * 2]
+                texto = " ".join(texto.split())[:TEXTO_NO_INDICE]
+            pastas = " ".join(arquivo.relative_to(raiz).parts[:-1])
+            banco.execute("INSERT OR REPLACE INTO arquivos VALUES (?,?,?,?,?)",
+                          (chave, st.st_mtime, arquivo.name, texto, normalizar(f"{arquivo.stem} {pastas} {texto}")))
+            lidos += 1
+    finally:
+        LIMITE_TEMPO_S = antes
+    completo = time.monotonic() - inicio < tempo
+    sumiram = [c for c in guardados if c not in vistos] if completo else []     # só apaga se a varredura foi até o fim
+    banco.executemany("DELETE FROM arquivos WHERE caminho=?", [(c,) for c in sumiram])
+    banco.execute("INSERT OR REPLACE INTO meta VALUES ('atualizado', ?)", (str(time.time()),))
+    banco.commit()
+    total = banco.execute("SELECT COUNT(*) FROM arquivos").fetchone()[0]
+    banco.close()
+    return {"arquivos": total, "lidos": lidos, "removidos": len(sumiram)}
+
+
+def indice_idade(caminho=None):
+    """Segundos desde a última atualização, ou None se não há índice."""
+    caminho = caminho or caminho_do_indice()
+    if not caminho.exists():
+        return None
+    try:
+        banco = _abrir_indice(caminho)
+        linha = banco.execute("SELECT valor FROM meta WHERE chave='atualizado'").fetchone()
+        banco.close()
+        return time.time() - float(linha[0]) if linha else None
+    except (sqlite3.Error, ValueError):
+        return None
+
+
+def buscar_no_indice(frase, raiz=None, limite=5, caminho=None):
+    """O mesmo resultado de buscar(), lido do índice (instantâneo). None se não há índice para usar."""
+    palavras = termos(frase)
+    if not palavras:
+        return []
+    caminho = caminho or caminho_do_indice()
+    if indice_idade(caminho) is None:
+        return None
+    raiz = str(Path(raiz or Path.home()))
+    banco = _abrir_indice(caminho)
+    try:
+        filtro = " OR ".join("busca LIKE ?" for _ in palavras)
+        linhas = banco.execute(f"SELECT caminho, mtime, nome, texto, busca FROM arquivos WHERE caminho LIKE ? AND ({filtro})",
+                               [raiz.rstrip(os.sep) + os.sep + "%"] + [f"%{p}%" for p in palavras]).fetchall()
+    finally:
+        banco.close()
+    minimo = max(1, (len(palavras) + 1) // 2)
+    achados = []
+    for arquivo, modificado, nome, texto, busca_n in linhas:
+        stem = normalizar(Path(nome).stem)
+        pasta_n = normalizar(" ".join(Path(arquivo).relative_to(raiz).parts[:-1]))
+        no_nome = {p for p in palavras if p in stem}
+        na_pasta = {p for p in palavras if p in pasta_n} - no_nome
+        no_texto = {p for p in palavras if texto and p in normalizar(texto)} - no_nome - na_pasta
+        if len(no_nome | na_pasta | no_texto) < minimo:
+            continue
+        achados.append({"caminho": arquivo, "nome": nome, "pasta": str(Path(arquivo).parent), "modificado": modificado,
+                        "trecho": _trecho(texto, palavras) if texto else "",
+                        "sem_texto": nome.lower().endswith(".pdf") and not texto.strip(),
+                        "pontos": 3 * len(no_nome) + 2 * len(na_pasta) + len(no_texto)})
+    achados.sort(key=lambda a: (-a["pontos"], -a["modificado"]))
+    return achados[:limite]
+
+
+def buscar(frase, raiz=None, limite=5, ler=texto_do_arquivo, indice=None):
+    """Com o índice ligado e existente, lê dele (e, se ele tem mais de uma hora, o atualiza em segundo plano); senão anda pelas
+    pastas como na 5.2. `indice`: True/False força; None segue a configuração."""
+    usar = indice_ligado() if indice is None else indice
+    if usar:
+        achados = buscar_no_indice(frase, raiz, limite)
+        if achados is not None:
+            idade = indice_idade()
+            if idade is not None and idade > VALIDADE_INDICE_S:
+                import threading
+                threading.Thread(target=lambda: atualizar_indice(raiz), daemon=True).start()
+            return achados
+    return _buscar_andando(frase, raiz, limite, ler)
+
+
+def _buscar_andando(frase, raiz=None, limite=5, ler=texto_do_arquivo):
     """[{caminho, nome, pasta, modificado, trecho, sem_texto, pontos}] do melhor para o pior. Um arquivo entra quando
     tem pelo menos metade das palavras da frase no nome, na pasta ou no texto."""
     palavras = termos(frase)

app/tars_confianca.py

@@ -21,6 +21,9 @@ _NAO_E_FATO = re.compile(  # pedido criativo ou de texto, em qualquer posição
     r"\b(escreva|escreve|poema|poesia|conto|historia|cancao|musica|letra|verso|rima|piada|crie|cria|invente|inventa|"
     r"faca|faz|gere|gera|sugira|traduza|traduz|resuma|resume|reescreva|corrija|"
     r"write|poem|poetry|story|joke|song|lyrics|translate|summari[sz]e|rewrite|fix|improve|draft|make up|tell me)\b", re.I)
+_SAUDACAO = re.compile(  # "e aí, tudo certo?" tem forma de pergunta, mas o app mandava pesquisar: a prova de 100 cobrava isso do modelo
+    r"^(e ai|oi|ola|opa|fala|bom dia|boa tarde|boa noite|tudo bem|tudo certo|como vai|como voce esta|"
+    r"hey|hi|hello|good (morning|afternoon|evening)|how are you|how's it going)\b", re.I)
 _PERGUNTA = re.compile(  # a forma de pergunta de fato: termina com "?" ou começa com palavra interrogativa
     r"\?\s*$|^(quem|qual|quais|quando|quanto|quanta|quantos|quantas|onde|por que|porque|o que|que|como|existe|"
     r"who|what|when|where|which|how|is|are|does|did)\b")
@@ -55,7 +58,8 @@ def vale_conferir(tarefa, pedido, resposta):
     if len((resposta or "").strip()) < MIN_CARACTERES or "```" in (resposta or ""):
         return False
     pedido = _sem_acento(pedido)
-    return len(pedido.split()) >= 3 and _PERGUNTA.search(pedido) is not None and not _NAO_E_FATO.search(pedido)
+    return len(pedido.split()) >= 3 and _PERGUNTA.search(pedido) is not None and not _NAO_E_FATO.search(pedido) \
+        and not _SAUDACAO.search(pedido)
 
 
 def logprobs_do_pedaco(pedaco):

app/tars_conta.py

@@ -0,0 +1,58 @@
+"""Contas por código: o modelo de 270M erra aritmética e a busca devolve lixo ("square root of 128" trazia a Wikipédia)."""
+import ast
+import math
+import operator
+import re
+
+_PEDIDO = re.compile(r"^(please |por favor |pode |can you |could you )?(what is|what's|whats|how much is|how much|calculate|calc|compute|solve|work out|"
+                     r"quanto e|quanto da|quanto vale|qual e|qual o valor de|qual|calcula|calcule|calcular|resolve|resolva|conta)?\s*(a |o |the )?")
+_PALAVRAS = [
+    (r"\braiz quadrada d[eao]\s*", "sqrt "), (r"\bsquare root of\s*", "sqrt "), (r"\braiz de\s*", "sqrt "), (r"\bsqrt( of)?\s*", "sqrt "),
+    (r"\bmetade d[eao]\s*", "0.5*"), (r"\bhalf of\s*", "0.5*"), (r"\bdobro d[eao]\s*", "2*"), (r"\bdouble of\s*", "2*"), (r"\bdouble\s+(?=\d)", "2*"), (r"\btriplo d[eao]\s*", "3*"),
+    (r"(\d)\s*(%|por cento|percent)\s*(de|do|da|of)\s*", r"\1*0.01*"),
+    (r"\b(elevado a|elevado ao?|to the power of|to the)\s*", "**"), (r"\bao quadrado\b|\bsquared\b", "**2"), (r"\bao cubo\b|\bcubed\b", "**3"), (r"\^", "**"),
+    (r"\b(vezes|times|multiplicado por|multiplied by)\b", "*"), (r"(?<=\d)\s*x\s*(?=\d)", "*"),
+    (r"\b(dividido por|divided by|over)\b", "/"), (r"\b(mais|plus)\b", "+"), (r"\b(menos|minus)\b", "-"),
+]
+_OPERACOES = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.Mod: operator.mod}
+
+
+def _valor(no):
+    if isinstance(no, ast.Constant) and type(no.value) in (int, float):
+        return no.value
+    if isinstance(no, ast.UnaryOp) and isinstance(no.op, (ast.USub, ast.UAdd)):
+        return -_valor(no.operand) if isinstance(no.op, ast.USub) else _valor(no.operand)
+    if isinstance(no, ast.BinOp) and isinstance(no.op, ast.Pow):
+        base, expoente = _valor(no.left), _valor(no.right)
+        if abs(expoente) > 300 or abs(base) > 1e6:     # 9**9**9 prenderia a placa
+            raise ValueError
+        return base ** expoente
+    if isinstance(no, ast.BinOp) and type(no.op) in _OPERACOES:
+        return _OPERACOES[type(no.op)](_valor(no.left), _valor(no.right))
+    if isinstance(no, ast.Call) and getattr(no.func, "id", "") == "sqrt" and len(no.args) == 1:
+        return math.sqrt(_valor(no.args[0]))
+    raise ValueError
+
+
+def _numero(valor, idioma):
+    if isinstance(valor, float) and valor.is_integer() and abs(valor) < 1e15:
+        valor = int(valor)
+    texto = str(valor) if isinstance(valor, int) else f"{valor:.6g}" if abs(valor) >= 1e6 else f"{valor:.6f}".rstrip("0")
+    return texto.replace(".", ",") if idioma == "pt" else texto
+
+
+def resolver(n, idioma):
+    """'2 + 2 = 4' para um pedido normalizado que é só uma conta; None para o resto."""
+    texto = _PEDIDO.sub("", n.strip(" ?.!=")).strip(" ?.!=")
+    for padrao, troca in _PALAVRAS:
+        texto = re.sub(padrao, troca, texto)
+    texto = re.sub(r"(?<=\d),(?=\d)", ".", texto)
+    texto = re.sub(r"sqrt\s*(\d+(?:\.\d+)?)", r"sqrt(\1)", texto).strip()
+    if not re.search(r"\d", texto) or not re.search(r"[-+*/%]|sqrt", texto) or re.fullmatch(r"[\d/.-]+", texto) and re.search(r"\d[/-]\d+[/-]\d", texto):
+        return None     # sem operação, ou uma data
+    if re.search(r"[^\d\s+\-*/%().sqrt]", texto):
+        return None
+    try:
+        return _numero(_valor(ast.parse(texto, mode="eval").body), idioma)
+    except (ValueError, SyntaxError, ZeroDivisionError, OverflowError, TypeError):
+        return None

app/tars_email.py

@@ -0,0 +1,324 @@
+"""5.3 (F4+++): e-mail no assistente, DESLIGADO por padrão: só vale depois de a pessoa pôr a conta em Configurações > Assistente.
+
+- A senha vai para o cofre do sistema (Secret Service no Linux, Gerenciador de Credenciais no Windows, Chaveiro no macOS) pelo pacote
+  `keyring`, e NUNCA para o config.json nem para o log. Sem o `keyring`, o e-mail fica desligado (não guarda senha em texto).
+- Ler é só leitura: a caixa é aberta em modo somente leitura e os cabeçalhos vêm com PEEK, então nada vira "lido". "Meus e-mails de hoje"
+  lista quem escreveu e o assunto; "ler o último e-mail de X" mostra o começo do texto. O texto do e-mail é dado: nunca vira ordem.
+- Enviar SEMPRE pergunta antes, com o destinatário, o assunto e o texto na tela; um destinatário por vez; sem lista nem cópia.
+- Gmail e Outlook pessoal exigem senha de app (ou já não aceitam senha); contas com login por navegador (OAuth) não funcionam aqui.
+Nada disso foi usado com um servidor de verdade (os testes usam servidores falsos).
+"""
+import datetime as dt
+import email
+import email.header
+import email.message
+import email.utils
+import imaplib
+import re
+import smtplib
+import ssl
+import unicodedata
+
+import tars_i18n
+
+SERVICO = "openTARS-email"
+LIMITE_LISTA = 12
+LIMITE_TEXTO = 1200
+LIMITE_BAIXAR = 200_000          # bytes do começo da mensagem (anexos grandes não vêm inteiros)
+TEMPO_REDE = 15
+MESES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]       # o IMAP só entende estes
+SERVIDORES = {    # domínio -> (imap, smtp)
+    "gmail.com": ("imap.gmail.com", "smtp.gmail.com"), "googlemail.com": ("imap.gmail.com", "smtp.gmail.com"),
+    "outlook.com": ("outlook.office365.com", "smtp-mail.outlook.com"), "hotmail.com": ("outlook.office365.com", "smtp-mail.outlook.com"),
+    "live.com": ("outlook.office365.com", "smtp-mail.outlook.com"), "icloud.com": ("imap.mail.me.com", "smtp.mail.me.com"),
+    "me.com": ("imap.mail.me.com", "smtp.mail.me.com"), "yahoo.com": ("imap.mail.yahoo.com", "smtp.mail.yahoo.com"),
+    "yahoo.com.br": ("imap.mail.yahoo.com", "smtp.mail.yahoo.com"), "uol.com.br": ("imap.uol.com.br", "smtps.uol.com.br"),
+    "proton.me": ("127.0.0.1", "127.0.0.1"),        # o Proton só fala IMAP pelo programa Bridge, que a pessoa instala e ajusta
+}
+
+TEXTOS = {
+    "pt": {"desligado": "O e-mail está desligado. Ligue em Configurações > Assistente.", "sem_senha": "Não achei a senha da conta no cofre do sistema. Digite de novo em Configurações > Assistente.",
+           "erro": "Não consegui falar com o servidor de e-mail ({erro}).", "nada_hoje": "Nenhum e-mail novo hoje.", "hoje": "Hoje chegaram {n} e-mails:",
+           "hoje_um": "Hoje chegou 1 e-mail:", "mais": "… e mais {n}.", "nao_achei": "Não achei e-mail de {quem}.", "de": "De {de}, {data}\nAssunto: {assunto}\n\n{texto}",
+           "sem_texto": "(sem texto)", "pedir": "Mandar este e-mail?\nPara: {para}\nAssunto: {assunto}\n\n{texto}", "negado": "Tudo bem, não enviei.",
+           "enviado": "E-mail enviado para {para}.", "sem_corpo": "Diga o que escrever: envia um e-mail para ana@exemplo.com dizendo que chego às 9h.",
+           "so_um": "Mando um e-mail por vez, para um destinatário.", "sem_assunto": "(sem assunto)"},
+    "en": {"desligado": "Email is off. Turn it on in Settings > Assistant.", "sem_senha": "I couldn't find the account password in the system keychain. Type it again in Settings > Assistant.",
+           "erro": "I couldn't reach the mail server ({erro}).", "nada_hoje": "No new email today.", "hoje": "{n} emails came in today:",
+           "hoje_um": "1 email came in today:", "mais": "… and {n} more.", "nao_achei": "I found no email from {quem}.", "de": "From {de}, {data}\nSubject: {assunto}\n\n{texto}",
+           "sem_texto": "(no text)", "pedir": "Send this email?\nTo: {para}\nSubject: {assunto}\n\n{texto}", "negado": "Okay, I didn't send it.",
+           "enviado": "Email sent to {para}.", "sem_corpo": "Tell me what to write: send an email to ana@example.com saying I arrive at 9.",
+           "so_um": "I send one email at a time, to one recipient.", "sem_assunto": "(no subject)"},
+}
+
+
+def _t(chave, idioma, **kw):
+    s = TEXTOS["pt" if idioma == "pt" else "en"][chave]
+    return s.format(**kw) if kw else s
+
+
+def normalizar(texto):
+    return unicodedata.normalize("NFKD", str(texto)).encode("ascii", "ignore").decode().lower()
+
+
+# ---------------------------------------------------------------- conta e senha
+class SemCofre(RuntimeError):
+    """O pacote keyring não está instalado ou o sistema não tem cofre de senhas."""
+
+
+def _cofre():
+    try:
+        import keyring
+        from keyring.backends import fail
+    except ImportError as e:
+        raise SemCofre("keyring não instalado") from e
+    if isinstance(keyring.get_keyring(), fail.Keyring):
+        raise SemCofre("este sistema não tem cofre de senhas")
+    return keyring
+
+
+def guardar_senha(usuario, senha):
+    _cofre().set_password(SERVICO, usuario, senha)
+
+
+def ler_senha(usuario):
+    try:
+        return _cofre().get_password(SERVICO, usuario)
+    except SemCofre:
+        return None
+
+
+def apagar_senha(usuario):
+    try:
+        _cofre().delete_password(SERVICO, usuario)
+    except Exception:  # noqa: BLE001  (já não existia)
+        pass
+
+
+def conta():
+    """{usuario, imap, imap_porta, smtp, smtp_porta} escolhida pela pessoa, ou None (desligado, o padrão)."""
+    c = tars_i18n.ler_config().get("email")
+    return c if isinstance(c, dict) and c.get("usuario") and c.get("imap") and c.get("smtp") else None
+
+
+def servidores_do_dominio(endereco):
+    """(imap, smtp) provável para o endereço, ou ('', '') se não conheço o provedor."""
+    return SERVIDORES.get(endereco.rsplit("@", 1)[-1].lower(), ("", ""))
+
+
+def salvar_conta(usuario, senha, imap="", smtp="", imap_porta=993, smtp_porta=465):
+    """Guarda a conta no config e a senha no cofre. Levanta SemCofre se não há cofre (aí nada é guardado). Vazio desliga."""
+    if not usuario:
+        antiga = conta()
+        tars_i18n.salvar_config(email={})
+        if antiga:
+            apagar_senha(antiga["usuario"])
+        return
+    padrao_imap, padrao_smtp = servidores_do_dominio(usuario)
+    if senha:
+        guardar_senha(usuario, senha)         # primeiro o cofre: se falhar, a conta não fica pela metade
+    tars_i18n.salvar_config(email={"usuario": usuario, "imap": imap or padrao_imap, "smtp": smtp or padrao_smtp,
+                                   "imap_porta": int(imap_porta), "smtp_porta": int(smtp_porta)})
+
+
+# ---------------------------------------------------------------- IMAP: ler
+def _decodificar(valor):
+    try:
+        return str(email.header.make_header(email.header.decode_header(valor or ""))).strip()
+    except Exception:  # noqa: BLE001  (cabeçalho torto: o texto cru serve)
+        return str(valor or "").strip()
+
+
+def _abrir_imap(c, senha):
+    if not senha:
+        raise SemCofre("sem senha")
+    # sem ssl_context o imaplib usa ssl._create_stdlib_context(), que não confere o certificado (revisão de 13/11)
+    caixa = imaplib.IMAP4_SSL(c["imap"], int(c.get("imap_porta") or 993), timeout=TEMPO_REDE, ssl_context=ssl.create_default_context())
+    caixa.login(c["usuario"], senha)
+    caixa.select("INBOX", readonly=True)             # só leitura: nada vira "lido", nada é apagado
+    return caixa
+
+
+def _cabecalhos(caixa, numeros):
+    saida = []
+    for n in numeros:
+        tipo, dados = caixa.fetch(n, "(BODY.PEEK[HEADER.FIELDS (FROM SUBJECT DATE)])")
+        if tipo != "OK" or not dados or not isinstance(dados[0], tuple):
+            continue
+        msg = email.message_from_bytes(dados[0][1])
+        nome, endereco = email.utils.parseaddr(_decodificar(msg.get("From")))
+        saida.append({"de": nome or endereco, "endereco": endereco, "assunto": _decodificar(msg.get("Subject")), "data": msg.get("Date", "")})
+    return saida
+
+
+def de_hoje(agora=None, c=None, senha=None):
+    """Os e-mails que chegaram hoje (do mais novo para o mais velho), só cabeçalhos."""
+    c, agora = c or conta(), agora or dt.datetime.now()
+    caixa = _abrir_imap(c, senha or ler_senha(c["usuario"]))
+    try:
+        desde = f"{agora.day:02d}-{MESES[agora.month - 1]}-{agora.year}"
+        tipo, dados = caixa.search(None, "SINCE", desde)
+        numeros = (dados[0].split() if tipo == "OK" and dados and dados[0] else [])[::-1]
+        return {"total": len(numeros), "itens": _cabecalhos(caixa, numeros[:LIMITE_LISTA])}
+    finally:
+        try:
+            caixa.logout()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+def _texto_da_mensagem(msg):
+    for parte in msg.walk() if msg.is_multipart() else [msg]:
+        if parte.get_content_type() == "text/plain" and not parte.get_filename():
+            carga = parte.get_payload(decode=True) or b""
+            return carga.decode(parte.get_content_charset() or "utf-8", "replace").strip()
+    for parte in msg.walk() if msg.is_multipart() else [msg]:
+        if parte.get_content_type() == "text/html":
+            carga = (parte.get_payload(decode=True) or b"").decode(parte.get_content_charset() or "utf-8", "replace")
+            return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", re.sub(r"(?is)<(script|style).*?</\1>", " ", carga))).strip()
+    return ""
+
+
+def ultimo_de(quem, c=None, senha=None):
+    """O e-mail mais recente de alguém (nome ou endereço): {de, data, assunto, texto} ou None."""
+    c = c or conta()
+    quem = re.sub(r'["\\\r\n]', "", quem).strip()
+    if not quem:
+        return None
+    caixa = _abrir_imap(c, senha or ler_senha(c["usuario"]))
+    try:
+        tipo, dados = caixa.search(None, "FROM", f'"{quem}"')
+        numeros = dados[0].split() if tipo == "OK" and dados and dados[0] else []
+        if not numeros:
+            return None
+        tipo, dados = caixa.fetch(numeros[-1], f"(BODY.PEEK[]<0.{LIMITE_BAIXAR}>)")
+        if tipo != "OK" or not dados or not isinstance(dados[0], tuple):
+            return None
+        msg = email.message_from_bytes(dados[0][1])
+        nome, endereco = email.utils.parseaddr(_decodificar(msg.get("From")))
+        return {"de": nome or endereco, "data": msg.get("Date", ""), "assunto": _decodificar(msg.get("Subject")),
+                "texto": _texto_da_mensagem(msg)[:LIMITE_TEXTO]}
+    finally:
+        try:
+            caixa.logout()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+# ---------------------------------------------------------------- SMTP: enviar
+EMAIL_VALIDO = re.compile(r"^[^@\s,;<>]+@[^@\s,;<>]+\.[^@\s,;<>]+$")
+
+
+def enviar(para, assunto, texto, c=None, senha=None):
+    """Manda UM e-mail. Quem chama já pediu a aprovação da pessoa."""
+    c = c or conta()
+    if not EMAIL_VALIDO.match(para):
+        raise ValueError("destinatário inválido")
+    if not (senha or ler_senha(c["usuario"])):
+        raise SemCofre("sem senha")
+    msg = email.message.EmailMessage()
+    msg["From"], msg["To"], msg["Subject"] = c["usuario"], para, assunto
+    msg["Date"] = email.utils.formatdate(localtime=True)
+    msg.set_content(texto)
+    porta, contexto = int(c.get("smtp_porta") or 465), ssl.create_default_context()
+    senha = senha or ler_senha(c["usuario"])
+    if porta == 465:
+        with smtplib.SMTP_SSL(c["smtp"], porta, timeout=TEMPO_REDE, context=contexto) as s:
+            s.login(c["usuario"], senha)
+            s.send_message(msg)
+    else:
+        with smtplib.SMTP(c["smtp"], porta, timeout=TEMPO_REDE) as s:
+            s.starttls(context=contexto)
+            s.login(c["usuario"], senha)
+            s.send_message(msg)
+
+
+def testar(c=None, senha=None):
+    """Entra na caixa e sai (só leitura). Devolve None se deu certo, ou o motivo."""
+    c = c or conta()
+    try:
+        caixa = _abrir_imap(c, senha or ler_senha(c["usuario"]))
+        caixa.logout()
+        return None
+    except (imaplib.IMAP4.error, OSError, ssl.SSLError) as e:
+        return str(e)[:100] or type(e).__name__
+
+
+# ---------------------------------------------------------------- frases
+_NOVOS = re.compile(r"\b(meus|my|novos?|new|chegou|chegaram|tenho|do i have|check|ver|mostra|mostre|show|quais|que|what|resume|resumo|summar\w+)\b.*"
+                    r"\be-?mails?\b.*\b(hoje|today)\b|\b(tenho|do i have|any)\b.*\b(novos?|new)\b.*\be-?mails?\b|\b(novos?|new) e-?mails?\b")
+_LER = re.compile(r"\b(ler|le|leia|abre|abra|mostra|mostre|read|show|open)\b.*\b(ultimo|ultima|last|latest|most recent)\b.*\be-?mail\b.*"
+                  r"\b(de|da|do|from)\s+(?P<quem>.+)$")
+_ENVIAR = re.compile(r"^\s*(?:por favor,?\s+|please,?\s+)?(?:envia|envie|enviar|manda|mande|mandar|escreve|escreva|send|write|email)\b.*?\be-?mails?\b.*?"
+                     r"\b(?:para|pra|to)\s+(?P<para>[^\s,;<>]+@[^\s,;<>]+?)[.,;]?(?P<resto>\s.*)?$", re.IGNORECASE | re.DOTALL)
+_CORPO = re.compile(r"\b(?:dizendo|falando|avisando|com o texto|com a mensagem|saying|telling (?:him|her|them)|with the message|that says)\b[:\s]*(?P<c>.+)$", re.IGNORECASE | re.DOTALL)
+_ASSUNTO = re.compile(r"\b(?:assunto|subject)\b[:\s]+(?P<a>.+?)(?=\s+(?:dizendo|falando|avisando|com o texto|com a mensagem|saying|with the message|that says)\b|$)", re.IGNORECASE | re.DOTALL)
+
+
+def _data_curta(texto):
+    try:
+        return email.utils.parsedate_to_datetime(texto).astimezone().strftime("%d/%m %H:%M")
+    except (TypeError, ValueError):
+        return texto[:16]
+
+
+def responder(pedido, idioma, core=None):
+    """Lista os e-mails de hoje, lê o último de alguém ou manda um e-mail (com aprovação). None se a frase não é de e-mail.
+    Desligado (sem conta) também devolve None: o pedido segue para o modelo, como antes."""
+    n = normalizar(pedido).replace("e-mail", "email")
+    c = conta()
+    if c is None:
+        return None
+    m_env = _ENVIAR.match(pedido)
+    if m_env:
+        return _enviar_por_frase(m_env, idioma, core, c)
+    try:
+        m = _LER.search(n)
+        if m:
+            quem = pedido[len(pedido) - len(m.group("quem")):].strip(" ?.!")           # com as maiúsculas e acentos de quem escreveu
+            achado = ultimo_de(quem, c)
+            if not achado:
+                return _t("nao_achei", idioma, quem=quem)
+            return _t("de", idioma, de=achado["de"], data=_data_curta(achado["data"]), assunto=achado["assunto"] or _t("sem_assunto", idioma),
+                      texto=achado["texto"] or _t("sem_texto", idioma))
+        if _NOVOS.search(n):
+            hoje = de_hoje(c=c)
+            if not hoje["itens"]:
+                return _t("nada_hoje", idioma)
+            linhas = [_t("hoje_um" if hoje["total"] == 1 else "hoje", idioma, n=hoje["total"])]
+            linhas += [f"• {i['de']}: {i['assunto'] or _t('sem_assunto', idioma)}" for i in hoje["itens"]]
+            if hoje["total"] > len(hoje["itens"]):
+                linhas.append(_t("mais", idioma, n=hoje["total"] - len(hoje["itens"])))
+            return "\n".join(linhas)
+    except SemCofre:
+        return _t("sem_senha", idioma)
+    except (imaplib.IMAP4.error, OSError, ssl.SSLError, smtplib.SMTPException) as e:
+        return _t("erro", idioma, erro=str(e)[:80] or type(e).__name__)
+    return None
+
+
+def _enviar_por_frase(m, idioma, core, c):
+    resto = m.group("resto") or ""
+    corpo = _CORPO.search(resto)
+    if "@" in (resto[:corpo.start()] if corpo else ""):          # "para a@x.com e b@y.com dizendo...": um destinatário por vez
+        return _t("so_um", idioma)
+    texto = re.sub(r"^(?:que|that)\s+", "", (corpo.group("c") if corpo else resto.strip(" :,-")).strip(), flags=re.IGNORECASE)
+    if not texto:
+        return _t("sem_corpo", idioma)
+    texto = texto[:1].upper() + texto[1:]
+    assunto = _ASSUNTO.search(resto)
+    assunto = (assunto.group("a").strip(" .,:") if assunto else "") or _t("sem_assunto", idioma)
+    para = m.group("para").strip("<>")
+    if not EMAIL_VALIDO.match(para):
+        return _t("sem_corpo", idioma)
+    # nunca sai sem a pessoa ver e dizer sim: sem janela para perguntar, ou com as perguntas desligadas (TARS_SEM_CONFIRMACAO_PERIGOSOS), não envia
+    if core is None or not getattr(core, "_CONFIRMAR_COMANDOS_PERIGOSOS", False) \
+            or not core._confirmar_comando_perigoso(_t("pedir", idioma, para=para, assunto=assunto, texto=texto[:500])):
+        return _t("negado", idioma)
+    try:
+        enviar(para, assunto, texto, c)
+    except SemCofre:
+        return _t("sem_senha", idioma)
+    except (imaplib.IMAP4.error, OSError, ssl.SSLError, smtplib.SMTPException, ValueError) as e:
+        return _t("erro", idioma, erro=str(e)[:80] or type(e).__name__)
+    return _t("enviado", idioma, para=para)

app/tars_gerenciar_modelos.py

@@ -11,6 +11,7 @@ import urllib.error
 import urllib.request
 
 import tars_primeiro_uso as pu
+import tars_motor as motor
 
 
 def _tamanho_gb(m):
@@ -20,7 +21,7 @@ def _tamanho_gb(m):
 def listar(host, abrir=None):
     """Os modelos instalados, do maior para o menor: [{nome, gb, parametros, quantizacao, familia, data, nuvem, oficial}].
     Levanta OSError se o Ollama não responder."""
-    pedido = urllib.request.Request(f"{host}/api/tags")
+    pedido = urllib.request.Request(motor.url("modelos", host))
     with (abrir or urllib.request.urlopen)(pedido, timeout=6) as r:
         dados = json.loads(r.read())
     saida = []
@@ -50,7 +51,7 @@ def apagar(nome, host, abrir=None):
     """Apaga `nome` do Ollama (DELETE /api/delete). Devolve (ok, erro). Os modelos que outros modelos compartilham
     continuam: o Ollama só remove as camadas que mais ninguém usa."""
     corpo = json.dumps({"model": nome, "name": nome}).encode()      # "name" para os Ollama mais antigos
-    pedido = urllib.request.Request(f"{host}/api/delete", data=corpo, method="DELETE",
+    pedido = urllib.request.Request(motor.url("apagar", host), data=corpo, method="DELETE",
                                     headers={"Content-Type": "application/json"})
     try:
         with (abrir or urllib.request.urlopen)(pedido, timeout=30):
@@ -72,7 +73,7 @@ REGISTRO = "https://registry.ollama.ai/v2/{repositorio}/manifests/{tag}"
 
 def camada_local(nome, host, abrir=None):
     """O digest da camada de pesos do modelo instalado, ou "" se não deu para saber."""
-    pedido = urllib.request.Request(f"{host}/api/show", data=json.dumps({"model": nome}).encode(),
+    pedido = urllib.request.Request(motor.url("detalhes", host), data=json.dumps({"model": nome}).encode(),
                                     headers={"Content-Type": "application/json"})
     with (abrir or urllib.request.urlopen)(pedido, timeout=10) as r:
         achados = re.findall(r"sha256[-:]([0-9a-f]{64})", json.loads(r.read()).get("modelfile") or "")

app/tars_gui.py

@@ -1299,30 +1299,10 @@ class JanelaTars(tk.Tk):
         self._trabalho = threading.Thread(target=alvo, daemon=True)
         self._trabalho.start()
 
-    def _na_ui(self, funcao):
-        """Chamado de outra thread: roda na thread da janela."""
-        self._fila_saida.put(_NaInterface(funcao))
-
     # ------------------------------------------------------------
     # Escolha da IA (um seletor só: Automático ou um modelo)
     # ------------------------------------------------------------
 
-    def _recontar_modelos(self):
-        """Conta de novo os modelos da barra de status."""
-        def alvo():
-            try:
-                catalogo = core.catalogar_modelos(forcar=True)
-                n = sum(1 for m in catalogo.values()
-                        if m["categoria"] != "embedding" and m["tag"] not in core.MODELOS_AJUDANTES)
-            except Exception:
-                return
-
-            def aplicar():
-                self._info["n_modelos"] = n
-                self._atualizar_status(self._info)
-            self._fila_saida.put(_NaInterface(aplicar))
-        threading.Thread(target=alvo, daemon=True).start()
-
     def _modelos_escolhiveis(self):
         # Esta função roda na thread da janela: com a lista já guardada, usa ela (e atualiza em segundo
         # plano), em vez de esperar até 5 s pelo Ollama a cada resposta e travar a tela.

app/tars_imagem.py

@@ -23,6 +23,7 @@ import time
 from pathlib import Path
 
 import tars_plataforma as plataforma
+import tars_motor as motor
 
 REPOSITORIO = "https://github.com/PrismML-Eng/Bonsai-Image-Demo.git"
 COMMIT = "de1e5c0323e7a0474c68c6cdd075bad4e782fb0e"
@@ -123,10 +124,10 @@ def descarregar_ollama(host, abrir=None):
     import urllib.request
     abrir = abrir or urllib.request.urlopen
     try:
-        with abrir(f"{host}/api/ps", timeout=5) as r:
+        with abrir(motor.url("rodando", host), timeout=5) as r:
             nomes = [m.get("name") for m in json.loads(r.read()).get("models", [])]
         for nome in nomes:
-            pedido = urllib.request.Request(f"{host}/api/generate", data=json.dumps({"model": nome, "keep_alive": 0}).encode(),
+            pedido = urllib.request.Request(motor.url("gerar", host), data=json.dumps({"model": nome, "keep_alive": 0}).encode(),
                                             headers={"Content-Type": "application/json"})
             with abrir(pedido, timeout=30):
                 pass

app/tars_integracoes.py

@@ -0,0 +1,476 @@
+"""5.3 (F4+++): integrações do assistente com a agenda e com as notas da pessoa, resolvidas por código (sem o modelo) e
+DESLIGADAS por padrão: só valem depois de a pessoa dizer, nas Configurações > Assistente, qual arquivo .ics (ou link) e qual
+pasta de notas usar. Só biblioteca padrão (mais o `requests` do app para o link do calendário). Nada sai do computador: o
+calendário é só lido, e as notas são arquivos Markdown comuns numa pasta que a pessoa escolheu.
+
+Agenda: lê eventos de arquivos .ics (Google, Outlook, Apple e Thunderbird exportam) com repetição diária, semanal, mensal e anual
+(INTERVAL, COUNT, UNTIL, BYDAY, BYMONTHDAY, exceções e instâncias alteradas). Responde "o que tenho amanhã?", "what's on my
+calendar this week?", "qual meu próximo compromisso?".
+  Limites: sem enviar convite nem criar evento (só leitura); fuso com nome do Windows ("W. Europe Standard Time") que o sistema
+  não conhece é tratado como horário local; BYSETPOS e regras raras ficam de fora e o evento só vale na primeira data.
+Notas: "cria uma nota: ..." grava um .md novo (nunca por cima de outro) e "minhas notas sobre X" / "show the note X" procura e lê.
+"""
+import datetime as dt
+import re
+import time
+import unicodedata
+from pathlib import Path
+
+import tars_i18n
+
+CACHE_LINK_S = 900
+LIMITE_ITERACOES = 6000
+LIMITE_LISTA = 15
+_cache_link = {}
+
+TEXTOS = {
+    "pt": {"nada": "Não há nada na agenda para {quando}.", "um": "{Quando} você tem 1 compromisso:", "varios": "{Quando} você tem {n} compromissos:",
+           "dia_inteiro": "dia inteiro", "proximo": "Seu próximo compromisso: {quando}, {titulo}{local}.", "sem_proximo": "Não achei compromisso nos próximos 60 dias.",
+           "mais": "… e mais {n}.", "erro": "Não consegui ler a agenda ({erro}).",
+           "nota_criada": "Nota criada: {nome}, em {pasta}.", "nota_vazia": "Diga o que escrever: cria uma nota: comprar pão.",
+           "notas_nada": "Não achei nada nas notas sobre {termo}.", "notas_achei": "Achei {n} em suas notas:", "nota_texto": "{nome}:\n{texto}",
+           "nota_nao_achei": "Não achei a nota {termo}.",
+           "hoje": "hoje", "amanha": "amanhã", "depois": "depois de amanhã", "semana": "esta semana", "semana_que_vem": "a semana que vem",
+           "dias": ["segunda", "terça", "quarta", "quinta", "sexta", "sábado", "domingo"]},
+    "en": {"nada": "There is nothing on your calendar for {quando}.", "um": "{Quando} you have 1 event:", "varios": "{Quando} you have {n} events:",
+           "dia_inteiro": "all day", "proximo": "Your next event: {quando}, {titulo}{local}.", "sem_proximo": "I found no events in the next 60 days.",
+           "mais": "… and {n} more.", "erro": "I couldn't read the calendar ({erro}).",
+           "nota_criada": "Note created: {nome}, in {pasta}.", "nota_vazia": "Tell me what to write: create a note: buy bread.",
+           "notas_nada": "I found nothing about {termo} in your notes.", "notas_achei": "Found {n} in your notes:", "nota_texto": "{nome}:\n{texto}",
+           "nota_nao_achei": "I couldn't find the note {termo}.",
+           "hoje": "today", "amanha": "tomorrow", "depois": "the day after tomorrow", "semana": "this week", "semana_que_vem": "next week",
+           "dias": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]},
+}
+_DIAS_ICS = {"MO": 0, "TU": 1, "WE": 2, "TH": 3, "FR": 4, "SA": 5, "SU": 6}
+
+
+def _t(chave, idioma, **kw):
+    return TEXTOS["pt" if idioma == "pt" else "en"][chave].format(**kw) if kw else TEXTOS["pt" if idioma == "pt" else "en"][chave]
+
+
+def normalizar(texto):
+    return unicodedata.normalize("NFKD", str(texto)).encode("ascii", "ignore").decode().lower()
+
+
+# ---------------------------------------------------------------- configuração (desligado por padrão)
+def agendas():
+    """Os arquivos .ics ou links escolhidos pela pessoa; lista vazia = agenda desligada."""
+    valor = tars_i18n.ler_config().get("agenda_ics") or []
+    return [str(v).strip() for v in ([valor] if isinstance(valor, str) else valor) if str(v).strip()]
+
+
+def pasta_de_notas():
+    valor = str(tars_i18n.ler_config().get("notas_pasta") or "").strip()
+    return Path(valor).expanduser() if valor else None
+
+
+# ---------------------------------------------------------------- ICS: ler
+def _desdobrar(texto):
+    """Linhas do iCalendar: uma linha que começa com espaço ou tab continua a anterior."""
+    linhas = []
+    for bruta in texto.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
+        if bruta[:1] in (" ", "\t") and linhas:
+            linhas[-1] += bruta[1:]
+        elif bruta:
+            linhas.append(bruta)
+    return linhas
+
+
+def _propriedade(linha):
+    cabeca, _, valor = linha.partition(":")
+    nome, *params = cabeca.split(";")
+    p = {}
+    for par in params:
+        k, _, v = par.partition("=")
+        p[k.upper()] = v.strip('"')
+    return nome.upper(), p, valor
+
+
+def _desescapar(valor):
+    return valor.replace("\\n", " ").replace("\\N", " ").replace("\\,", ",").replace("\\;", ";").replace("\\\\", "\\")
+
+
+def _fuso(nome):
+    if not nome:
+        return None
+    try:
+        from zoneinfo import ZoneInfo
+        return ZoneInfo(nome)
+    except Exception:  # noqa: BLE001  (nome do Windows ou sem tzdata: horário local)
+        return None
+
+
+def _quando(valor, params):
+    """(data e hora SEM fuso no horário do próprio evento, fuso, dia_inteiro)."""
+    valor = valor.strip()
+    if params.get("VALUE") == "DATE" or (len(valor) == 8 and valor.isdigit()):
+        return dt.datetime.strptime(valor[:8], "%Y%m%d"), None, True
+    utc = valor.endswith("Z")
+    naive = dt.datetime.strptime(valor.rstrip("Z")[:15], "%Y%m%dT%H%M%S")
+    if utc:
+        return naive, dt.timezone.utc, False
+    return naive, _fuso(params.get("TZID")), False
+
+
+def _local(naive, fuso):
+    """O horário da parede do evento, no horário local do computador, sem fuso."""
+    if fuso is None:
+        return naive
+    return naive.replace(tzinfo=fuso).astimezone().replace(tzinfo=None)
+
+
+def _duracao(valor):
+    m = re.fullmatch(r"([+-])?P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?", valor.strip())
+    if not m:
+        return dt.timedelta(0)
+    sinal = -1 if m.group(1) == "-" else 1
+    sem, dia, h, mi, s = (int(x or 0) for x in m.groups()[1:])
+    return sinal * dt.timedelta(weeks=sem, days=dia, hours=h, minutes=mi, seconds=s)
+
+
+def ler_ics(texto):
+    """Os eventos do texto de um .ics: [{uid, inicio, fuso, dia_inteiro, duracao, titulo, local, regra, excecoes, id_instancia}]."""
+    eventos, atual = [], None
+    for linha in _desdobrar(texto):
+        if linha.upper() == "BEGIN:VEVENT":
+            atual = {"props": []}
+        elif linha.upper() == "END:VEVENT" and atual is not None:
+            e = _montar(atual["props"])
+            if e:
+                eventos.append(e)
+            atual = None
+        elif atual is not None:
+            atual["props"].append(_propriedade(linha))
+    return eventos
+
+
+def _montar(props):
+    d = {}
+    excecoes = []
+    for nome, p, valor in props:
+        if nome == "EXDATE":
+            excecoes += [(v, p) for v in valor.split(",") if v.strip()]
+        else:
+            d.setdefault(nome, (p, valor))
+    if "DTSTART" not in d or d.get("STATUS", ({}, ""))[1].upper() == "CANCELLED":
+        return None
+    try:
+        inicio, fuso, inteiro = _quando(d["DTSTART"][1], d["DTSTART"][0])
+        if "DTEND" in d:
+            fim, fuso_fim, _ = _quando(d["DTEND"][1], d["DTEND"][0])
+            duracao = (fim - inicio) if fuso_fim == fuso else _local(fim, fuso_fim) - _local(inicio, fuso)
+        elif "DURATION" in d:
+            duracao = _duracao(d["DURATION"][1])
+        else:
+            duracao = dt.timedelta(days=1) if inteiro else dt.timedelta(0)
+        regra = {}
+        for parte in (d.get("RRULE", ({}, ""))[1]).split(";"):
+            k, _, v = parte.partition("=")
+            if k:
+                regra[k.upper()] = v
+        sem = {_quando(v, p)[0] for v, p in excecoes}
+        instancia = _quando(d["RECURRENCE-ID"][1], d["RECURRENCE-ID"][0])[0] if "RECURRENCE-ID" in d else None
+    except (ValueError, KeyError):
+        return None
+    return {"uid": d.get("UID", ({}, ""))[1], "inicio": inicio, "fuso": fuso, "dia_inteiro": inteiro, "duracao": duracao,
+            "titulo": _desescapar(d.get("SUMMARY", ({}, ""))[1]) or "(sem título)", "local": _desescapar(d.get("LOCATION", ({}, ""))[1]),
+            "regra": regra, "excecoes": sem, "id_instancia": instancia}
+
+
+# ---------------------------------------------------------------- ICS: repetir
+def _passos_da_regra(e):
+    """As datas (horário da parede do evento) de cada ocorrência, em ordem, a partir do início. Para quando a regra acaba."""
+    r, inicio = e["regra"], e["inicio"]
+    if not r.get("FREQ"):
+        yield inicio
+        return
+    freq, intervalo = r["FREQ"].upper(), max(1, int(r.get("INTERVAL") or 1))
+    contagem = int(r["COUNT"]) if r.get("COUNT", "").isdigit() else None
+    ate = None
+    if r.get("UNTIL"):
+        try:
+            u, fuso_u, _ = _quando(r["UNTIL"], {})
+            ate = u if fuso_u is None else _local(u, fuso_u)
+            ate = ate + dt.timedelta(days=1) if len(r["UNTIL"]) == 8 else ate
+        except ValueError:
+            ate = None
+    emitidos = 0
+    hora = inicio.time()
+    por_dia = [(int(m.group(1) or 0), _DIAS_ICS[m.group(2)]) for m in re.finditer(r"([+-]?\d+)?(MO|TU|WE|TH|FR|SA|SU)", r.get("BYDAY", ""))]
+    dias_mes = [int(x) for x in r.get("BYMONTHDAY", "").split(",") if x.strip("-").isdigit()]
+
+    def candidatos():
+        if freq == "DAILY":
+            n = 0
+            while True:
+                yield inicio + dt.timedelta(days=n * intervalo)
+                n += 1
+        elif freq == "WEEKLY":
+            segunda = inicio - dt.timedelta(days=inicio.weekday())
+            dias = sorted({d for _, d in por_dia}) or [inicio.weekday()]
+            n = 0
+            while True:
+                base = segunda + dt.timedelta(weeks=n * intervalo)
+                for d in dias:
+                    yield dt.datetime.combine((base + dt.timedelta(days=d)).date(), hora)
+                n += 1
+        elif freq in ("MONTHLY", "YEARLY"):
+            n = 0
+            while True:
+                total = (inicio.year * 12 + inicio.month - 1) + (n * intervalo * (12 if freq == "YEARLY" else 1))
+                ano, mes = divmod(total, 12)
+                mes += 1
+                if freq == "YEARLY" and por_dia == [] and not dias_mes:
+                    dias = [inicio.day]
+                else:
+                    dias = list(dias_mes) or []
+                    if por_dia and freq == "MONTHLY":
+                        dias += _dias_da_semana_do_mes(ano, mes, por_dia)
+                    if not dias:
+                        dias = [inicio.day]
+                ultimo = (dt.date(ano + (mes == 12), mes % 12 + 1, 1) - dt.timedelta(days=1)).day
+                for d in sorted(set(dias)):
+                    d = ultimo + 1 + d if d < 0 else d
+                    if 1 <= d <= ultimo:
+                        yield dt.datetime.combine(dt.date(ano, mes, d), hora)
+                n += 1
+        else:
+            yield inicio
+
+    for c in candidatos():
+        if c < inicio:
+            continue
+        if ate is not None and c >= ate:
+            return
+        emitidos += 1
+        if contagem is not None and emitidos > contagem:
+            return
+        yield c
+        if emitidos >= LIMITE_ITERACOES:
+            return
+
+
+def _dias_da_semana_do_mes(ano, mes, por_dia):
+    """BYDAY com ordinal (2TU, -1FR) ou sem (todas as terças) dentro do mês."""
+    dias = []
+    ultimo = (dt.date(ano + (mes == 12), mes % 12 + 1, 1) - dt.timedelta(days=1)).day
+    for ordinal, dia in por_dia:
+        do_dia = [d for d in range(1, ultimo + 1) if dt.date(ano, mes, d).weekday() == dia]
+        if not ordinal:
+            dias += do_dia
+        elif 0 < ordinal <= len(do_dia):
+            dias.append(do_dia[ordinal - 1])
+        elif ordinal < 0 and -ordinal <= len(do_dia):
+            dias.append(do_dia[ordinal])
+    return dias
+
+
+def ocorrencias(eventos, de, ate):
+    """[(inicio, fim, evento)] que tocam [de, ate), no horário local, em ordem."""
+    alteradas = {(e["uid"], e["id_instancia"]) for e in eventos if e["id_instancia"] is not None}
+    saida = []
+    for e in eventos:
+        for naive in _passos_da_regra(e):
+            local = naive if e["dia_inteiro"] else _local(naive, e["fuso"])
+            if local >= ate:
+                break                                   # as ocorrências vêm em ordem: o resto é depois do período
+            if naive in e["excecoes"] or (e["uid"], naive) in alteradas:
+                continue
+            fim = local + e["duracao"]
+            if fim > de or (not e["duracao"] and local >= de):
+                saida.append((local, fim, e))
+    saida.sort(key=lambda x: (x[0], x[2]["titulo"]))
+    return saida
+
+
+def eventos_das_fontes(fontes=None, agora=None):
+    """Lê os .ics escolhidos (arquivos ou links). Devolve (eventos, erros). O link tem cache de 15 minutos."""
+    eventos, erros = [], []
+    for fonte in (fontes if fontes is not None else agendas()):
+        try:
+            if re.match(r"https?://", fonte, re.I) or fonte.lower().startswith("webcal://"):
+                texto = _baixar(fonte.replace("webcal://", "https://", 1))
+            else:
+                texto = Path(fonte).expanduser().read_text(encoding="utf-8", errors="replace")
+            eventos += ler_ics(texto)
+        except Exception as e:  # noqa: BLE001  (arquivo sumiu, sem rede: a resposta diz, o resto continua)
+            erros.append(f"{type(e).__name__}")
+    return eventos, erros
+
+
+def _baixar(url):
+    guardado = _cache_link.get(url)
+    if guardado and time.monotonic() - guardado[0] < CACHE_LINK_S:
+        return guardado[1]
+    import requests
+    r = requests.get(url, timeout=10, headers={"User-Agent": "openTARS"})
+    r.raise_for_status()
+    _cache_link[url] = (time.monotonic(), r.text)
+    return r.text
+
+
+# ---------------------------------------------------------------- agenda: entender a frase
+_AGENDA = re.compile(r"\b(agenda|compromiss\w*|calendar\w*|calendario|meetings?|events?|eventos?|reuni\w+|schedule)\b")
+_TEMPO = re.compile(r"\b(hoje|today|amanha|tomorrow|depois de amanha|day after tomorrow|esta semana|essa semana|nesta semana|this week|"
+                    r"semana que vem|proxima semana|next week|segunda|terca|quarta|quinta|sexta|sabado|domingo|monday|tuesday|wednesday|"
+                    r"thursday|friday|saturday|sunday)\b")
+_PROXIMO = re.compile(r"\b(proximo|proxima|next|upcoming)\b.*\b(compromisso|evento|reuniao|meeting|event|appointment)\b|"
+                      r"\b(compromisso|evento|reuniao|meeting|event|appointment)\b.*\b(proximo|proxima|next)\b")
+_NOMES_DIA = {"segunda": 0, "terca": 1, "quarta": 2, "quinta": 3, "sexta": 4, "sabado": 5, "domingo": 6,
+              "monday": 0, "tuesday": 1, "wednesday": 2, "thursday": 3, "friday": 4, "saturday": 5, "sunday": 6}
+
+
+def _intervalo(n, hoje):
+    """(início, fim, nome do período em pt/en) para a frase normalizada, ou None."""
+    dia = dt.datetime.combine(hoje, dt.time())
+    if re.search(r"\b(depois de amanha|day after tomorrow)\b", n):
+        return dia + dt.timedelta(days=2), dia + dt.timedelta(days=3), "depois"
+    if re.search(r"\b(amanha|tomorrow)\b", n):
+        return dia + dt.timedelta(days=1), dia + dt.timedelta(days=2), "amanha"
+    if re.search(r"\b(semana que vem|proxima semana|next week)\b", n):
+        segunda = dia + dt.timedelta(days=7 - hoje.weekday())
+        return segunda, segunda + dt.timedelta(days=7), "semana_que_vem"
+    if re.search(r"\b(esta semana|essa semana|nesta semana|this week)\b", n):
+        return dia, dia + dt.timedelta(days=7 - hoje.weekday()), "semana"
+    if re.search(r"\b(hoje|today)\b", n):
+        return dia, dia + dt.timedelta(days=1), "hoje"
+    for nome, numero in _NOMES_DIA.items():
+        if re.search(rf"\b{nome}\b", n):
+            alvo = dia + dt.timedelta(days=(numero - hoje.weekday()) % 7)
+            return alvo, alvo + dt.timedelta(days=1), ("dia", numero)
+    return None
+
+
+def _periodo_texto(periodo, idioma, inicio):
+    if isinstance(periodo, tuple):
+        nome = TEXTOS["pt" if idioma == "pt" else "en"]["dias"][periodo[1]]
+        return (f"{'na' if periodo[1] < 5 else 'no'} {nome}" if idioma == "pt" else f"on {nome}") + f" ({inicio:%d/%m})"
+    return _t(periodo, idioma)
+
+
+def _hora(local, fim, inteiro, idioma):
+    if inteiro:
+        return _t("dia_inteiro", idioma)
+    return f"{local:%H:%M}" + (f"–{fim:%H:%M}" if fim != local and fim.date() == local.date() else "")
+
+
+def responder_agenda(pedido, idioma, agora=None, fontes=None):
+    """O texto da resposta sobre a agenda, ou None quando a frase não é sobre a agenda (ou a agenda está desligada)."""
+    fontes = agendas() if fontes is None else fontes
+    n = normalizar(pedido)
+    if not fontes:
+        return None
+    proximo = bool(_PROXIMO.search(n))
+    intervalo = None if proximo else _intervalo(n, (agora or dt.datetime.now()).date())
+    pede = proximo or (intervalo is not None and bool(_AGENDA.search(n) or re.search(r"\b(tenho|do i have|have i|i have|what do i)\b", n)))
+    if not pede:
+        return None
+    eventos, erros = eventos_das_fontes(fontes)
+    if erros and not eventos:
+        return _t("erro", idioma, erro=erros[0])
+    agora = agora or dt.datetime.now()
+    if proximo:
+        for inicio, fim, e in ocorrencias(eventos, agora, agora + dt.timedelta(days=60)):
+            quando = f"{inicio:%d/%m} {_hora(inicio, fim, e['dia_inteiro'], idioma)}"
+            return _t("proximo", idioma, quando=quando, titulo=e["titulo"], local=f" ({e['local']})" if e["local"] else "")
+        return _t("sem_proximo", idioma)
+    de, ate, periodo = intervalo
+    achados = ocorrencias(eventos, de, ate)
+    nome = _periodo_texto(periodo, idioma, de)
+    if not achados:
+        return _t("nada", idioma, quando=nome)
+    cabeca = _t("um" if len(achados) == 1 else "varios", idioma, Quando=_cap(nome), n=len(achados))
+    linhas = [cabeca]
+    multi_dia = (ate - de).days > 1
+    for inicio, fim, e in achados[:LIMITE_LISTA]:
+        dia = f"{TEXTOS['pt' if idioma == 'pt' else 'en']['dias'][inicio.weekday()][:3]} {inicio:%d/%m} " if multi_dia else ""
+        linhas.append(f"• {dia}{_hora(inicio, fim, e['dia_inteiro'], idioma)}  {e['titulo']}" + (f" ({e['local']})" if e["local"] else ""))
+    if len(achados) > LIMITE_LISTA:
+        linhas.append(_t("mais", idioma, n=len(achados) - LIMITE_LISTA))
+    return "\n".join(linhas)
+
+
+def _cap(s):
+    return s[:1].upper() + s[1:]
+
+
+# ---------------------------------------------------------------- notas em Markdown
+_CRIAR_NOTA = re.compile(r"^\s*(?:por favor,?\s+|please,?\s+)?(?:cri[ae]r?|fa[zç]a?|salv[ae]|escrev[ae]r?|anot[ae]r?|nova|create|make|take|new|add|save|write)\s+"
+                         r"(?:(?:uma|a|an)\s+)?(?:(?:nova|new)\s+)?n[oó]ta\b\s*(?:sobre|de|com|dizendo|que|about|saying|that|:|-)?\s*:?\s*(?P<corpo>.*)$",
+                         re.IGNORECASE | re.DOTALL)
+_CRIAR_NOTA_EN = re.compile(r"^\s*(?:please,?\s+)?(?:create|make|take|new|add|save|write)\s+(?:(?:a|an)\s+)?(?:(?:new)\s+)?note\b\s*(?:about|saying|that|:|-)?\s*:?\s*(?P<corpo>.*)$",
+                            re.IGNORECASE | re.DOTALL)
+_ACHAR_NOTA = re.compile(r"\b(?:minhas\s+)?notas?\s+(?:sobre|de|com|about|on|for)\s+(?P<termo>.+)$|"
+                         r"\b(?:procura|busca|ache|acha|procure|busque|search|find|look)\w*\s+(?:nas?\s+)?(?:minhas\s+)?(?:notas|my notes|in my notes|notes)\s+(?P<termo2>.+)$", re.IGNORECASE)
+_LER_NOTA = re.compile(r"^\s*(?:abre|abra|mostra|mostre|le|ler|leia|show|open|read)\s+(?:a\s+|the\s+|minha\s+|my\s+)*(?:nota|note)\s+(?P<termo>.+?)\s*$", re.IGNORECASE)
+
+
+def _nome_de_arquivo(texto):
+    base = normalizar(texto.strip().splitlines()[0] if texto.strip() else "nota")
+    slug = "-".join(re.findall(r"[a-z0-9]+", base)[:7]) or "nota"
+    return slug[:60]
+
+
+def criar_nota(corpo, pasta=None, agora=None):
+    """Grava uma nota nova e devolve o caminho. Nunca escreve por cima: se o nome existe, ganha -2, -3..."""
+    pasta = Path(pasta or pasta_de_notas())
+    pasta.mkdir(parents=True, exist_ok=True)
+    corpo = corpo.strip()
+    titulo = corpo.splitlines()[0][:80]
+    base = f"{(agora or dt.datetime.now()):%Y-%m-%d}-{_nome_de_arquivo(corpo)}"
+    destino, k = pasta / f"{base}.md", 2
+    while destino.exists():
+        destino = pasta / f"{base}-{k}.md"
+        k += 1
+    resto = "\n".join(corpo.splitlines()[1:]).strip()
+    destino.write_text(f"# {titulo}\n\n" + (resto + "\n" if resto else ""), encoding="utf-8")
+    return destino
+
+
+def achar_notas(termo, pasta=None, limite=5):
+    import tars_busca_arquivos as busca
+    pasta = Path(pasta or pasta_de_notas())
+    if not pasta.is_dir():
+        return []
+    achados = busca.buscar(termo, raiz=pasta, limite=limite * 2, indice=False)
+    return [a for a in achados if a["nome"].lower().endswith((".md", ".txt"))][:limite]
+
+
+def responder_notas(pedido, idioma, pasta=None):
+    """Cria, procura ou lê notas. None quando a frase não é de nota, ou as notas estão desligadas (sem pasta)."""
+    pasta = pasta or pasta_de_notas()
+    if pasta is None:
+        return None
+    m = _CRIAR_NOTA.match(pedido) or _CRIAR_NOTA_EN.match(pedido)
+    if m:
+        corpo = (m.group("corpo") or "").strip()
+        if not corpo:
+            return _t("nota_vazia", idioma)
+        destino = criar_nota(corpo, pasta)
+        return _t("nota_criada", idioma, nome=destino.name, pasta=str(destino.parent).replace(str(Path.home()), "~", 1))
+    m = _LER_NOTA.match(pedido)
+    if m:
+        termo = m.group("termo").strip(" ?.!")
+        achados = achar_notas(termo, pasta, 1)
+        if not achados:
+            return _t("nota_nao_achei", idioma, termo=termo)
+        texto = Path(achados[0]["caminho"]).read_text(encoding="utf-8", errors="replace").strip()
+        return _t("nota_texto", idioma, nome=achados[0]["nome"], texto=texto[:900] + ("…" if len(texto) > 900 else ""))
+    m = _ACHAR_NOTA.search(pedido)
+    if m:
+        termo = (m.group("termo") or m.group("termo2") or "").strip(" ?.!")
+        if not termo:
+            return None
+        achados = achar_notas(termo, pasta)
+        if not achados:
+            return _t("notas_nada", idioma, termo=termo)
+        linhas = [_t("notas_achei", idioma, n=len(achados))]
+        for a in achados:
+            linhas.append(f"• {a['nome']}" + (f": {a['trecho']}" if a["trecho"] else ""))
+        return "\n".join(linhas)
+    return None
+
+
+def responder(pedido, idioma):
+    """Agenda e notas por código; None se a frase não é com elas (ou as duas estão desligadas, o padrão)."""
+    return responder_notas(pedido, idioma) or responder_agenda(pedido, idioma)

app/tars_lembretes.py

@@ -0,0 +1,130 @@
+"""Lembretes e timers por frase (F4++ do PLANO_5.3.md, 07/11), sem o modelo.
+
+Medido antes: "me lembra de tomar água daqui a 30 minutos" virava uma memória ("Vou lembrar"), e "põe um timer de 5 minutos" tentava
+programas que não existem e dizia que o timer estava rodando. Nenhum aviso era agendado.
+Aqui a frase vira uma rotina de uma vez na agenda que o app já tem (tars_rotinas); na hora, o pedido "Lembrete: ..." sai por regra
+(resposta_da_rotina) e a janela avisa como avisa qualquer rotina. Só dispara com o openTARS aberto (ou na bandeja).
+"""
+import datetime as dt
+import re
+import unicodedata
+
+import tars_rotinas
+
+_NUMEROS = {"um": 1, "uma": 1, "dois": 2, "duas": 2, "tres": 3, "quatro": 4, "cinco": 5, "seis": 6, "sete": 7, "oito": 8, "nove": 9, "dez": 10,
+            "quinze": 15, "vinte": 20, "trinta": 30, "quarenta": 40, "meia": 30, "a": 1, "an": 1, "one": 1, "two": 2, "three": 3, "five": 5,
+            "ten": 10, "fifteen": 15, "twenty": 20, "thirty": 30}
+_N = r"(\d+|um|uma|dois|duas|tres|quatro|cinco|seis|sete|oito|nove|dez|quinze|vinte|trinta|quarenta|a|an|one|two|three|five|ten|fifteen|twenty|thirty)"
+_PEDE = re.compile(r"^(?:por favor |please |pode |can you )?(?:me lembra|me lembre|lembra-me|me avisa|me avise|avisa-me|remind me|ping me)\b")
+_PEDE_SEM_DUVIDA = re.compile(r"^(?:por favor |please |pode |can you )?(?:me lembra|me lembre|lembra-me|remind me)\b")
+_TIMER = re.compile(r"\b(?:timer|temporizador|cronometro|alarme|alarm)\b")
+_DAQUI = re.compile(r"\b(?:daqui a|daqui|em|dentro de|in|after)\s+" + _N + r"\s*(minutos?|minutes?|mins?|horas?|h|hours?|segundos?|seconds?|s)\b")
+_DURACAO = re.compile(_N + r"[\s-]*(minutos?|minutes?|mins?|horas?|hours?|h|segundos?|seconds?|s)\b")
+_HORA = re.compile(r"\b(?:as|a|at|pras|para as|ao meio)\s*(\d{1,2})(?:[:h](\d{2}))?\s*(?:h|horas)?\s*(am|pm|da manha|da tarde|da noite)?\b|\b(\d{1,2})\s*(am|pm)\b|\b(meio[- ]dia|noon|midnight|meia[- ]noite)\b")
+_AMANHA = re.compile(r"\b(amanha|tomorrow)\b")
+
+
+def _sem_acento(texto):
+    return "".join(c for c in unicodedata.normalize("NFKD", texto) if not unicodedata.combining(c)).lower().strip()
+
+
+def _numero(texto):
+    return int(texto) if texto.isdigit() else _NUMEROS.get(texto, 1)
+
+
+def _segundos(numero, unidade):
+    u = unidade[0]
+    return _numero(numero) * (3600 if u == "h" else 1 if u == "s" else 60)
+
+
+def _quando(n, agora):
+    """O datetime pedido, ou None se a frase não diz quando."""
+    a = _DAQUI.search(n)
+    if a:
+        return agora + dt.timedelta(seconds=_segundos(a.group(1), a.group(2)))
+    h = _HORA.search(n)
+    if not h:
+        return None
+    if h.group(6):
+        hora, minuto = (12, 0) if h.group(6).startswith(("meio", "noon")) else (0, 0)
+    else:
+        hora = int(h.group(1) or h.group(4))
+        minuto = int(h.group(2) or 0)
+        periodo = h.group(3) or h.group(5) or ""
+        if periodo in ("pm", "da tarde", "da noite") and hora < 12:
+            hora += 12
+        if periodo in ("am", "da manha") and hora == 12:
+            hora = 0
+    if hora > 23 or minuto > 59:
+        return None
+    alvo = agora.replace(hour=hora, minute=minuto, second=0, microsecond=0)
+    if _AMANHA.search(n):
+        alvo += dt.timedelta(days=1)
+    elif alvo <= agora:
+        alvo += dt.timedelta(days=1)
+    return alvo
+
+
+def _o_que(original, n):
+    """O texto do lembrete, com os acentos e as maiúsculas de quem escreveu: o pedido sem o "me lembra" e sem o quando."""
+    base = original.strip() if len(original.strip()) == len(n) else n
+    apagar = [False] * len(n)
+    for padrao in (_PEDE, _DAQUI, _HORA, _AMANHA):
+        for m in padrao.finditer(n):
+            for k in range(m.start(), m.end()):
+                apagar[k] = True
+    texto = " ".join("".join(" " if apagar[k] else c for k, c in enumerate(base)).split())
+    texto = re.sub(r"^(?:de|que|para|pra|to|that|about)\s+", "", texto, flags=re.IGNORECASE)
+    return re.sub(r"\s+(?:de|para|pra|to|e|and)$", "", texto, flags=re.IGNORECASE).strip(" ,.!?")
+
+
+def entender(texto, agora=None):
+    """{'tipo': 'lembrete'|'timer', 'quando': datetime, 'texto': ...}, {'tipo': 'falta_hora'} ou None."""
+    n = _sem_acento(texto)
+    agora = agora or dt.datetime.now().replace(microsecond=0)
+    if _TIMER.search(n) and re.search(r"\b(poe|ponha|coloca|coloque|liga|ligue|cria|crie|marca|marque|faz|set|start|put|make|timer de|timer for)\b|^timer\b", n):
+        d = _DURACAO.search(n)
+        if not d:
+            return {"tipo": "falta_hora"}
+        segundos = _segundos(d.group(1), d.group(2))
+        rotulo = f"{_numero(d.group(1))} {d.group(2)}"
+        return {"tipo": "timer", "quando": agora + dt.timedelta(seconds=segundos), "texto": rotulo}
+    if not _PEDE.search(n):
+        return None
+    quando = _quando(n, agora)
+    if quando is None:          # "me avisa se..." sem hora não é lembrete; "me lembra de..." sem hora pergunta quando
+        return {"tipo": "falta_hora"} if _PEDE_SEM_DUVIDA.search(n) else None
+    return {"tipo": "lembrete", "quando": quando, "texto": _o_que(texto, n) or ("isso" if re.search(r"[ãçáé]|\bde\b", n) else "this")}
+
+
+def agendar(pedido, idioma, agenda=None):
+    """Cria a rotina e devolve a frase de confirmação; None se a frase não é de lembrete nem de timer."""
+    e = entender(pedido)
+    if e is None:
+        return None
+    pt = idioma == "pt"
+    if e["tipo"] == "falta_hora":
+        return "Quando te lembro? Por exemplo: daqui a 30 minutos, ou amanhã às 9h." if pt else "When should I remind you? For example: in 30 minutes, or tomorrow at 9 am."
+    agenda = agenda or tars_rotinas.Agenda()
+    if e["tipo"] == "timer":
+        nome, aviso = (f"Timer de {e['texto']}", f"Timer: {e['texto']} terminaram.") if pt else (f"{e['texto']} timer", f"Timer: {e['texto']} are up.")
+    else:
+        nome, aviso = (("Lembrete: " if pt else "Reminder: ") + e["texto"])[:tars_rotinas.LIMITE_NOME], ("Lembrete: " if pt else "Reminder: ") + e["texto"]
+    rotina, erro = agenda.criar(nome, aviso, {"tipo": "uma_vez", "data": e["quando"].isoformat()}, ativa=True, aprovada=True, origem="pessoa")
+    if erro:
+        return ("Não consegui agendar (" + erro + ")." if pt else "I couldn't schedule it (" + erro + ").")
+    dia = "" if e["quando"].date() == dt.date.today() else (" de amanhã" if pt else " tomorrow") if e["quando"].date() == dt.date.today() + dt.timedelta(days=1) \
+        else f" de {e['quando']:%d/%m}" if pt else f" on {e['quando']:%m/%d}"
+    hora = f"{e['quando']:%H:%M}"
+    if e["tipo"] == "timer":
+        return f"Timer de {e['texto']} ligado: toca às {hora}{dia}." if pt else f"{e['texto']} timer set: it goes off at {hora}{dia}."
+    return f"Combinado: às {hora}{dia} eu te lembro de {e['texto']}." if pt else f"Got it: at {hora}{dia} I'll remind you to {e['texto']}."
+
+
+_AVISO = re.compile(r"^(lembrete|reminder|timer):\s*(.+)$", re.IGNORECASE)
+
+
+def resposta_da_rotina(pedido):
+    """Quando a rotina dispara, o pedido "Lembrete: X" volta como o próprio aviso, sem o modelo."""
+    a = _AVISO.match((pedido or "").strip())
+    return f"⏰ {pedido.strip()}" if a else None

app/tars_mais_modelos.py

@@ -10,9 +10,10 @@ Se um tamanho mudar lá, é aqui que se corrige.
 GRUPOS = (
     # 25/10 (decisão do Enzo): os modelos do openTARS no topo, o Lite primeiro e destacado (é o que fica em segundo plano)
     ("opentars", (
-        ("ProjectOpenTARS/Gargantua-2:lite", "Gargantua 2 Lite", 0.617, ("vision", "tools")),
-        ("ProjectOpenTARS/Gargantua-2:latest", "Gargantua 2", 1.6, ("vision", "tools")),
-        ("ProjectOpenTARS/Gargantua:code", "Gargantua Code", 1.1, ("tools",)),
+        ("ProjectOpenTARS/Gargantua-2.5:lite", "Gargantua Lite Gen 3", 4.4, ("vision", "tools")),
+        ("ProjectOpenTARS/Gargantua-2.5:latest", "Gargantua 2.5", 6.3, ("vision", "tools")),
+        ("ProjectOpenTARS/Gargantua-Pro:pro", "Gargantua Pro Gen 1", 7.6, ("vision", "tools")),
+        ("ProjectOpenTARS/Gargantua-Code-Gen2:code", "Gargantua Code Gen 2", 4.7, ("tools",)),
     )),
     ("bonsai", (
         ("bonsai-2:2b", "Bonsai 2 · 2B", 0.911, ("vision", "tools", "thinking")),
@@ -90,7 +91,7 @@ GRUPOS = (
 )
 
 CAPACIDADES = ("vision", "tools", "thinking", "image", "text")
-DESTAQUE = "ProjectOpenTARS/Gargantua-2:lite"
+DESTAQUE = "ProjectOpenTARS/Gargantua-2.5:lite"
 
 # Etiquetas que o Ollama mostra com outro nome quando o modelo foi baixado sem a tag (o mesmo arquivo).
 _APELIDOS = {
@@ -117,10 +118,6 @@ _APELIDOS = {
 }
 
 
-def todas_as_tags():
-    return [item[0] for _, itens in GRUPOS for item in itens]
-
-
 def _norma(tag):
     tag = tag.strip().lower()
     return tag if ":" in tag else tag + ":latest"
@@ -133,6 +130,8 @@ def instalado(tag, instalados):
 
 
 def tamanho_texto(gb):
+    if not gb:
+        return "?"                        # resultado da pesquisa na biblioteca: o tamanho só se sabe ao clicar
     return f"{round(gb * 1000)} MB" if gb < 1 else f"{gb:.1f} GB"
 
 
@@ -186,3 +185,55 @@ def recomendados(hw):
         if cabem:
             achados.append(max(cabem, key=lambda i: ("tools" in i[3], i[2], "thinking" not in i[3]))[0])
     return achados
+
+
+# ---------------------------------------------------------------- 11/11: pesquisa na loja
+
+def filtrar(itens, consulta):
+    """Os itens (tag, nome, gb, capacidades) em que todas as palavras da consulta aparecem no nome, na tag ou nas capacidades."""
+    palavras = str(consulta or "").lower().split()
+    return [i for i in itens if all(p in " ".join((i[0].split("/")[-1], i[1], *i[3])).lower() for p in palavras)]   # sem o dono: "pro" não casa com ProjectOpenTARS
+
+
+def _http(url, tempo=10):
+    import urllib.request
+    pedido = urllib.request.Request(url, headers={"User-Agent": "openTARS"})
+    with urllib.request.urlopen(pedido, timeout=tempo) as r:
+        return r.read(2_000_000).decode("utf-8", "replace")
+
+
+_CAPACIDADES_CONHECIDAS = ("vision", "tools", "thinking")
+
+
+def buscar_biblioteca(consulta, http=_http):
+    """Procura na biblioteca do Ollama (ollama.com/search). Devolve [{nome, descricao, capacidades, tamanhos}], só o que roda
+    local: modelos "cloud" e de usuário ficam de fora. Falha de rede levanta a exceção do `http`."""
+    import re
+    from urllib.parse import quote
+    pagina = http("https://ollama.com/search?q=" + quote(str(consulta).strip()))
+    achados = []
+    for bloco in pagina.split('<li  class="border-t')[1:]:
+        m = re.search(r'href="/library/([a-z0-9][\w.\-]*)"', bloco)
+        if not m:
+            continue
+        marcas = re.findall(r'>([^<>]{1,24})</span>', bloco)
+        descricao = re.search(r'<p class="[^"]*">([^<]+)</p>', bloco)
+        achados.append({
+            "nome": m.group(1),
+            "descricao": (descricao.group(1).strip() if descricao else ""),
+            "capacidades": tuple(c for c in _CAPACIDADES_CONHECIDAS if c in marcas),
+            "tamanhos": tuple(x for x in marcas if re.fullmatch(r"(e?\d+(\.\d+)?[bm]|latest)", x)),
+        })
+    return achados
+
+
+def tamanho_da_tag(nome_tag, http=_http):
+    """Tamanho do download (GB) de `nome:tag` segundo a página de tags da biblioteca, ou None se não achar."""
+    import re
+    nome, _, tag = nome_tag.partition(":")
+    pagina = http(f"https://ollama.com/library/{nome}/tags")
+    m = re.search(r'href="/library/' + re.escape(nome_tag) + r'"(.{0,900}?)([\d.]+)\s?(GB|MB)', pagina, re.S)
+    if not m:
+        return None
+    valor = float(m.group(2))
+    return valor if m.group(3) == "GB" else valor / 1000

app/tars_midia.py

@@ -0,0 +1,172 @@
+"""5.3 (F4+++): controle de música e vídeo por frase, sem o modelo: "pausa a música", "próxima faixa", "que música está tocando?".
+
+Linux: qualquer player que fale MPRIS (Spotify, VLC, Rhythmbox, Firefox, Chromium, o YouTube no navegador...) pelo `gdbus`, que vem
+com o GNOME e o glib. Windows: as teclas de mídia do sistema (tocar/pausar, próxima, anterior); o Windows não deixa um programa
+simples ler o que está tocando, então "que música é?" diz que não sabe. macOS: Spotify e Music pelo `osascript`.
+Só age quando a frase pede (nunca sozinho), e nunca abre nem fecha programas. Não foi usado com um player de verdade fora do Linux.
+"""
+import re
+import subprocess
+import sys
+import unicodedata
+
+import tars_plataforma as plataforma
+
+TEXTOS = {
+    "pt": {"play_pause": "Pronto.", "pause": "Pausei.", "play": "Toquei.", "next": "Próxima.", "previous": "Voltei.", "stop": "Parei.",
+           "nenhum": "Não achei nenhum player de música ou vídeo aberto.", "tocando": "Tocando agora: {titulo}{artista} ({app}).",
+           "pausado": "Está pausado: {titulo}{artista} ({app}).", "nada": "Não tem nada tocando agora.",
+           "nao_sei": "No Windows eu consigo pausar, tocar e pular, mas não sei dizer o que está tocando.", "falhou": "Não consegui controlar o player ({erro})."},
+    "en": {"play_pause": "Done.", "pause": "Paused.", "play": "Playing.", "next": "Next.", "previous": "Back.", "stop": "Stopped.",
+           "nenhum": "I didn't find any music or video player open.", "tocando": "Now playing: {titulo}{artista} ({app}).",
+           "pausado": "Paused: {titulo}{artista} ({app}).", "nada": "Nothing is playing right now.",
+           "nao_sei": "On Windows I can pause, play and skip, but I can't tell what is playing.", "falhou": "I couldn't control the player ({erro})."},
+}
+METODOS = {"play_pause": "PlayPause", "pause": "Pause", "play": "Play", "next": "Next", "previous": "Previous", "stop": "Stop"}
+TECLAS_WINDOWS = {"play_pause": 0xB3, "pause": 0xB3, "play": 0xB3, "next": 0xB0, "previous": 0xB1, "stop": 0xB2}
+COMANDOS_MAC = {"play_pause": "playpause", "pause": "pause", "play": "play", "next": "next track", "previous": "previous track", "stop": "pause"}
+PLAYERS_MAC = ("Spotify", "Music")
+
+
+def _t(chave, idioma, **kw):
+    s = TEXTOS["pt" if idioma == "pt" else "en"][chave]
+    return s.format(**kw) if kw else s
+
+
+def normalizar(texto):
+    return unicodedata.normalize("NFKD", str(texto)).encode("ascii", "ignore").decode().lower().strip(" .!?,")
+
+
+def _rodar(comando, tempo=4):
+    """O texto de saída, ou levanta OSError / SubprocessError / RuntimeError. (Os testes trocam esta função por uma falsa.)"""
+    r = subprocess.run(comando, capture_output=True, text=True, timeout=tempo)
+    if r.returncode != 0:
+        raise RuntimeError((r.stderr or r.stdout or f"código {r.returncode}").strip()[:120])
+    return r.stdout
+
+
+# ---------------------------------------------------------------- Linux: MPRIS pelo gdbus
+def _players_mpris():
+    saida = _rodar(["gdbus", "call", "--session", "--dest", "org.freedesktop.DBus", "--object-path", "/org/freedesktop/DBus",
+                    "--method", "org.freedesktop.DBus.ListNames"])
+    return [n for n in re.findall(r"'(org\.mpris\.MediaPlayer2\.[^']+)'", saida)]
+
+
+def _propriedade(player, nome):
+    return _rodar(["gdbus", "call", "--session", "--dest", player, "--object-path", "/org/mpris/MediaPlayer2", "--method",
+                   "org.freedesktop.DBus.Properties.Get", "org.mpris.MediaPlayer2.Player", nome])
+
+
+def _estado(player):
+    """'Playing', 'Paused' ou 'Stopped'; '' se não respondeu."""
+    try:
+        m = re.search(r"'(Playing|Paused|Stopped)'", _propriedade(player, "PlaybackStatus"))
+    except (OSError, RuntimeError, subprocess.SubprocessError):
+        return ""
+    return m.group(1) if m else ""
+
+
+def _escolher_player(players):
+    """O que está tocando; senão o que está pausado; senão o primeiro."""
+    estados = {p: _estado(p) for p in players}
+    for desejado in ("Playing", "Paused"):
+        for p, e in estados.items():
+            if e == desejado:
+                return p
+    return players[0] if players else None
+
+
+def _nome_do_player(player):
+    nome = player.split("org.mpris.MediaPlayer2.", 1)[-1]
+    return re.sub(r"\.instance\d+$", "", nome).capitalize()
+
+
+def _metadados(player):
+    texto = _propriedade(player, "Metadata")
+    titulo = re.search(r"'xesam:title': <'((?:[^'\\]|\\.)*)'>", texto)
+    artista = re.search(r"'xesam:artist': <\['((?:[^'\\]|\\.)*)'", texto)
+    desescapar = lambda s: s.replace("\\'", "'").replace("\\\\", "\\")  # noqa: E731
+    return (desescapar(titulo.group(1)) if titulo else "", desescapar(artista.group(1)) if artista else "")
+
+
+def _linux(acao, idioma):
+    players = _players_mpris()
+    if not players:
+        return _t("nenhum", idioma)
+    player = _escolher_player(players)
+    if acao == "agora":
+        titulo, artista = _metadados(player)
+        estado = _estado(player)
+        if not titulo or estado == "Stopped":
+            return _t("nada", idioma)
+        return _t("tocando" if estado == "Playing" else "pausado", idioma, titulo=titulo,
+                  artista=f", {artista}" if artista else "", app=_nome_do_player(player))
+    _rodar(["gdbus", "call", "--session", "--dest", player, "--object-path", "/org/mpris/MediaPlayer2", "--method",
+            f"org.mpris.MediaPlayer2.Player.{METODOS[acao]}"])
+    return _t(acao, idioma)
+
+
+# ---------------------------------------------------------------- Windows e macOS
+def _windows(acao, idioma):
+    if acao == "agora":
+        return _t("nao_sei", idioma)
+    import ctypes
+    tecla = TECLAS_WINDOWS[acao]
+    ctypes.windll.user32.keybd_event(tecla, 0, 0, 0)          # aperta e solta a tecla de mídia
+    ctypes.windll.user32.keybd_event(tecla, 0, 2, 0)
+    return _t(acao, idioma)
+
+
+def _mac(acao, idioma):
+    aberto = [p for p in PLAYERS_MAC if _rodar(["osascript", "-e", f'application "{p}" is running']).strip() == "true"]
+    if not aberto:
+        return _t("nenhum", idioma)
+    player = aberto[0]
+    if acao == "agora":
+        estado = _rodar(["osascript", "-e", f'tell application "{player}" to player state as string']).strip()
+        if estado not in ("playing", "paused"):
+            return _t("nada", idioma)
+        titulo = _rodar(["osascript", "-e", f'tell application "{player}" to name of current track']).strip()
+        artista = _rodar(["osascript", "-e", f'tell application "{player}" to artist of current track']).strip()
+        return _t("tocando" if estado == "playing" else "pausado", idioma, titulo=titulo, artista=f", {artista}" if artista else "", app=player)
+    _rodar(["osascript", "-e", f'tell application "{player}" to {COMANDOS_MAC[acao]}'])
+    return _t(acao, idioma)
+
+
+def agir(acao, idioma="pt"):
+    """Faz a ação ("play_pause", "pause", "play", "next", "previous", "stop" ou "agora") e devolve a frase da resposta."""
+    try:
+        sistema = plataforma.sistema()
+        return {"windows": _windows, "macos": _mac}.get(sistema, _linux)(acao, idioma)
+    except (OSError, RuntimeError, subprocess.SubprocessError, AttributeError) as e:
+        return _t("falhou", idioma, erro=str(e)[:80] or type(e).__name__)
+
+
+# ---------------------------------------------------------------- entender a frase
+_MIDIA = r"(musica|musicas|faixa|song|songs|track|music|player|spotify|video|videos|podcast)"
+_ACOES = (
+    ("agora", re.compile(rf"^(que|qual|what)\b.*\b{_MIDIA}\b.*\b(tocando|esta tocando|playing|is this)\b|^(what'?s|what is) (this song|playing( now)?)$|"
+                         r"^(que|qual) (musica|faixa) (e|eh|esta tocando)( essa| esta| agora)?$|^o que esta tocando( agora)?$")),
+    ("next", re.compile(rf"^(pula|pule|passa|passe|skip|next)\b( a| o| the)? {_MIDIA}$|^(proxima|proximo|next) (musica|faixa|song|track|video)$|"
+                        r"^(vai|va|ir) (para|pra|a|to) (a )?(proxima|next)( (musica|faixa|song|track))?$")),
+    ("previous", re.compile(rf"^(volta|volte|previous|go back)\b( a| o| the)? {_MIDIA}$|^(musica|faixa) anterior$|^(previous|last) (song|track|music)$")),
+    ("pause", re.compile(rf"^(pausa|pause|pare|para|stop)\b( a| o| the) {_MIDIA}$|^(pausa|pause)$|^(da|de|dar) pause$|^(pausa|pause) {_MIDIA}$")),
+    ("play", re.compile(rf"^(toca|toque|continua|continue|retoma|retome|resume|play|unpause)\b( a| o| the)? {_MIDIA}$|^(play)$|^(da|de|dar) play$|"
+                        r"^(volta|volte) a tocar$")),
+)
+
+
+def acao_da_frase(pedido):
+    """A ação de mídia que a frase pede, ou None. Só frases completas e sem objeto: "toca Legião Urbana" NÃO entra (é uma busca)."""
+    n = normalizar(pedido)
+    if len(n) > 80:
+        return None
+    for acao, regra in _ACOES:
+        if regra.search(n):
+            return acao
+    return None
+
+
+def responder(pedido, idioma):
+    acao = acao_da_frase(pedido)
+    return agir(acao, idioma) if acao else None

app/tars_modos.py

@@ -1,50 +1,61 @@
-"""openTARS 5.1: os três modos da interface (Lite, Base e Pro) e os ajustes avançados do Pro.
+"""openTARS 5.3: um modo só (Base) e a chave "dev", que acrescenta os ajustes avançados e o diagnóstico.
 
+Até a 5.2 havia Lite, Base e Pro; em 07/11 o Enzo decidiu: Base para todo mundo e "dev" nas Configurações.
+Quem usava o Pro atualiza com o dev ligado; quem usava o Lite ou o Base fica no Base.
 Só biblioteca padrão: a janela pergunta aqui o que mostrar, e o núcleo pergunta os ajustes avançados.
-A escolha fica em ~/.config/opentars/config.json ("modo" e "avancado"), o mesmo arquivo do idioma.
-
-- Lite: conversa, microfone, anexos e o básico das configurações. Tudo no automático.
-- Base: Lite + histórico, escolha de modelo, memória, rotinas, Probes e nuvem.
-- Pro: Base + ajustes avançados e diagnóstico.
+A escolha fica em ~/.config/opentars/config.json ("dev", e o "modo" antigo só para migrar).
 """
 
 import tars_i18n
 import tars_primeiro_uso as pu
 
-MODOS = ("lite", "base", "pro")
-PADRAO_INSTALACAO_NOVA = "base"
-PADRAO_ATUALIZACAO = "pro"       # quem já usava a 5.0 não perde nada do que via
+MODOS = ("base", "dev")
 
-_LITE = {"conversa", "microfone", "anexos", "cfg.geral", "cfg.assistente", "cfg.voz", "cfg.atualizacoes", "cfg.sobre"}
-_BASE = _LITE | {"historico", "seletor_modelo", "memoria", "cfg.memoria", "cfg.rotinas", "cfg.probes", "cfg.nuvem", "cfg.modelos", "cfg.gerenciar"}
-_PRO = _BASE | {"cfg.avancado", "cfg.diagnostico"}
-RECURSOS = {"lite": _LITE, "base": _BASE, "pro": _PRO}
+_BASE = {"conversa", "microfone", "anexos", "cfg.geral", "cfg.assistente", "cfg.voz", "cfg.atualizacoes", "cfg.sobre",
+         "historico", "seletor_modelo", "memoria", "cfg.memoria", "cfg.rotinas", "cfg.probes", "cfg.nuvem", "cfg.modelos", "cfg.gerenciar"}
+_DEV = _BASE | {"cfg.avancado", "cfg.diagnostico"}
+RECURSOS = {"base": _BASE, "dev": _DEV}
+_ANTIGOS = {"lite": "base", "pro": "dev"}
 
 CONTEXTOS = (4096, 8192, 16384, 32768)
 TEMPERATURA_MAXIMA = 1.5
 LIMITE_INSTRUCOES = 1500
 
 
+def dev_ligado():
+    config = tars_i18n.ler_config()
+    if isinstance(config.get("dev"), bool):
+        return config["dev"]
+    antigo = config.get("modo")
+    if antigo in ("lite", "base"):
+        return False
+    if antigo == "pro":
+        return True
+    # sem escolha gravada: quem atualizou da 5.0 via tudo (o antigo Pro); instalação nova começa no Base
+    return pu.primeiro_uso_concluido()
+
+
+def definir_dev(ligado):
+    tars_i18n.salvar_config(dev=bool(ligado))
+
+
 def modo_atual():
-    m = tars_i18n.ler_config().get("modo")
-    if m in MODOS:
-        return m
-    # sem escolha gravada: quem atualizou da 5.0 (primeiro uso já feito) fica no Pro; instalação nova, Base
-    return PADRAO_ATUALIZACAO if pu.primeiro_uso_concluido() else PADRAO_INSTALACAO_NOVA
+    return "dev" if dev_ligado() else "base"
 
 
 def definir_modo(modo):
-    if modo not in MODOS:
+    """Compatibilidade: "pro"/"dev" ligam o dev; "lite"/"base" desligam."""
+    if modo not in MODOS and modo not in _ANTIGOS:
         raise ValueError(f"modo desconhecido: {modo}")
-    tars_i18n.salvar_config(modo=modo)
+    definir_dev(_ANTIGOS.get(modo, modo) == "dev")
 
 
 def mostra(recurso, modo=None):
-    return recurso in RECURSOS[modo or modo_atual()]
+    return recurso in RECURSOS[_ANTIGOS.get(modo, modo) or modo_atual()]
 
 
 # ------------------------------------------------------------
-# Ajustes avançados (só valem no Pro; no Lite e no Base tudo fica no automático)
+# Ajustes avançados (só valem com o dev ligado; no Base tudo fica no automático)
 # ------------------------------------------------------------
 
 def _limpar(bruto):
@@ -65,13 +76,13 @@ def _limpar(bruto):
 
 
 def avancado_gravado():
-    """O que está gravado, valha ou não agora (a tela do Pro mostra isso)."""
+    """O que está gravado, valha ou não agora (a tela dos ajustes avançados mostra isso)."""
     return _limpar(tars_i18n.ler_config().get("avancado"))
 
 
 def avancado():
-    """Os ajustes que valem agora: os gravados no Pro; os padrões nos outros modos."""
-    return avancado_gravado() if modo_atual() == "pro" else _limpar({})
+    """Os ajustes que valem agora: os gravados, com o dev ligado; os padrões, no Base."""
+    return avancado_gravado() if dev_ligado() else _limpar({})
 
 
 def salvar_avancado(**mudancas):

app/tars_motor.py

@@ -0,0 +1,19 @@
+"""A porta do motor de modelos, como o tars_plataforma é a porta do sistema. Hoje o motor é o Ollama; a 5.3 troca pelo llama.cpp
+(PLANO_5.3.md, F9). Cada rota abaixo é uma operação que o motor novo precisa responder, e nenhum endereço da API mora fora daqui:
+tests/test_motor.py confere."""
+
+ROTAS = {
+    "versao": "/api/version",       # está de pé?
+    "modelos": "/api/tags",         # o que está instalado
+    "detalhes": "/api/show",        # capacidades, parâmetros e quantização de um modelo
+    "rodando": "/api/ps",           # o que está na memória
+    "conversa": "/api/chat",        # conversa com ferramentas, em streaming ou não
+    "gerar": "/api/generate",       # carregar e descarregar da memória (keep_alive), e pergunta simples
+    "baixar": "/api/pull",
+    "apagar": "/api/delete",
+    "conta": "/api/me",             # conta do ollama.com (nuvem): não existe no llama.cpp
+}
+
+
+def url(rota, host):
+    return f"{str(host).rstrip('/')}{ROTAS[rota]}"

app/tars_motor_local.py

@@ -0,0 +1,797 @@
+"""O motor do openTARS 5.3 (F9 do PLANO_5.3.md): llama.cpp por dentro, a API do Ollama por fora.
+
+Decidido pelo Enzo em 07/11: llama.cpp nos três sistemas, e a parte de visão (mmproj) só quando chega uma imagem. O app continua
+falando "Ollama" (13 chamadas, tars_motor.ROTAS): este processo responde nessas rotas e roda um `llama-server` por modelo em uso.
+
+- Modelos Gargantua baixados do Hugging Face (OpenTARS/...) com SHA-256 conferido, na pasta de dados do app.
+- `llama-server` da Release fixa do ggml-org (VERSAO_LLAMA), conferido pelo hash: Vulkan no Linux e no Windows (com reserva em CPU
+  se a máquina não tiver Vulkan), Metal no macOS.
+- Uma instância por modelo; a de visão só sobe quando o pedido traz imagem. Cada uma sai depois do keep_alive parado (padrão 5 min,
+  -1 = fica, 0 = sai já). O processo do motor fica aberto (como o serviço do Ollama), só com uns MB de Python.
+
+    python3 tars_motor_local.py --servir        (o app sobe sozinho quando precisa: garantir())
+"""
+import hashlib
+import json
+import os
+import platform
+import shutil
+import socket
+import subprocess
+import sys
+import tarfile
+import threading
+import time
+import urllib.error
+import urllib.request
+import zipfile
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+import tars_plataforma as plataforma
+
+PORTA = int(os.environ.get("TARS_MOTOR_PORTA") or 11435)
+URL = f"http://127.0.0.1:{PORTA}"
+VERSAO_LLAMA = "b12032"           # 01/11/2026: a mesma usada no Space; versão fixa, nada de "a mais nova do dia"
+_GH = f"https://github.com/ggml-org/llama.cpp/releases/download/{VERSAO_LLAMA}/"
+BINARIOS = {   # (sistema, máquina, aceleração): (arquivo, sha256)
+    ("linux", "x86_64", "vulkan"): ("llama-b12032-bin-ubuntu-vulkan-x64.tar.gz", "f75e7107f9450034c5467492c41e9ed91816e2d815fc4b802c6bd58de7d5b126"),
+    ("linux", "x86_64", "cpu"): ("llama-b12032-bin-ubuntu-x64.tar.gz", "9f10432ca3f66ef003a7a540aaffb9da0acadaefd05404521b9ab7a2436af304"),
+    ("windows", "x86_64", "vulkan"): ("llama-b12032-bin-win-vulkan-x64.zip", "19a8bbf269fa683ae7bc04f886c9c2a93e0655c2606f37d2b60069bf9e8bcc32"),
+    ("windows", "x86_64", "cpu"): ("llama-b12032-bin-win-cpu-x64.zip", "5296f5d18bb7d422c7c26f4bb9bc796d9d4f41e1312a8c296cff475bdc60d0d4"),
+    ("macos", "arm64", "metal"): ("llama-b12032-bin-macos-arm64.tar.gz", "00468fe833eb000b78a748122f5921b6c7b07dc82331a8d0c68196c69cb26382"),
+    ("macos", "x86_64", "cpu"): ("llama-b12032-bin-macos-x64.tar.gz", "291d99f3b6f45f67f73afe5381540f29928840a1a14d9c19d6595bd649a035fc"),
+}
+_HF = "https://huggingface.co/OpenTARS/{repo}/resolve/main/{arquivo}"
+_PARAMETROS_QWEN = "top_k                          20\ntop_p                          0.8\nrepeat_penalty                 1.05\ntemperature                    0.4"
+_PARAMETROS_GEMMA = "top_k                          64\ntop_p                          0.95\ntemperature                    0.4"
+CATALOGO = {   # a ficha que o Ollama dava para cada modelo (copiada em 07/11), mais os arquivos do Hugging Face
+    "ProjectOpenTARS/Gargantua-2.5:latest": {      # 13/11: Gemma 4 E4B, treino completo (1.949 passos)
+        "repo": "Gargantua-2.5", "gguf": ("gargantua-2.5-gemma4-e4b-Q4_K_M.gguf", "6b9e28f8c5eb8361796d0ecbe0d6a7bc3338f942820afcad388c5beeead795e1", 5302274208),
+        "mmproj": ("mmproj-gargantua-2.5-gemma4-e4b-F16.gguf", "c4347b30c7d9d176bb264fc6a14b81e44dde7266b9dd035ea60a91170d39775f", 990372160),
+        "capabilities": ["completion", "vision", "audio", "tools", "thinking"], "family": "gemma4", "parameter_size": "7.5B", "quantization_level": "Q4_K_M",
+        "parameters": _PARAMETROS_GEMMA},
+    "ProjectOpenTARS/Gargantua-2.5:lite": {        # 13/11: Gemma 4 E2B (Lite Gen 3), primeira época (a segunda inventou mais: 11 contra 4 de 48; decisão do Enzo)
+        "repo": "Gargantua-2.5-Lite", "gguf": ("gargantua-2.5-lite-gemma4-e2b-Q4_K_M.gguf", "08b61b2a5e860033565cc8a057c03331f9d8a1f1465e3bd45a0f55117bb26c29", 3416120096),
+        "mmproj": ("mmproj-gargantua-2.5-lite-gemma4-e2b-F16.gguf", "7024964e8736cfe91cee244670315bc6aa8582dcdfb7eb65e4b460df7681546a", 985653568),
+        "capabilities": ["completion", "vision", "audio", "tools", "thinking"], "family": "gemma4", "parameter_size": "4.6B", "quantization_level": "Q4_K_M",
+        "parameters": _PARAMETROS_GEMMA},
+    "ProjectOpenTARS/Gargantua-Pro:pro": {         # 11/11: Gemma 4 12B (Pro Gen 1, passo 300 de 368); o projetor tem de ser F32 (em F16 a placa corrompe)
+        "repo": "Gargantua-Pro", "gguf": ("gargantua-pro-gemma4-12b-Q4_K_M.gguf", "add484a229114d2cf6d7716f8264f830dd85a732591fbbc20439c3bebc943e0b", 7381383104),
+        "mmproj": ("mmproj-gargantua-pro-gemma4-12b-F32.gguf", "f35db6bf889c96f70f75350b371d2d0bd99d1bd62dea88c89594d245719d0267", 209521600),
+        "capabilities": ["completion", "vision", "tools", "thinking"], "family": "gemma4", "parameter_size": "11.95B", "quantization_level": "Q4_K_M",
+        "parameters": _PARAMETROS_GEMMA},
+    "ProjectOpenTARS/Gargantua-2:latest": {
+        "repo": "Gargantua-2", "gguf": ("gargantua-1.2-qwen3.5-2b-Q4_0.gguf", "3f2d450ec96be581d4b05f34eab703d1bd78e9f3e88a69f51e5efb6c5c61a86c", 1202486848),
+        "mmproj": ("mmproj-gargantua-qwen3.5-2b-Q8_0.gguf", "3156ce8710040751b6affc151eb66fe225dbe369a4ae51cd6298b1ae74087790", 364663840),
+        "capabilities": ["completion", "vision", "tools", "thinking"], "family": "qwen35", "parameter_size": "1.9B", "quantization_level": "Q4_0",
+        "parameters": _PARAMETROS_QWEN},
+    "ProjectOpenTARS/Gargantua-2:lite": {
+        "repo": "Gargantua-2-Lite", "gguf": ("gargantua-1.2-lite-qwen3.5-0.8b-Q4_0.gguf", "8736bc95729f047dfcf265e8fdaa8ed611bf9cf30c8d06e79b8e4f0d1cbbf29a", 501452352),
+        "mmproj": ("mmproj-gargantua-qwen3.5-0.8b-Q8_0.gguf", "1251de28a9e9c147e81a589d64e67470a5e8aa66a99834bb6902283a4d210519", 115923136),
+        "capabilities": ["completion", "vision", "tools", "thinking"], "family": "qwen35", "parameter_size": "752.39M", "quantization_level": "Q4_0",
+        "parameters": _PARAMETROS_QWEN},
+    "ProjectOpenTARS/Gargantua-Code-Gen2:code": {
+        "repo": "Gargantua-Code-Gen2", "gguf": ("gargantua-1.2-code-qwen2.5-coder-7b-Q4_K_M.gguf", "4c17360dcb36a3c0932f600df0eb6d7a3859e3ee7406fd4bbfb0f7c526904456", 4683073536),
+        "mmproj": None, "capabilities": ["completion", "tools", "insert"], "family": "qwen2", "parameter_size": "7.6B", "quantization_level": "Q4_K_M",
+        "parameters": _PARAMETROS_QWEN},
+}
+KEEP_ALIVE_PADRAO = 300
+OLLAMA = os.environ.get("TARS_OLLAMA_REAL") or "http://127.0.0.1:11434"   # modelos que não são do catálogo ("Mais modelos") seguem para ele
+CONTEXTO = 8192
+
+
+# ---------------------------------------------------------------- arquivos
+
+def pasta():
+    return plataforma.pastas()["dados"] / "motor"
+
+
+def pasta_modelos():
+    return pasta() / "modelos"
+
+
+def sistema_e_maquina():
+    maquina = platform.machine().lower()
+    maquina = {"amd64": "x86_64", "aarch64": "arm64"}.get(maquina, maquina)
+    return plataforma.sistema(), maquina
+
+
+def tem_vulkan():
+    s, _ = sistema_e_maquina()
+    if s == "windows":
+        return Path(os.environ.get("SystemRoot", r"C:\Windows"), "System32", "vulkan-1.dll").exists()
+    if s == "linux":
+        try:
+            return "libvulkan.so.1" in subprocess.run(["ldconfig", "-p"], capture_output=True, text=True, timeout=5).stdout
+        except (OSError, subprocess.SubprocessError):
+            return any(Path(p, "libvulkan.so.1").exists() for p in ("/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib"))
+    return False
+
+
+def variantes():
+    """As acelerações a tentar, da melhor para a reserva."""
+    s, m = sistema_e_maquina()
+    if s == "macos":
+        return ["metal"] if m == "arm64" else ["cpu"]
+    return (["vulkan"] if tem_vulkan() else []) + ["cpu"]
+
+
+def binario():
+    """O llama-server instalado (o da melhor variante que já foi baixada), ou None."""
+    s, m = sistema_e_maquina()
+    nome = "llama-server.exe" if s == "windows" else "llama-server"
+    for v in variantes():
+        raiz = pasta() / VERSAO_LLAMA / v
+        if raiz.exists():
+            achado = next(iter(sorted(raiz.rglob(nome))), None)
+            if achado:
+                return achado
+    return None
+
+
+def _sha256(caminho, algoritmo="sha256"):
+    h = hashlib.new(algoritmo)
+    with open(caminho, "rb") as f:
+        for bloco in iter(lambda: f.read(1 << 20), b""):
+            h.update(bloco)
+    return h.hexdigest()
+
+
+def baixar(url, destino, sha, ao_progresso=None, tentativas=3, algoritmo="sha256"):
+    """Baixa com retomada (.parcial), confere o hash (SHA-256; `algoritmo` troca, a imagem do Debian usa SHA-512) e só então põe
+    no lugar. Levanta ValueError se o hash não bater."""
+    for tentativa in range(tentativas):        # a conexão que trava no meio retoma do .parcial (visto em 07/11 no GitHub)
+        try:
+            return _baixar(url, destino, sha, ao_progresso, algoritmo)
+        except (TimeoutError, ConnectionError, urllib.error.URLError):
+            if tentativa == tentativas - 1:
+                raise
+
+
+def _baixar(url, destino, sha, ao_progresso, algoritmo="sha256"):
+    destino = Path(destino)
+    destino.parent.mkdir(parents=True, exist_ok=True)
+    parcial = destino.with_name(destino.name + ".parcial")
+    feito = parcial.stat().st_size if parcial.exists() else 0
+    pedido = urllib.request.Request(url, headers={"User-Agent": "openTARS", **({"Range": f"bytes={feito}-"} if feito else {})})
+    with urllib.request.urlopen(pedido, timeout=60) as r:
+        if feito and r.status != 206:
+            feito = 0                         # o servidor não retomou: começa de novo
+        total = feito + int(r.headers.get("Content-Length") or 0)
+        with open(parcial, "ab" if feito else "wb") as f:
+            for bloco in iter(lambda: r.read(1 << 16), b""):
+                f.write(bloco)
+                feito += len(bloco)
+                if ao_progresso:
+                    ao_progresso(feito, total)
+    if _sha256(parcial, algoritmo) != sha:
+        parcial.unlink(missing_ok=True)
+        raise ValueError(f"{destino.name}: {algoritmo.upper()} check failed")
+    os.replace(parcial, destino)
+    return destino
+
+
+def instalar_binario(ao_progresso=None):
+    """Baixa e extrai o llama-server desta máquina (a melhor variante; a de CPU se a outra não existir aqui)."""
+    s, m = sistema_e_maquina()
+    for v in variantes():
+        chave = (s, m, v)
+        if chave not in BINARIOS:
+            continue
+        arquivo, sha = BINARIOS[chave]
+        raiz = pasta() / VERSAO_LLAMA / v
+        pacote = baixar(_GH + arquivo, pasta() / "baixados" / arquivo, sha, ao_progresso)
+        temporario = raiz.with_name(raiz.name + ".novo")
+        shutil.rmtree(temporario, ignore_errors=True)
+        temporario.mkdir(parents=True)
+        if arquivo.endswith(".zip"):
+            with zipfile.ZipFile(pacote) as z:
+                z.extractall(temporario)
+        else:
+            with tarfile.open(pacote) as t:
+                t.extractall(temporario, **({"filter": "data"} if hasattr(tarfile, "data_filter") else {}))
+        for executavel in temporario.rglob("llama-server*"):
+            executavel.chmod(0o755)
+        shutil.rmtree(raiz, ignore_errors=True)
+        os.replace(temporario, raiz)
+        pacote.unlink(missing_ok=True)
+        return binario()
+    raise ValueError(f"no llama.cpp build for {s} {m}")
+
+
+def _blob_do_ollama(sha):
+    """O arquivo do Ollama com esse SHA-256 (o mesmo GGUF que publicamos no Hugging Face), se esta máquina tiver."""
+    pastas = [os.environ.get("OLLAMA_MODELS"), Path.home() / ".ollama" / "models", "/usr/share/ollama/.ollama/models", "/var/lib/ollama/models"]
+    for raiz in filter(None, pastas):
+        blob = Path(raiz) / "blobs" / f"sha256-{sha}"
+        if blob.is_file() and os.access(blob, os.R_OK):
+            return blob
+    return None
+
+
+def sha_do_arquivo(destino):
+    """SHA-256 de um GGUF já na pasta: lido da marca ao lado (gravada ao pôr o arquivo), ou calculado uma vez. O nome do arquivo
+    não muda entre versões do modelo; sem a marca, o modelo velho passava por novo para sempre (revisão de 13/11)."""
+    marca = Path(destino).with_name(Path(destino).name + ".sha256")
+    try:
+        return marca.read_text().strip()
+    except OSError:
+        sha = _sha256(destino)
+        marca.write_text(sha)
+        return sha
+
+
+def _atual(destino, sha):
+    return destino.exists() and sha_do_arquivo(destino) == sha
+
+
+def obter_arquivo(repo, arquivo, sha, ao_progresso=None):
+    """Põe um GGUF do catálogo na pasta: copiado do Ollama se ele já tem o mesmo arquivo, senão baixado do Hugging Face.
+    Um arquivo de mesmo nome com outro SHA-256 (versão anterior do modelo) é trocado."""
+    destino = pasta_modelos() / arquivo
+    if _atual(destino, sha):
+        return destino
+    blob = _blob_do_ollama(sha)
+    if not blob:
+        baixar(_HF.format(repo=repo, arquivo=arquivo), destino, sha, ao_progresso)
+    else:
+        destino.parent.mkdir(parents=True, exist_ok=True)
+        temporario = destino.with_name(destino.name + ".parcial")
+        shutil.copyfile(blob, temporario)
+        if _sha256(temporario) != sha:
+            temporario.unlink(missing_ok=True)
+            raise ValueError(f"{arquivo}: SHA-256 check failed")
+        os.replace(temporario, destino)
+    destino.with_name(destino.name + ".sha256").write_text(sha)
+    return destino
+
+
+def preparar(nomes, ao_progresso=None):
+    """Instala o llama-server e os modelos pedidos. Levanta OSError/ValueError."""
+    if binario() is None:
+        instalar_binario(ao_progresso)
+    for nome in nomes:
+        ficha = CATALOGO[_nome(nome)]
+        for arquivo, sha, _ in [ficha["gguf"]] + ([ficha["mmproj"]] if ficha.get("mmproj") else []):
+            obter_arquivo(ficha["repo"], arquivo, sha, ao_progresso)
+
+
+def _nome(nome):
+    """"ProjectOpenTARS/Gargantua-2" é o mesmo que ":latest", como no Ollama."""
+    return nome if not nome or ":" in nome.split("/")[-1] else nome + ":latest"
+
+
+def instalado(nome):
+    nome = _nome(nome)
+    ficha = CATALOGO.get(nome)
+    return bool(ficha) and (pasta_modelos() / ficha["gguf"][0]).exists()
+
+
+def instalados():
+    return [n for n in CATALOGO if instalado(n)]
+
+
+def escolhido():
+    """"llamacpp" (padrão) ou "ollama". A variável TARS_MOTOR vale mais que a config (chave "motor", Configurações > Avançado, de dev)."""
+    v = (os.environ.get("TARS_MOTOR") or "").strip().lower()
+    if v not in ("ollama", "llamacpp"):
+        try:
+            import tars_i18n
+            v = str(tars_i18n.ler_config().get("motor", "")).strip().lower()
+        except Exception:
+            v = ""
+    return "ollama" if v == "ollama" else "llamacpp"
+
+
+def pronto():
+    """O motor pode servir agora: tem o llama-server e ao menos um modelo."""
+    return binario() is not None and bool(instalados())
+
+
+# ---------------------------------------------------------------- instâncias do llama-server
+
+def _porta_livre():
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _pedir(url, corpo=None, tempo=900):
+    dados = json.dumps(corpo).encode() if corpo is not None else None
+    return urllib.request.urlopen(urllib.request.Request(url, dados, {"Content-Type": "application/json"}), timeout=tempo)
+
+
+class Instancia:
+    def __init__(self, nome, visao):
+        ficha = CATALOGO[nome]
+        self.nome, self.visao, self.porta = nome, visao, _porta_livre()
+        self.ultimo, self.keep_alive = time.time(), KEEP_ALIVE_PADRAO
+        comando = [str(binario()), "-m", str(pasta_modelos() / ficha["gguf"][0]), "--host", "127.0.0.1", "--port", str(self.porta),
+                   "-c", str(CONTEXTO), "--jinja", "--parallel", "1", "--no-webui", "-ngl", "99"]
+        if visao and ficha.get("mmproj"):
+            comando += ["--mmproj", str(pasta_modelos() / ficha["mmproj"][0])]
+        registro = open(pasta() / "llama-server.log", "ab")
+        extra = {"creationflags": 0x08000000} if plataforma.sistema() == "windows" else {"start_new_session": True}   # sem janela preta no Windows
+        self.processo = subprocess.Popen(comando, stdin=subprocess.DEVNULL, stdout=registro, stderr=registro, **extra)
+        limite = time.time() + 300
+        while time.time() < limite:
+            if self.processo.poll() is not None:
+                raise RuntimeError(f"llama-server stopped with code {self.processo.returncode} (see {pasta() / 'llama-server.log'})")
+            try:
+                with _pedir(f"http://127.0.0.1:{self.porta}/health", tempo=2) as r:
+                    if json.loads(r.read()).get("status") == "ok":
+                        return
+            except (OSError, ValueError):
+                time.sleep(0.3)
+        self.parar()
+        raise RuntimeError("llama-server took too long to start")
+
+    def parar(self):
+        if self.processo.poll() is None:
+            self.processo.terminate()
+            try:
+                self.processo.wait(10)
+            except subprocess.TimeoutExpired:
+                self.processo.kill()
+
+
+class Motor:
+    def __init__(self):
+        self.instancias, self.trava, self.ultimo_pedido = {}, threading.Lock(), time.time()
+
+    def instancia(self, nome, visao=False):
+        if nome not in CATALOGO or not instalado(nome):
+            raise KeyError(nome)
+        visao = visao and bool(CATALOGO[nome].get("mmproj"))
+        with self.trava:
+            chave = (nome, visao)
+            atual = self.instancias.get(chave)
+            if atual is None or atual.processo.poll() is not None:
+                atual = self.instancias[chave] = Instancia(nome, visao)
+            atual.ultimo = time.time()
+            return atual
+
+    def descarregar(self, nome):
+        with self.trava:
+            for chave in [c for c in self.instancias if c[0] == nome]:
+                self.instancias.pop(chave).parar()
+
+    def faxina(self):
+        """Tira da memória o que ficou parado além do keep_alive."""
+        agora = time.time()
+        with self.trava:
+            for chave, inst in list(self.instancias.items()):
+                if inst.processo.poll() is not None or (inst.keep_alive >= 0 and agora - inst.ultimo > inst.keep_alive):
+                    self.instancias.pop(chave).parar()
+
+    def parar_tudo(self):
+        with self.trava:
+            for inst in self.instancias.values():
+                inst.parar()
+            self.instancias.clear()
+
+
+def _keep_alive(valor):
+    if valor in (None, ""):
+        return KEEP_ALIVE_PADRAO
+    if isinstance(valor, (int, float)):
+        return float(valor)
+    texto = str(valor).strip()
+    unidade = {"s": 1, "m": 60, "h": 3600}.get(texto[-1:], 1)
+    try:
+        return float(texto[:-1] if texto[-1:] in "smh" else texto) * unidade
+    except ValueError:
+        return KEEP_ALIVE_PADRAO
+
+
+# ---------------------------------------------------------------- tradução Ollama <-> OpenAI (llama-server)
+
+def _parametros(nome):
+    p = {}
+    for linha in CATALOGO[nome]["parameters"].splitlines():
+        partes = linha.split()
+        if len(partes) == 2:
+            try:
+                p[partes[0]] = float(partes[1])
+            except ValueError:
+                pass
+    return p
+
+
+def para_openai(corpo, nome):
+    mensagens, pendentes, numero = [], [], 0
+    for m in corpo.get("messages", []):
+        saida = {"role": m["role"], "content": m.get("content") or ""}
+        if m.get("images") or m.get("audio"):     # "audio": WAV em base64, campo nosso (o Ollama não tem); o Gemma 4 ouve pelo projetor
+            saida["content"] = [{"type": "text", "text": saida["content"]}] + [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{i}"}} for i in m.get("images") or []] + [
+                {"type": "input_audio", "input_audio": {"data": a, "format": "wav"}} for a in m.get("audio") or []]
+        if m.get("tool_calls"):
+            saida["tool_calls"] = []
+            for chamada in m["tool_calls"]:
+                numero += 1
+                f = chamada.get("function", {})
+                argumentos = f.get("arguments")
+                saida["tool_calls"].append({"id": f"call_{numero}", "type": "function", "function": {
+                    "name": f.get("name"), "arguments": argumentos if isinstance(argumentos, str) else json.dumps(argumentos or {}, ensure_ascii=False)}})
+                pendentes.append(f"call_{numero}")
+        if m["role"] == "tool":
+            saida["tool_call_id"] = pendentes.pop(0) if pendentes else "call_0"
+            if m.get("tool_name") or m.get("name"):
+                saida["name"] = m.get("tool_name") or m.get("name")
+        mensagens.append(saida)
+    opcoes = {**_parametros(nome), **(corpo.get("options") or {})}
+    saida = {"messages": mensagens, "stream": bool(corpo.get("stream", True)), "cache_prompt": True,
+             "temperature": opcoes.get("temperature", 0.4), "top_p": opcoes.get("top_p", 0.8), "top_k": opcoes.get("top_k", 20),
+             "repeat_penalty": opcoes.get("repeat_penalty", 1.05), "chat_template_kwargs": {"enable_thinking": bool(corpo.get("think", False))}}
+    if opcoes.get("num_predict"):
+        saida["max_tokens"] = int(opcoes["num_predict"])
+    if corpo.get("tools"):
+        saida["tools"] = corpo["tools"]
+    if corpo.get("logprobs") and not (corpo.get("tools") and saida["stream"]):
+        saida["logprobs"] = True   # shortcut: o llama-server recusa logprobs com ferramentas em streaming; aí a conferência de confiança fica sem sinal
+    if corpo.get("format") == "json":
+        saida["response_format"] = {"type": "json_object"}
+    elif isinstance(corpo.get("format"), dict):
+        saida["response_format"] = {"type": "json_schema", "json_schema": {"schema": corpo["format"]}}
+    return saida
+
+
+def _chamadas_ollama(chamadas):
+    saida = []
+    for chamada in chamadas:
+        f = chamada.get("function", {})
+        argumentos = f.get("arguments")
+        try:
+            argumentos = json.loads(argumentos) if isinstance(argumentos, str) else argumentos
+        except ValueError:
+            argumentos = {}
+        saida.append({"function": {"name": f.get("name"), "arguments": argumentos or {}}})
+    return saida
+
+
+def _final(nome, inicio, mensagem, motivo, logprobs=None):
+    saida = {"model": nome, "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "message": mensagem, "done": True,
+             "done_reason": "length" if motivo == "length" else "stop", "total_duration": int((time.time() - inicio) * 1e9)}
+    if logprobs:
+        saida["logprobs"] = logprobs
+    return saida
+
+
+def _tem_imagem(corpo):
+    """Imagem ou áudio no pedido: o llama-server precisa do projetor (mmproj), que só carrega quando precisa."""
+    return any(m.get("images") or m.get("audio") for m in corpo.get("messages", []))
+
+
+# ---------------------------------------------------------------- o servidor com cara de Ollama
+
+def _do_ollama(caminho):
+    """Os modelos do Ollama da pessoa, menos os que o motor já tem (ele serve esses). Lista vazia se não há Ollama."""
+    try:
+        with urllib.request.urlopen(OLLAMA + caminho, timeout=1.5) as r:
+            return [m for m in json.loads(r.read()).get("models", []) if not instalado(m.get("name"))]
+    except (OSError, ValueError):
+        return []
+
+
+def _ficha_tags(nome):
+    ficha = CATALOGO[nome]
+    caminho = pasta_modelos() / ficha["gguf"][0]
+    tamanho = ficha["gguf"][2] + (ficha["mmproj"][2] if ficha.get("mmproj") else 0)
+    detalhes = {"parent_model": ficha["gguf"][0], "format": "gguf", "family": ficha["family"], "families": [ficha["family"]],
+                "parameter_size": ficha["parameter_size"], "quantization_level": ficha["quantization_level"]}
+    modificado = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(caminho.stat().st_mtime)) if caminho.exists() else ""
+    return {"name": nome, "model": nome, "modified_at": modificado, "size": tamanho, "digest": ficha["gguf"][1], "details": detalhes,
+            "capabilities": ficha["capabilities"]}
+
+
+def servir():
+    motor = Motor()
+    pasta().mkdir(parents=True, exist_ok=True)
+
+    class Pedido(BaseHTTPRequestHandler):
+        protocol_version = "HTTP/1.1"
+
+        def log_message(self, *a):
+            pass
+
+        def _json(self, dados, codigo=200):
+            corpo = json.dumps(dados, ensure_ascii=False).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 _linhas(self):
+            self.send_response(200)
+            self.send_header("Content-Type", "application/x-ndjson")
+            self.send_header("Transfer-Encoding", "chunked")
+            self.end_headers()
+
+        def _linha(self, dados):
+            texto = (json.dumps(dados, ensure_ascii=False) + "\n").encode()
+            self.wfile.write(f"{len(texto):x}\r\n".encode() + texto + b"\r\n")
+            self.wfile.flush()
+
+        def _fim_linhas(self):
+            self.wfile.write(b"0\r\n\r\n")
+            self.wfile.flush()
+
+        def do_GET(self):
+            motor.ultimo_pedido = time.time()
+            if self.path == "/api/version":
+                return self._json({"version": "0.40.6"})
+            if self.path == "/api/tags":
+                return self._json({"models": [_ficha_tags(n) for n in instalados()] + _do_ollama("/api/tags")})
+            if self.path == "/api/ps":
+                with motor.trava:
+                    vivos = {c[0] for c in motor.instancias}
+                return self._json({"models": [dict(_ficha_tags(n), size_vram=0, expires_at="") for n in vivos] + _do_ollama("/api/ps")})
+            if self.path in ("/", "/api"):
+                return self._json({"status": "openTARS motor (llama.cpp)"})
+            self._json({"error": "not found"}, 404)
+
+        def do_HEAD(self):
+            self.send_response(200)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+
+        def _repassar(self, corpo):
+            """Pedido de um modelo de fora do catálogo: vai igual para o Ollama da pessoa, e a resposta volta pedaço por pedaço."""
+            pedido = urllib.request.Request(OLLAMA + self.path, json.dumps(corpo).encode(), {"Content-Type": "application/json"}, method=self.command)
+            try:
+                r = urllib.request.urlopen(pedido, timeout=900)
+            except urllib.error.HTTPError as e:
+                r = e
+            except OSError:
+                return self._json({"error": f"model '{corpo.get('model') or corpo.get('name')}' not found"}, 404)
+            with r:
+                self.send_response(r.status)
+                self.send_header("Content-Type", r.headers.get("Content-Type") or "application/json")
+                self.send_header("Transfer-Encoding", "chunked")
+                self.end_headers()
+                for bloco in iter(lambda: r.read1(1 << 16), b""):
+                    self.wfile.write(f"{len(bloco):x}\r\n".encode() + bloco + b"\r\n")
+                    self.wfile.flush()
+                self._fim_linhas()
+
+        def do_DELETE(self):
+            corpo = self._corpo()
+            nome = _nome(corpo.get("model") or corpo.get("name"))
+            if nome not in CATALOGO:
+                return self._repassar(corpo)
+            motor.descarregar(nome)
+            ficha = CATALOGO[nome]
+            for arquivo in [ficha["gguf"]] + ([ficha["mmproj"]] if ficha.get("mmproj") else []):
+                (pasta_modelos() / arquivo[0]).unlink(missing_ok=True)
+            self._json({})
+
+        def _corpo(self):
+            tamanho = int(self.headers.get("Content-Length") or 0)
+            try:
+                return json.loads(self.rfile.read(tamanho) or b"{}")
+            except ValueError:
+                return {}
+
+        def do_POST(self):
+            motor.ultimo_pedido = time.time()
+            corpo = self._corpo()
+            nome = _nome(corpo.get("model") or corpo.get("name"))
+            if nome not in CATALOGO or (self.path != "/api/pull" and not instalado(nome) and self.path != "/api/delete"):
+                return self._repassar(corpo)
+            if self.path == "/api/show":
+                if nome not in CATALOGO or not instalado(nome):
+                    return self._json({"error": f"model '{nome}' not found"}, 404)
+                ficha = _ficha_tags(nome)
+                return self._json({"capabilities": ficha["capabilities"], "details": ficha["details"], "parameters": CATALOGO[nome]["parameters"],
+                                   # o hash do arquivo instalado: o aviso de modelo novo (tars_gerenciar_modelos.desatualizados) compara com o ollama.com
+                                   "modelfile": f"# {CATALOGO[nome]['gguf'][0]} sha256:{sha_do_arquivo(pasta_modelos() / CATALOGO[nome]['gguf'][0])}", "template": "", "model_info": {"general.architecture": CATALOGO[nome]["family"]}})
+            if self.path == "/api/pull":
+                return self._puxar(nome, corpo.get("stream", True))
+            if self.path == "/api/delete":
+                return self.do_DELETE()
+            if self.path == "/api/generate":
+                return self._gerar(nome, corpo)
+            if self.path == "/api/chat":
+                return self._conversar(nome, corpo)
+            self._json({"error": "not found"}, 404)
+
+        def _gerar(self, nome, corpo):
+            ka = _keep_alive(corpo.get("keep_alive"))
+            if nome not in CATALOGO or not instalado(nome):
+                return self._json({"error": f"model '{nome}' not found"}, 404)
+            if not corpo.get("prompt"):
+                if ka == 0:
+                    motor.descarregar(nome)
+                    return self._json({"model": nome, "response": "", "done": True, "done_reason": "unload"})
+                try:
+                    motor.instancia(nome).keep_alive = ka          # carregar na memória e deixar quente
+                except (RuntimeError, KeyError) as e:
+                    return self._json({"error": str(e)}, 500)
+                return self._json({"model": nome, "response": "", "done": True, "done_reason": "load"})
+            chat = {"messages": [{"role": "user", "content": corpo["prompt"], **({"images": corpo["images"]} if corpo.get("images") else {})}],
+                    "stream": False, "options": corpo.get("options"), "think": corpo.get("think", False), "keep_alive": corpo.get("keep_alive")}
+            if corpo.get("system"):
+                chat["messages"].insert(0, {"role": "system", "content": corpo["system"]})
+            resposta = self._responder(nome, chat)
+            if "error" in resposta:
+                return self._json(resposta, 500)
+            return self._json({"model": nome, "response": resposta["message"]["content"], "done": True, "done_reason": resposta["done_reason"]})
+
+        def _responder(self, nome, corpo):
+            """Pedido sem streaming: o último pedaço do /api/chat."""
+            inicio = time.time()
+            try:
+                inst = motor.instancia(nome, _tem_imagem(corpo))
+                inst.keep_alive = _keep_alive(corpo.get("keep_alive"))
+                pedido = dict(para_openai(corpo, nome), stream=False)
+                with _pedir(f"http://127.0.0.1:{inst.porta}/v1/chat/completions", pedido) as r:
+                    dados = json.loads(r.read())
+                inst.ultimo = time.time()
+            except urllib.error.HTTPError as e:
+                return {"error": e.read().decode("utf-8", "replace")[:300]}
+            except (OSError, RuntimeError, KeyError, ValueError) as e:
+                return {"error": str(e)}
+            escolha = dados["choices"][0]
+            m = escolha["message"]
+            mensagem = {"role": "assistant", "content": m.get("content") or ""}
+            if m.get("reasoning_content"):
+                mensagem["thinking"] = m["reasoning_content"]
+            if m.get("tool_calls"):
+                mensagem["tool_calls"] = _chamadas_ollama(m["tool_calls"])
+            logprobs = [{"token": x.get("token"), "logprob": x.get("logprob")} for x in (escolha.get("logprobs") or {}).get("content") or []]
+            return _final(nome, inicio, mensagem, escolha.get("finish_reason"), logprobs or None)
+
+        def _conversar(self, nome, corpo):
+            if nome not in CATALOGO or not instalado(nome):
+                return self._json({"error": f"model '{nome}' not found"}, 404)
+            if not corpo.get("stream", True):
+                resposta = self._responder(nome, corpo)
+                return self._json(resposta, 500 if "error" in resposta else 200)
+            inicio = time.time()
+            try:
+                inst = motor.instancia(nome, _tem_imagem(corpo))
+                inst.keep_alive = _keep_alive(corpo.get("keep_alive"))
+                r = _pedir(f"http://127.0.0.1:{inst.porta}/v1/chat/completions", dict(para_openai(corpo, nome), stream=True))
+            except urllib.error.HTTPError as e:
+                return self._json({"error": e.read().decode("utf-8", "replace")[:300]}, 500)
+            except (OSError, RuntimeError, KeyError) as e:
+                return self._json({"error": str(e)}, 500)
+            self._linhas()
+            chamadas, motivo, logprobs = {}, "stop", []
+            with r:
+                for bruta in r:
+                    linha = bruta.decode("utf-8", "replace").strip()
+                    if not linha.startswith("data:"):
+                        continue
+                    dado = linha[5:].strip()
+                    if dado == "[DONE]":
+                        break
+                    try:
+                        pedaco = json.loads(dado)
+                    except ValueError:
+                        continue
+                    for escolha in pedaco.get("choices") or []:
+                        delta = escolha.get("delta") or {}
+                        motivo = escolha.get("finish_reason") or motivo
+                        for c in delta.get("tool_calls") or []:       # as chamadas chegam em pedaços: junta pelo índice
+                            atual = chamadas.setdefault(c.get("index", 0), {"function": {"name": "", "arguments": ""}})
+                            f = c.get("function") or {}
+                            atual["function"]["name"] += f.get("name") or ""
+                            atual["function"]["arguments"] += f.get("arguments") or ""
+                        logprobs += [{"token": x.get("token"), "logprob": x.get("logprob")} for x in (escolha.get("logprobs") or {}).get("content") or []]
+                        texto = delta.get("content") or ""
+                        pensado = delta.get("reasoning_content") or ""
+                        if texto or pensado:
+                            mensagem = {"role": "assistant", "content": texto}
+                            if pensado:
+                                mensagem["thinking"] = pensado
+                            self._linha({"model": nome, "message": mensagem, "done": False})
+            inst.ultimo = time.time()
+            final = {"role": "assistant", "content": ""}
+            if chamadas:
+                final["tool_calls"] = _chamadas_ollama([chamadas[i] for i in sorted(chamadas)])
+            self._linha(_final(nome, inicio, final, motivo, logprobs or None))
+            self._fim_linhas()
+
+        def _puxar(self, nome, stream):
+            if nome not in CATALOGO:
+                return self._json({"error": f"pull model manifest: file does not exist ({nome})"}, 404)
+            ficha = CATALOGO[nome]
+            arquivos = [ficha["gguf"]] + ([ficha["mmproj"]] if ficha.get("mmproj") else [])
+            if stream:
+                self._linhas()
+            avisar = (lambda d: self._linha(d)) if stream else (lambda d: None)
+            try:
+                avisar({"status": "pulling manifest"})
+                if binario() is None:
+                    avisar({"status": "downloading llama.cpp"})
+                    instalar_binario(lambda f, t: None)
+                for arquivo, sha, tamanho in arquivos:
+                    destino = pasta_modelos() / arquivo
+                    if _atual(destino, sha):
+                        avisar({"status": f"pulling {sha[:12]}", "digest": f"sha256:{sha}", "total": tamanho, "completed": tamanho})
+                        continue
+                    ultimo = [0.0]
+
+                    def progresso(feito, total, sha=sha, tamanho=tamanho):
+                        if time.time() - ultimo[0] > 0.5 or feito >= (total or tamanho):
+                            ultimo[0] = time.time()
+                            avisar({"status": f"pulling {sha[:12]}", "digest": f"sha256:{sha}", "total": total or tamanho, "completed": feito})
+                    obter_arquivo(ficha["repo"], arquivo, sha, progresso)
+                avisar({"status": "verifying sha256 digest"})
+                avisar({"status": "success"})
+            except (OSError, ValueError) as e:
+                if stream:
+                    avisar({"error": str(e)})
+                else:
+                    return self._json({"error": str(e)}, 500)
+            if stream:
+                self._fim_linhas()
+            else:
+                self._json({"status": "success"})
+
+    class Servidor(ThreadingHTTPServer):
+        def server_bind(self):      # o original chama socket.getfqdn(), que no macOS travou mais de 20 s (CI de 07/11)
+            import socketserver
+            socketserver.TCPServer.server_bind(self)
+            self.server_name, self.server_port = "127.0.0.1", self.server_address[1]
+
+    servidor = Servidor(("127.0.0.1", PORTA), Pedido)
+    servidor.daemon_threads = True
+    print(f"motor escutando em {URL}", file=sys.stderr, flush=True)
+
+    def vigiar():
+        while True:
+            time.sleep(15)
+            motor.faxina()
+    threading.Thread(target=vigiar, daemon=True).start()
+    import signal
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))   # sem isso o finally não roda e os llama-server ficam órfãos (visto em 13/11)
+    try:
+        servidor.serve_forever()
+    finally:
+        motor.parar_tudo()
+
+
+# ---------------------------------------------------------------- o lado do app
+
+def respondendo(tempo=1.0):
+    try:
+        with urllib.request.urlopen(f"{URL}/api/version", timeout=tempo) as r:
+            return r.status == 200
+    except (OSError, ValueError):
+        return False
+
+
+def garantir(espera=15):
+    """Deixa o motor de pé (sobe em segundo plano se não estiver) e devolve o endereço, ou None se não deu."""
+    if respondendo():
+        return URL
+    if binario() is None:        # sem modelo também sobe: o primeiro uso baixa os modelos pelo /api/pull dele
+        return None
+    extra = {"creationflags": 0x08000000 | 0x00000200} if plataforma.sistema() == "windows" else {"start_new_session": True}
+    pasta().mkdir(parents=True, exist_ok=True)
+    with open(pasta() / "motor.log", "ab") as registro:
+        subprocess.Popen([sys.executable, str(Path(__file__).resolve()), "--servir"], stdin=subprocess.DEVNULL, stdout=registro, stderr=registro,
+                         cwd=str(Path(__file__).resolve().parent), **extra)
+    limite = time.time() + espera
+    while time.time() < limite:
+        if respondendo(0.5):
+            return URL
+        time.sleep(0.2)
+    return None
+
+
+if __name__ == "__main__":
+    if "--servir" in sys.argv:
+        if os.environ.get("TARS_MOTOR_DEPURAR"):          # o CI do macOS: se travar, a pilha vai para o motor.log
+            import faulthandler
+            faulthandler.dump_traceback_later(20, exit=False)
+        servir()
+    elif "--instalar" in sys.argv:          # baixa o llama-server e os modelos pedidos (ou o 2B e o Lite)
+        nomes = [a for a in sys.argv[2:] if not a.startswith("-")] or ["ProjectOpenTARS/Gargantua-2.5:lite", "ProjectOpenTARS/Gargantua-2.5:latest"]
+        preparar(nomes)
+        print("pronto:", instalados())