llamagent 0.1.0__tar.gz

llamagent-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,47 @@
+# Intégration continue (étape 18) : à chaque push sur main et à chaque pull
+# request, les tests tournent sous Linux, Windows et macOS, avec Python 3.11
+# à 3.13. Puis le paquet est construit, vérifié et installé comme le ferait
+# un utilisateur.
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  tests:
+    name: Tests (${{ matrix.os }}, Python ${{ matrix.python }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false # voir tous les systèmes en échec, pas seulement le premier
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Installer les dépendances (versions exactes de uv.lock)
+        run: uv sync --locked
+      - name: Tests
+        run: uv run pytest -q
+
+  package:
+    name: Paquet
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Construire
+        run: uv build
+      - name: Vérifier le contenu
+        run: python3 scripts/check_package.py
+      - name: Installer le paquet construit et le lancer
+        run: |
+          uv tool install dist/*.whl
+          LLAMAGENT="$(uv tool dir --bin)/llamagent"
+          "$LLAMAGENT" --version
+          mkdir "$RUNNER_TEMP/projet" && cd "$RUNNER_TEMP/projet"
+          echo /quit | "$LLAMAGENT"

llamagent-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,64 @@
+# Publication (étape 18) : quand une étiquette de version (v0.1.0...) est
+# poussée, le paquet est testé, construit et vérifié, publié sur TestPyPI,
+# puis sur PyPI après validation manuelle (environnement « pypi » protégé).
+# Aucun mot de passe ni jeton : PyPI fait confiance à ce workflow précis
+# (Trusted Publishing), qui prouve son identité avec un jeton OIDC de GitHub.
+name: Publication
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    name: Tester et construire
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Tests
+        run: |
+          uv sync --locked
+          uv run pytest -q
+      - name: Construire
+        run: uv build
+      - name: Vérifier le paquet et la version
+        run: python3 scripts/check_package.py "$GITHUB_REF_NAME"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  testpypi:
+    name: Publier sur TestPyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/llamagent
+    permissions:
+      id-token: write # nécessaire au Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  pypi:
+    name: Publier sur PyPI
+    needs: testpypi
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/llamagent
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

llamagent-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

llamagent-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

llamagent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nils Malmberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llamagent-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.5
+Name: llamagent
+Version: 0.1.0
+Summary: Un agent de code minimal autour d'Ollama, écrit à la main pour comprendre chaque brique.
+Project-URL: Documentation, https://nils-malmberg.fr/project8.html
+Project-URL: Repository, https://github.com/nils-malmberg/llamagent
+Project-URL: Issues, https://github.com/nils-malmberg/llamagent/issues
+Author: Nils Malmberg
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,coding-agent,llm,ollama,tutoriel
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Natural Language :: French
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: requests>=2.34.2
+Description-Content-Type: text/markdown
+
+# llamagent
+
+Un agent de code minimal en Python, écrit à la main pour comprendre comment fonctionne un agent de code : boucle agentique, harness, outils, prompt système, skills et garde-fous.
+
+Il pilote un LLM local servi par [Ollama](https://ollama.com) (par défaut `qwen3.5:4b`) via l'API native `/api/chat`. Aucun framework d'agent : une seule dépendance, `requests`.
+
+![Interface de llamagent : la mascotte, puis chaque tour de la boucle avec le modèle, le harness et l'outil](https://nils-malmberg.fr/media/projets/project8/interface.png)
+
+📖 Tutoriel complet, étape par étape : [nils-malmberg.fr/project8.html](https://nils-malmberg.fr/project8.html)
+
+## Installation
+
+Prérequis : un serveur [Ollama](https://ollama.com) avec un modèle qui gère les outils (`ollama pull qwen3.5:4b`).
+
+```bash
+uv tool install llamagent      # ou : pipx install llamagent
+```
+
+Si Ollama ne tourne pas sur la même machine, indiquez son adresse dans `~/.llamagent/config.toml` (sous Windows : `C:\Users\<vous>\.llamagent\config.toml`) :
+
+```toml
+url = "http://192.168.1.76:11434"
+```
+
+## Utilisation
+
+```bash
+cd chemin/vers/mon-projet
+llamagent                                   # mode conversation
+llamagent "Trouve le bug dans @calc.py"     # une seule demande, puis on quitte
+llamagent -c                                # reprendre la dernière conversation
+llamagent -m qwen3.5:9b -t 0.5              # choisir le modèle et la température
+llamagent --help
+```
+
+Le dossier depuis lequel on lance `llamagent` devient le dossier de travail : les outils de fichiers ne peuvent ni lire ni écrire ailleurs.
+
+Chaque tour de la boucle est affiché avec ses trois acteurs : le **modèle** (ce qu'il demande), le **harness** (ce que les garde-fous en font) et l'**outil** (ce qu'il renvoie).
+
+### Commandes
+
+| Commande | Rôle |
+|---|---|
+| `/help` | liste des commandes |
+| `/init` | préparer le projet : crée `AGENTS.md` et le dossier `.llamagent/` |
+| `/config` | réglages actuels |
+| `/models`, `/model qwen3.5:9b` | modèles installés, changer de modèle |
+| `/temp 0.5`, `/ctx 16384` | changer la température, la taille du contexte |
+| `/skills`, `/skill corriger-un-bug` | skills disponibles, charger une skill |
+| `/context`, `/compact` | ce qui occupe le contexte, le compacter (automatique à 80 %) |
+| `/sessions`, `/resume 2`, `/delete 2` | conversations sauvegardées |
+| `/allow python -m pytest` | lancer une commande sans confirmation pour la session |
+| `/clear`, `/quit` | effacer la conversation, quitter |
+
+`@chemin` dans une demande joint le contenu du fichier.
+
+## Configuration
+
+Les réglages viennent de cinq sources ; chacune remplace la précédente :
+
+1. les valeurs par défaut ;
+2. le fichier global `~/.llamagent/config.toml` ;
+3. le fichier du projet `.llamagent/config.toml` ;
+4. les variables d'environnement `OLLAMA_URL` et `OLLAMA_MODEL` ;
+5. les options de la ligne de commande.
+
+```toml
+url = "http://localhost:11434"
+model = "qwen3.5:4b"
+temperature = 0.2
+num_ctx = 8192
+allowed_commands = ["python -m pytest", "git status", "git diff"]
+```
+
+Autres variables : `LLAMAGENT_WORKDIR` (dossier de travail) et `NO_COLOR` (affichage sans couleurs).
+
+## Personnaliser un projet
+
+```
+mon-projet/
+├── AGENTS.md              # consignes du projet, ajoutées au prompt système
+└── .llamagent/
+    ├── .gitignore         # exclut sessions/ de git
+    ├── config.toml        # réglages du projet
+    ├── sessions/          # conversations sauvegardées
+    └── skills/            # skills du projet (remplacent les globales de même nom)
+```
+
+`/init` crée ces fichiers. Une skill est un fichier Markdown avec un en-tête `description:` ; le modèle la charge avec l'outil `load_skill` quand la demande correspond.
+
+```markdown
+---
+description: Écrire des tests pytest pour un module Python.
+---
+# Écrire des tests pytest
+
+1. Lis le module à tester avec read_file.
+2. ...
+```
+
+## Limites
+
+- Seuls les outils de fichiers sont confinés au dossier de travail. Une commande lancée par `run_command` peut écrire ailleurs : la protection est la confirmation `[o/N]`. Les commandes autorisées sont un confort, pas une barrière de sécurité.
+- Avec un modèle 4B et 8192 tokens, le contexte se remplit vite : `/compact` le résume.
+- Un petit modèle peut inventer un outil, se tromper de chemin ou répéter un appel. Les erreurs lui sont renvoyées pour qu'il se corrige, mais il n'y arrive pas toujours.
+
+## Développement
+
+```bash
+git clone https://github.com/nils-malmberg/llamagent.git
+cd llamagent
+uv sync
+uv run pytest -q
+uv tool install -e .     # la commande llamagent utilise ce dossier
+```
+
+Chaque push lance les tests sous Windows, macOS et Linux (Python 3.11 à 3.13). Pour publier une version : mettre à jour `version` dans `pyproject.toml`, puis créer et pousser l'étiquette correspondante (`git tag v0.1.0 && git push origin v0.1.0`) ; le paquet est publié sur TestPyPI, puis sur PyPI après validation.
+
+## Licence
+
+MIT, voir [LICENSE](https://github.com/nils-malmberg/llamagent/blob/main/LICENSE).

llamagent-0.1.0/README.md

@@ -0,0 +1,121 @@
+# llamagent
+
+Un agent de code minimal en Python, écrit à la main pour comprendre comment fonctionne un agent de code : boucle agentique, harness, outils, prompt système, skills et garde-fous.
+
+Il pilote un LLM local servi par [Ollama](https://ollama.com) (par défaut `qwen3.5:4b`) via l'API native `/api/chat`. Aucun framework d'agent : une seule dépendance, `requests`.
+
+![Interface de llamagent : la mascotte, puis chaque tour de la boucle avec le modèle, le harness et l'outil](https://nils-malmberg.fr/media/projets/project8/interface.png)
+
+📖 Tutoriel complet, étape par étape : [nils-malmberg.fr/project8.html](https://nils-malmberg.fr/project8.html)
+
+## Installation
+
+Prérequis : un serveur [Ollama](https://ollama.com) avec un modèle qui gère les outils (`ollama pull qwen3.5:4b`).
+
+```bash
+uv tool install llamagent      # ou : pipx install llamagent
+```
+
+Si Ollama ne tourne pas sur la même machine, indiquez son adresse dans `~/.llamagent/config.toml` (sous Windows : `C:\Users\<vous>\.llamagent\config.toml`) :
+
+```toml
+url = "http://192.168.1.76:11434"
+```
+
+## Utilisation
+
+```bash
+cd chemin/vers/mon-projet
+llamagent                                   # mode conversation
+llamagent "Trouve le bug dans @calc.py"     # une seule demande, puis on quitte
+llamagent -c                                # reprendre la dernière conversation
+llamagent -m qwen3.5:9b -t 0.5              # choisir le modèle et la température
+llamagent --help
+```
+
+Le dossier depuis lequel on lance `llamagent` devient le dossier de travail : les outils de fichiers ne peuvent ni lire ni écrire ailleurs.
+
+Chaque tour de la boucle est affiché avec ses trois acteurs : le **modèle** (ce qu'il demande), le **harness** (ce que les garde-fous en font) et l'**outil** (ce qu'il renvoie).
+
+### Commandes
+
+| Commande | Rôle |
+|---|---|
+| `/help` | liste des commandes |
+| `/init` | préparer le projet : crée `AGENTS.md` et le dossier `.llamagent/` |
+| `/config` | réglages actuels |
+| `/models`, `/model qwen3.5:9b` | modèles installés, changer de modèle |
+| `/temp 0.5`, `/ctx 16384` | changer la température, la taille du contexte |
+| `/skills`, `/skill corriger-un-bug` | skills disponibles, charger une skill |
+| `/context`, `/compact` | ce qui occupe le contexte, le compacter (automatique à 80 %) |
+| `/sessions`, `/resume 2`, `/delete 2` | conversations sauvegardées |
+| `/allow python -m pytest` | lancer une commande sans confirmation pour la session |
+| `/clear`, `/quit` | effacer la conversation, quitter |
+
+`@chemin` dans une demande joint le contenu du fichier.
+
+## Configuration
+
+Les réglages viennent de cinq sources ; chacune remplace la précédente :
+
+1. les valeurs par défaut ;
+2. le fichier global `~/.llamagent/config.toml` ;
+3. le fichier du projet `.llamagent/config.toml` ;
+4. les variables d'environnement `OLLAMA_URL` et `OLLAMA_MODEL` ;
+5. les options de la ligne de commande.
+
+```toml
+url = "http://localhost:11434"
+model = "qwen3.5:4b"
+temperature = 0.2
+num_ctx = 8192
+allowed_commands = ["python -m pytest", "git status", "git diff"]
+```
+
+Autres variables : `LLAMAGENT_WORKDIR` (dossier de travail) et `NO_COLOR` (affichage sans couleurs).
+
+## Personnaliser un projet
+
+```
+mon-projet/
+├── AGENTS.md              # consignes du projet, ajoutées au prompt système
+└── .llamagent/
+    ├── .gitignore         # exclut sessions/ de git
+    ├── config.toml        # réglages du projet
+    ├── sessions/          # conversations sauvegardées
+    └── skills/            # skills du projet (remplacent les globales de même nom)
+```
+
+`/init` crée ces fichiers. Une skill est un fichier Markdown avec un en-tête `description:` ; le modèle la charge avec l'outil `load_skill` quand la demande correspond.
+
+```markdown
+---
+description: Écrire des tests pytest pour un module Python.
+---
+# Écrire des tests pytest
+
+1. Lis le module à tester avec read_file.
+2. ...
+```
+
+## Limites
+
+- Seuls les outils de fichiers sont confinés au dossier de travail. Une commande lancée par `run_command` peut écrire ailleurs : la protection est la confirmation `[o/N]`. Les commandes autorisées sont un confort, pas une barrière de sécurité.
+- Avec un modèle 4B et 8192 tokens, le contexte se remplit vite : `/compact` le résume.
+- Un petit modèle peut inventer un outil, se tromper de chemin ou répéter un appel. Les erreurs lui sont renvoyées pour qu'il se corrige, mais il n'y arrive pas toujours.
+
+## Développement
+
+```bash
+git clone https://github.com/nils-malmberg/llamagent.git
+cd llamagent
+uv sync
+uv run pytest -q
+uv tool install -e .     # la commande llamagent utilise ce dossier
+```
+
+Chaque push lance les tests sous Windows, macOS et Linux (Python 3.11 à 3.13). Pour publier une version : mettre à jour `version` dans `pyproject.toml`, puis créer et pousser l'étiquette correspondante (`git tag v0.1.0 && git push origin v0.1.0`) ; le paquet est publié sur TestPyPI, puis sur PyPI après validation.
+
+## Licence
+
+MIT, voir [LICENSE](https://github.com/nils-malmberg/llamagent/blob/main/LICENSE).

llamagent-0.1.0/demo/stats.py

@@ -0,0 +1,19 @@
+"""Petit script de statistiques sur des notes.
+
+Il contient un bug volontaire : c'est la démo de llamagent.
+"""
+
+
+def moyenne(notes: list[float]) -> float:
+    total = 0
+    for i in range(1, len(notes)):
+        total += notes[i]
+    return total / len(notes)
+
+
+if __name__ == "__main__":
+    notes = [12, 15, 9, 18]
+    resultat = moyenne(notes)
+    print(f"Moyenne des notes {notes} : {resultat}")
+    assert resultat == 13.5, f"moyenne attendue : 13.5, obtenue : {resultat}"
+    print("OK")

llamagent-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "llamagent"
+version = "0.1.0"
+description = "Un agent de code minimal autour d'Ollama, écrit à la main pour comprendre chaque brique."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Nils Malmberg" }]
+requires-python = ">=3.11"
+dependencies = [
+    "requests>=2.34.2",
+]
+keywords = ["agent", "coding-agent", "llm", "ollama", "tutoriel"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Natural Language :: French",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+]
+
+[project.urls]
+Documentation = "https://nils-malmberg.fr/project8.html"
+Repository = "https://github.com/nils-malmberg/llamagent"
+Issues = "https://github.com/nils-malmberg/llamagent/issues"
+
+[project.scripts]
+llamagent = "llamagent.cli:main"
+
+[build-system]
+# 1.27 : première version qui comprend « license = "MIT" » (PEP 639).
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

llamagent-0.1.0/scripts/check_package.py

@@ -0,0 +1,38 @@
+"""Vérifie le paquet construit avant de le publier (étape 18).
+
+    python scripts/check_package.py            # le contenu du paquet (dist/)
+    python scripts/check_package.py v0.1.0     # et l'étiquette correspond à la version
+"""
+
+import sys
+import tomllib
+import zipfile
+from pathlib import Path
+
+# Fichiers sans lesquels llamagent ne démarre pas : s'ils manquent dans le
+# paquet, il s'installe sans erreur mais plante au premier lancement.
+REQUIRED = [
+    "llamagent/cli.py",
+    "llamagent/prompts/AGENT.md",
+    "llamagent/prompts/COMPACT.md",
+    "llamagent/skills/corriger-un-bug.md",
+    "llamagent/skills/ecrire-tests-pytest.md",
+]
+
+
+def main() -> None:
+    version = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))["project"]["version"]
+    if len(sys.argv) > 1 and sys.argv[1] != f"v{version}":
+        sys.exit(f"L'étiquette {sys.argv[1]} ne correspond pas à la version v{version} de pyproject.toml.")
+    wheels = list(Path("dist").glob(f"llamagent-{version}-*.whl"))
+    if len(wheels) != 1:
+        sys.exit(f"Un seul paquet llamagent-{version} attendu dans dist/, trouvé : {[w.name for w in wheels]}")
+    names = zipfile.ZipFile(wheels[0]).namelist()
+    missing = [name for name in REQUIRED if name not in names]
+    if missing:
+        sys.exit(f"Fichiers absents du paquet : {', '.join(missing)}")
+    print(f"{wheels[0].name} : {len(names)} fichiers, prompts et skills présents.")
+
+
+if __name__ == "__main__":
+    main()

llamagent-0.1.0/src/llamagent/__init__.py

@@ -0,0 +1 @@
+"""llamagent : un agent de code minimal autour d'Ollama."""

llamagent-0.1.0/src/llamagent/agent.py

@@ -0,0 +1,124 @@
+"""La boucle agentique : le cœur de llamagent.
+
+    tant que le modèle demande des outils :
+        exécuter chaque outil demandé
+        ajouter le résultat à la conversation
+        rappeler le modèle
+    sinon : renvoyer sa réponse finale
+
+La boucle ne connaît aucun outil en particulier : elle passe par le registre
+de tools.py. Elle ne parle pas non plus directement à Ollama : on lui donne
+une fonction `chat`, ce qui permet de la tester avec un faux modèle.
+"""
+
+import json
+import os
+import platform
+from pathlib import Path
+from typing import Callable
+
+from llamagent import ui
+from llamagent.config import MAX_OUTPUT_CHARS, MAX_TOURS
+from llamagent.guards import is_allowed_command, truncate
+from llamagent.tools import TOOLS, ToolContext, execute_tool, tool_schemas
+
+# Une fonction qui reçoit (messages, schémas des outils) et renvoie le message
+# de l'assistant. En vrai : llm.chat. Dans les tests : un faux modèle.
+ChatFunction = Callable[[list[dict], list[dict]], dict]
+
+
+# ─────────────────────────── Prompt système ───────────────────────────
+
+
+def build_system_prompt(template: str, workdir: Path, skills: dict[str, str], project_instructions: str = "") -> str:
+    """Remplit le modèle de prompt (prompts/AGENT.md) avec l'environnement réel.
+
+    Si le projet a un fichier AGENTS.md (étape 9), son contenu est ajouté à la fin.
+    """
+    shell = "cmd.exe" if os.name == "nt" else "/bin/sh"
+    skills_text = "\n".join(f"- {name} : {description}" for name, description in skills.items())
+    # str.replace plutôt que str.format : le Markdown peut contenir des { }.
+    prompt = (
+        template.replace("{os}", platform.system())
+        .replace("{shell}", shell)
+        .replace("{workdir}", str(workdir))
+        .replace("{skills}", skills_text or "(aucune)")
+    )
+    if project_instructions:
+        prompt += f"\n\n## Instructions du projet (AGENTS.md)\n{project_instructions}"
+    return prompt
+
+
+# ─────────────────────────── La boucle ───────────────────────────
+
+
+def describe_harness(name: str, arguments, ctx: ToolContext, repeated: bool) -> str:
+    """Ce que le harness fait de la demande du modèle, en une phrase (étape 17).
+
+    Seulement pour l'affichage : on rend visible le rôle du harness entre
+    le modèle, qui demande, et l'outil, qui exécute.
+    """
+    if repeated:
+        return "appel identique au précédent : pas exécuté, le modèle est prévenu"
+    if name not in TOOLS:
+        return "outil inconnu : l'erreur est renvoyée au modèle"
+    if name == "edit_file":
+        return "vérifie le chemin, montre le diff et demande ta confirmation"
+    if name == "run_command":
+        command = arguments.get("command", "") if isinstance(arguments, dict) else ""
+        if is_allowed_command(command, ctx.allowed_commands):
+            return "commande autorisée : lancée sans confirmation"
+        return "demande ta confirmation avant de lancer la commande"
+    if name == "load_skill":
+        return "vérifie que la skill existe et la charge"
+    return f"vérifie le chemin et exécute {name}"
+
+
+def run_turn(chat: ChatFunction, messages: list[dict], ctx: ToolContext, max_tours: int = MAX_TOURS) -> str:
+    """Traite le dernier message utilisateur et renvoie la réponse finale.
+
+    `messages` est modifiée sur place : on y ajoute les messages de
+    l'assistant et les résultats des outils, pour garder tout l'historique.
+    L'affichage montre chaque tour : le modèle demande, le harness décide,
+    l'outil répond.
+    """
+    previous_call = None
+    for tour in range(1, max_tours + 1):
+        print(ui.tour_header(tour))
+        reply = chat(messages, tool_schemas())
+        # 1) On garde le message de l'assistant TEL QUEL, avec ses tool_calls :
+        #    au prochain appel, le modèle doit voir ce qu'il a demandé.
+        messages.append(reply)
+
+        tool_calls = reply.get("tool_calls") or []
+        if not tool_calls:
+            print(ui.role_line("modèle", "répond sans demander d'outil : fin de la boucle"))
+            print(ui.answer_header(tour))
+            return reply.get("content", "")
+
+        for call in tool_calls:
+            name = call["function"]["name"]
+            arguments = call["function"].get("arguments", {})
+            print(ui.model_asks(name, arguments))
+
+            # Détection de boucle : le même appel deux fois de suite ne
+            # donnera pas un résultat différent, on le signale au modèle.
+            signature = (name, json.dumps(arguments, sort_keys=True, ensure_ascii=False))
+            repeated = signature == previous_call
+            print(ui.role_line("harness", describe_harness(name, arguments, ctx, repeated)))
+            if repeated:
+                result = (
+                    f"Erreur : tu viens déjà d'appeler {name} avec exactement ces arguments. "
+                    "Le résultat sera le même : change d'approche ou donne ta réponse finale."
+                )
+            else:
+                result = execute_tool(name, arguments, ctx)
+            previous_call = signature
+
+            shortened = truncate(result, MAX_OUTPUT_CHARS)
+            print(ui.tool_result(shortened, truncated=len(shortened) < len(result)))
+            # 2) Puis le résultat de l'outil, avec le rôle "tool".
+            messages.append({"role": "tool", "tool_name": name, "content": shortened})
+
+    print(ui.role_line("harness", f"limite de {max_tours} tours atteinte : la boucle s'arrête", ui.RED))
+    return f"Arrêt : limite de {max_tours} tours atteinte sans réponse finale."