grimoire-kit 3.78.1__tar.gz → 3.79.0__tar.gz

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/CHANGELOG.md

@@ -7,6 +7,18 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.79.0] - 2026-11-06
+
+- fix(cockpit): changer vite d'espace n'efface plus l'espace ouvert ni son sélecteur de vues (un espace quitté se montait quand même) (#1112)
+- fix(missions): le PATH de l'unité du tick garde le dossier des exécutables appelés par chemin absolu dans les hooks des réglages Claude Code utilisateur et projet (#1022) (#1111)
+- fix(memory): `memory gate` ne vérifie la migration que si le bundle existe, sinon il affiche « aucune migration en cours sur ce poste » sans échouer (`--require-migration` pour garder le FAIL) (#1042) (#1109)
+- fix(lease): le frein du bail ne gèle plus la session qui a remis sa tâche en revue (`needs_verification`) quand le fichier de bail manque ; un bail repris par une autre session reste refusé (#1117) (#1118)
+- fix(cli): le rendu texte de `task show`, `task list` et `task pack` part sur stdout et stderr ne garde que les erreurs (#879) (#1107)
+- fix(cockpit): les questions du wizard s'affichent dans la langue du cockpit (`?lang=`, repli anglais), la CLI reste inchangée (#899) (#1110)
+- fix(up): `agent-manifest.csv` ne liste plus deux fois le même agent, un projet à jour ne montre plus de fichier à écrire (#908) (#1108)
+- test(missions): le janitor garde le worktree et rapporte `failed` quand la copie des preuves est impossible (#928) (#1115)
+- feat(orchestrate): le tick peut lancer ses workers V0/V1 sur un fournisseur compatible Anthropic comme DeepSeek (`orchestrator.roles.worker.provider`), avec les outils et les hooks de Claude Code ; le relecteur reste à part (#1113)
+
 ## [3.78.1] - 2026-11-06
 
 - fix(missions): la relecture d'un dispatch ne porte plus que sur ce que l'ouvrier a changé : plus de fausse alerte sur un arbre déjà modifié, et les fichiers qu'il crée ne lui échappent plus (#1101)

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.78.1
+Version: 3.79.0
 Summary: Dashboard, task board, project memory and evidence check for code you delegate to agents (Claude Code, Copilot).
 Project-URL: Homepage, https://github.com/Guilhem-Bonnet/Grimoire-kit
 Project-URL: Repository, https://github.com/Guilhem-Bonnet/Grimoire-kit

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/registry/kit-file-hashes.json

@@ -1,6 +1,6 @@
 {
  "schema": "grimoire-kit-file-hashes/v1",
- "generated_for": "3.78.1",
+ "generated_for": "3.79.0",
  "digests": {
   "002d1e68ce00769ee09d1e94f4af260b952837f7d1557080c2fd505216c23ac0": {
    "version": "3.11.2",

grimoire_kit-3.79.0/src/grimoire/__version__.py

@@ -0,0 +1 @@
+__version__ = "3.79.0"

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/src/grimoire/cli/cmd_memory.py

@@ -76,7 +76,16 @@ _gate_bundle_opt = typer.Option(
 )
 _gate_sync_opt = typer.Option(True, "--sync/--no-sync", help="Sync Neo4j graph projections before verification.")
 _gate_soft_opt = typer.Option(False, "--soft", help="Report failures without returning a non-zero exit code.")
-_gate_skip_migration_opt = typer.Option(False, "--skip-migration", help="Skip Weaviate/Neo4j migration parity check.")
+_gate_skip_migration_opt = typer.Option(
+    False,
+    "--skip-migration",
+    help="Skip Weaviate/Neo4j migration parity check outright, even when a bundle exists.",
+)
+_gate_require_migration_opt = typer.Option(
+    False,
+    "--require-migration",
+    help="Fail when the migration bundle is missing instead of noting that no migration is running.",
+)
 _gate_skip_graph_opt = typer.Option(False, "--skip-graph", help="Skip code/task graph projection check.")
 _gate_sync_vectors_opt = typer.Option(False, "--sync-vectors/--no-sync-vectors", help="Sync semantic code/task vector projections before verification.")
 _gate_skip_vectors_opt = typer.Option(False, "--skip-vectors", help="Skip semantic code/task vector projection check.")
@@ -227,6 +236,15 @@ def _append_gate_issue(report: dict[str, Any], message: str) -> None:
     report.setdefault("issues", []).append(message)
 
 
+#: Constat, jamais une issue : sur ce poste aucune migration n'est vérifiable ni n'a été demandée.
+_NO_MIGRATION_NOTICE = "aucune migration en cours sur ce poste"
+
+_GATE_MIGRATION_REMEDY = (
+    "run `grimoire memory migrate export-bundle --bundle <dir>`, then "
+    "`grimoire memory migrate import-weaviate` / `import-neo4j`, then "
+    "`grimoire memory migrate verify`, or pass --skip-migration"
+)
+
 
 # ── grimoire memory gate ─────────────────────────────────────────────────────
 
@@ -243,6 +261,7 @@ def memory_gate(
     sync: bool = _gate_sync_opt,
     soft: bool = _gate_soft_opt,
     skip_migration: bool = _gate_skip_migration_opt,
+    require_migration: bool = _gate_require_migration_opt,
     skip_graph: bool = _gate_skip_graph_opt,
     sync_vectors: bool = _gate_sync_vectors_opt,
     skip_vectors: bool = _gate_skip_vectors_opt,
@@ -278,8 +297,11 @@ def memory_gate(
     if not skip_migration:
         bundle_path = _default_migration_bundle(cfg, root, bundle)
         report["migration"] = {"skipped": True, "bundle": str(bundle_path)}
-        if not bundle_path.exists():
-            _append_gate_issue(report, f"Migration bundle not found: {bundle_path}")
+        # Opt-in par présence : sans dossier bundle, aucune migration n'est en cours — un constat, pas un FAIL.
+        if not bundle_path.is_dir() and not require_migration:
+            report["migration"]["notice"] = _NO_MIGRATION_NOTICE
+        elif not bundle_path.is_dir():
+            _append_gate_issue(report, f"Migration bundle not found: {bundle_path} — {_GATE_MIGRATION_REMEDY}")
         elif not cfg.memory.weaviate_url:
             _append_gate_issue(report, "memory.weaviate_url is required for migration verification")
         else:
@@ -399,7 +421,8 @@ def memory_gate(
                 f"Weaviate {report['migration']['weaviate']['count']}"
             )
         else:
-            console.print("  Migration : skipped")
+            notice = report["migration"].get("notice")
+            console.print(f"  Migration : skipped ({notice})" if notice else "  Migration : skipped")
         if not report["graph_verify"].get("skipped"):
             actual = report["graph_verify"].get("actual", {})
             console.print(

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/src/grimoire/cli/cmd_task.py

@@ -32,8 +32,10 @@ task_app = typer.Typer(
 board_app = typer.Typer(help="Le board gouverné, projeté depuis le ledger.", no_args_is_help=True)
 task_app.add_typer(board_app, name="board")
 
-# Le rendu humain part sur stderr : le JSON de stdout reste pipeable.
+# Faute de sortie (erreurs, diagnostics, transitions) sur stderr : stdout reste
+# celui du rendu nominal et du JSON, seuls `out` écrivent là (issue #879).
 console = Console(stderr=True)
+out = Console()
 
 _BOARD_RELPATH = Path("_grimoire/standard/task-board.yaml")
 _DEFAULT_LEDGER = Path("_grimoire-runtime-output/ledger")
@@ -251,13 +253,15 @@ def task_list(
         typer.echo(json.dumps([t.to_dict() for t in tasks], indent=2, ensure_ascii=False))
         return
     if not tasks:
-        console.print("[dim]Aucune tâche.[/dim]")
+        out.print("[dim]Aucune tâche.[/dim]")
         return
     for task in tasks:
         # Sans échappement, Rich prend les crochets pour une balise de style
         # et fait disparaître l'état — la ligne restait muette sur l'essentiel.
         etat = escape(f"[{task.status_label} · {board_status_of(task.status)}]")
-        console.print(f"  {task.id}  {etat}  {task.title}")
+        out.print(f"  {task.id}  {etat}  {task.title}")
+
+
 @task_app.command("show")
 def task_show(
     ctx: typer.Context,
@@ -295,46 +299,47 @@ def task_show(
         payload["usage"] = usage
         typer.echo(json.dumps(payload, indent=2, ensure_ascii=False))
         return
-    console.print(f"[bold]{task.id}[/bold] — {task.title}")
-    console.print(f"  état    : {task.status_label} (board : {board_status_of(task.status)})")
+    out.print(f"[bold]{task.id}[/bold] — {task.title}")
+    out.print(f"  état    : {task.status_label} (board : {board_status_of(task.status)})")
     if task.description:
         first, *rest = task.description.splitlines()
-        console.print(f"  description : {escape(first)}")
+        out.print(f"  description : {escape(first)}")
         for line in rest:
-            console.print(f"                {escape(line)}")
-    console.print(f"  accepte : {', '.join(task.acceptance) or '—'}")
-    console.print(f"  vérifiabilité : {verifiabilite['class']} — {verifiabilite['explanation']}")
-    console.print(f"  modèle recommandé : {model_hint(advice)} [dim](palier : {advice['model_tier']})[/dim]")
+            out.print(f"                {escape(line)}")
+    out.print(f"  accepte : {', '.join(task.acceptance) or '—'}")
+    out.print(f"  vérifiabilité : {verifiabilite['class']} — {verifiabilite['explanation']}")
+    out.print(f"  modèle recommandé : {model_hint(advice)} [dim](palier : {advice['model_tier']})[/dim]")
     for risque in task.accepted_risks:
-        console.print(
+        out.print(
             f"  [yellow]risque accepté[/yellow] : {escape(str(risque.get('reason', '')))} "
             f"[dim]({risque.get('amendments')}/{risque.get('cap')} amendements, run {risque.get('run_id')})[/dim]"
         )
     for entree in verifiabilite["criteria"]:
         motif = entree["pattern"] or "non reconnu"
-        console.print(f"    [dim]- {escape(entree['criterion'])} → {motif}[/dim]")
+        out.print(f"    [dim]- {escape(entree['criterion'])} → {motif}[/dim]")
     if last_dispatch is not None:
         if last_dispatch.get("review") is not None:
             _print_review(
                 last_dispatch["review"],
                 [str(p) for p in last_dispatch.get("review_files") or ()],
                 last_dispatch.get("review_note"),
+                out,
             )
-        _print_uncertainties(list(last_dispatch.get("uncertainties") or ()))
+        _print_uncertainties(list(last_dispatch.get("uncertainties") or ()), out)
         for warning in last_dispatch.get("uncertainty_warnings") or ():
-            console.print(f"  [yellow]![/yellow] {escape(str(warning))}")
-    console.print(f"  usage   : {_usage_line(usage)}")
+            out.print(f"  [yellow]![/yellow] {escape(str(warning))}")
+    out.print(f"  usage   : {_usage_line(usage)}")
     if task.finition:
-        console.print(f"  finition : {task.finition}")
+        out.print(f"  finition : {task.finition}")
     if task.owner or task.claim:
-        console.print(f"  porté par : {task.owner or (task.claim.actor_id if task.claim else '—')}")
+        out.print(f"  porté par : {task.owner or (task.claim.actor_id if task.claim else '—')}")
     if task.directives:
         from grimoire.missions.recall import directive_status
 
-        console.print("  consignes de l'orchestrateur :")
+        out.print("  consignes de l'orchestrateur :")
         for directive in task.directives:
             marque = escape(f"[{directive.kind}, {directive.origin}, {directive_status(directive)}]")
-            console.print(
+            out.print(
                 f"    - {marque} {escape(directive.author)}, "
                 f"{directive.created_at[:16]} : {escape(directive.text)}  [dim]{directive.id}[/dim]"
             )
@@ -342,11 +347,11 @@ def task_show(
     try:
         transitions = declared_transitions(project_root.resolve())
     except GatesFileError as exc:
-        console.print(f"  [yellow]![/yellow] {exc} — aucune transition ne passera tant qu'il n'est pas réparé")
+        out.print(f"  [yellow]![/yellow] {exc} — aucune transition ne passera tant qu'il n'est pas réparé")
         return
     exigences = {to: e.get("required_evidence", []) for (src, to), e in transitions.items() if src == here}
     for to, req in exigences.items():
-        console.print(f"  [dim]vers {to} : {', '.join(str(r) for r in req)}[/dim]")
+        out.print(f"  [dim]vers {to} : {', '.join(str(r) for r in req)}[/dim]")
 
 
 @task_app.command("claim")
@@ -1042,15 +1047,15 @@ def task_pack(
         typer.echo(json.dumps(pack.to_dict(), indent=2, ensure_ascii=False, default=str))
         return
 
-    console.print(f"[bold]{pack.id}[/bold] — tâche {pack.task_id}, profil {pack.profile.value}  [dim]({pack.created_at})[/dim]")
+    out.print(f"[bold]{pack.id}[/bold] — tâche {pack.task_id}, profil {pack.profile.value}  [dim]({pack.created_at})[/dim]")
     if pack.coverage is not None:
         couverts = ", ".join(pack.coverage.acceptance_covered) or "—"
-        console.print(f"  Critères couverts  : {couverts}")
+        out.print(f"  Critères couverts  : {couverts}")
         if pack.coverage.acceptance_missing:
             manquants = ", ".join(pack.coverage.acceptance_missing)
-            console.print(f"  [red]Critères manquants[/red] : {manquants}")
+            out.print(f"  [red]Critères manquants[/red] : {manquants}")
     for item in pack.items:
-        console.print(f"  - [{item.kind.value}] {escape(item.summary or item.uri)}  [dim]{item.uri}[/dim]")
+        out.print(f"  - [{item.kind.value}] {escape(item.summary or item.uri)}  [dim]{item.uri}[/dim]")
 
 
 @task_app.command("verify")
@@ -1235,24 +1240,31 @@ def _emit_dispatch(ctx: typer.Context, report: Any) -> None:
     raise typer.Exit(report.exit_code)
 
 
-def _print_review(review: str, review_files: list[str], review_note: str | None) -> None:
-    """Rendu texte de la classe de relisibilité (#327) — les mêmes données que ``to_dict()``."""
+def _print_review(
+    review: str, review_files: list[str], review_note: str | None, target: Console | None = None
+) -> None:
+    """Rendu texte de la classe de relisibilité (#327) — les mêmes données que ``to_dict()``.
+
+    ``target`` : la console du rendu appelant (``out`` pour ``show``) ; défaut stderr.
+    """
+    cible = target or console
     label = "[red]requise[/red]" if review == "review_required" else "[dim]optionnelle[/dim]"
-    console.print(f"[bold]relecture[/bold] : {label}")
+    cible.print(f"[bold]relecture[/bold] : {label}")
     for path in review_files:
-        console.print(f"  [dim]- {escape(path)}[/dim]")
+        cible.print(f"  [dim]- {escape(path)}[/dim]")
     if review_note:
-        console.print(f"  [dim]{escape(review_note)}[/dim]")
+        cible.print(f"  [dim]{escape(review_note)}[/dim]")
 
 
-def _print_uncertainties(uncertainties: list[dict[str, Any]]) -> None:
+def _print_uncertainties(uncertainties: list[dict[str, Any]], target: Console | None = None) -> None:
     """Rendu texte des incertitudes déclarées (#328) — silencieux si la liste est vide."""
     if not uncertainties:
         return
-    console.print(f"[bold]incertitudes déclarées[/bold] ({len(uncertainties)}) :")
+    cible = target or console
+    cible.print(f"[bold]incertitudes déclarées[/bold] ({len(uncertainties)}) :")
     for item in uncertainties:
-        console.print(f"  - {escape(str(item.get('where', '')))} : {escape(str(item.get('what', '')))}")
-        console.print(f"    [dim]{escape(str(item.get('why', '')))}[/dim]")
+        cible.print(f"  - {escape(str(item.get('where', '')))} : {escape(str(item.get('what', '')))}")
+        cible.print(f"    [dim]{escape(str(item.get('why', '')))}[/dim]")
 
 
 @task_app.command("dispatch")

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/src/grimoire/cli/init_questions.py

@@ -23,7 +23,7 @@ même réponse donne le même archétype des deux côtés. Module séparé de
 
 from __future__ import annotations
 
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, field, replace
 from typing import Any
 
 from grimoire.core.archetype_resolver import ArchetypeResolver, ResolvedArchetype
@@ -44,6 +44,7 @@ __all__ = [
     "prefill",
     "question",
     "questions_payload",
+    "resolve_lang",
 ]
 
 
@@ -52,11 +53,20 @@ __all__ = [
 
 @dataclass(frozen=True, slots=True)
 class Option:
-    """Une réponse possible à une question."""
+    """Une réponse possible à une question.
+
+    ``texts`` ne porte que les langues autres que ``label``/``hint``
+    (l'anglais) : ``label`` et ``hint`` restent la référence de la CLI.
+    """
 
     id: str
     label: str
     hint: str = ""
+    texts: dict[str, tuple[str, str]] = field(default_factory=dict)
+
+    def localized(self, lang: str = "en") -> tuple[str, str]:
+        """``(label, hint)`` dans la langue demandée, anglais par défaut."""
+        return self.texts.get(lang, (self.label, self.hint))
 
 
 @dataclass(frozen=True, slots=True)
@@ -67,6 +77,12 @@ class Question:
     prompt: str
     options: tuple[Option, ...]
     multiple: bool = False
+    #: Même règle que :class:`Option` : une entrée par langue non anglaise.
+    prompts: dict[str, str] = field(default_factory=dict)
+
+    def localized_prompt(self, lang: str = "en") -> str:
+        """L'énoncé dans la langue demandée, anglais par défaut."""
+        return self.prompts.get(lang, self.prompt)
 
     def option_ids(self) -> tuple[str, ...]:
         return tuple(o.id for o in self.options)
@@ -79,10 +95,14 @@ class Question:
 STACK_QUESTION = Question(
     id="stack",
     prompt="Which technical stack does this project use?",
+    prompts={"fr": "Quelle pile technique ce projet utilise-t-il ?"},
     multiple=True,
     options=(
         Option("python", "Python"),
-        Option("typescript", "JavaScript / TypeScript", "Node, React, Vue included"),
+        Option(
+            "typescript", "JavaScript / TypeScript", "Node, React, Vue included",
+            texts={"fr": ("JavaScript / TypeScript", "Node, React et Vue compris")},
+        ),
         Option("go", "Go"),
         Option("rust", "Rust"),
         Option("java", "Java / Kotlin"),
@@ -98,31 +118,78 @@ STACK_QUESTION = Question(
 WHO_QUESTION = Question(
     id="who",
     prompt="Who works on this project?",
+    prompts={"fr": "Qui travaille sur ce projet ?"},
     options=(
-        Option("solo", "Just me, I know my stack"),
-        Option("learning", "Just me, I am learning"),
-        Option("team", "A small team of developers"),
-        Option("team-ops", "A team with ops or platform people"),
-        Option("agents", "Mostly AI agents that I supervise"),
+        Option("solo", "Just me, I know my stack", texts={"fr": ("Moi seul, je connais ma pile", "")}),
+        Option("learning", "Just me, I am learning", texts={"fr": ("Moi seul, j'apprends", "")}),
+        Option("team", "A small team of developers", texts={"fr": ("Une petite équipe de développeurs", "")}),
+        Option(
+            "team-ops", "A team with ops or platform people",
+            texts={"fr": ("Une équipe avec des profils ops ou plateforme", "")},
+        ),
+        Option(
+            "agents", "Mostly AI agents that I supervise",
+            texts={"fr": ("Surtout des agents IA que je supervise", "")},
+        ),
     ),
 )
 
 DOMAIN_QUESTION = Question(
     id="domain",
     prompt="What is the project about?",
+    prompts={"fr": "Quel est le sujet du projet ?"},
     options=(
-        Option("none", "A library, a CLI, a service", "no asserted domain"),
-        Option("web", "A web application", "frontend and/or API"),
-        Option("infra", "Infrastructure, deployment, homelab"),
-        Option("platform", "An internal platform", "contracts between teams"),
-        Option("creative", "Content, design, brand"),
-        Option("fixloop", "Maintenance with a certified fix loop", "TDD proofs, incidents"),
-        Option("standard", "The agentic standard itself", "traceability, evidence gates"),
+        Option(
+            "none", "A library, a CLI, a service", "no asserted domain",
+            texts={"fr": ("Une bibliothèque, une CLI, un service", "aucun domaine affirmé")},
+        ),
+        Option(
+            "web", "A web application", "frontend and/or API",
+            texts={"fr": ("Une application web", "frontend et/ou API")},
+        ),
+        Option(
+            "infra", "Infrastructure, deployment, homelab",
+            texts={"fr": ("Infrastructure, déploiement, homelab", "")},
+        ),
+        Option(
+            "platform", "An internal platform", "contracts between teams",
+            texts={"fr": ("Une plateforme interne", "contrats entre équipes")},
+        ),
+        Option("creative", "Content, design, brand", texts={"fr": ("Contenu, design, marque", "")}),
+        Option(
+            "fixloop", "Maintenance with a certified fix loop", "TDD proofs, incidents",
+            texts={"fr": ("Maintenance avec une boucle de correction certifiée", "preuves TDD, incidents")},
+        ),
+        Option(
+            "standard", "The agentic standard itself", "traceability, evidence gates",
+            texts={"fr": ("Le standard agentique lui-même", "traçabilité, barrières de preuve")},
+        ),
     ),
 )
 
 QUESTIONS: tuple[Question, Question, Question] = (STACK_QUESTION, WHO_QUESTION, DOMAIN_QUESTION)
 
+#: Langue de repli, celle des libellés écrits en dur et de la CLI.
+DEFAULT_LANG = "en"
+
+
+def resolve_lang(*values: str | None) -> str:
+    """Langue retenue : le premier ``fr``/``en`` reconnu, sinon l'anglais.
+
+    Utilisée pour ``?lang=`` puis ``Accept-Language`` : un en-tête y met des
+    poids (``fr-CH,fr;q=0.9,en;q=0.8``), d'où la lecture par préférence
+    décroissante plutôt que l'égalité.
+    """
+    for value in values:
+        for tag in str(value or "").split(","):
+            code = tag.split(";")[0].strip().lower()
+            if not code:
+                continue
+            lang = code.split("-")[0].split("_")[0]
+            if lang in {"fr", "en"}:
+                return lang
+    return DEFAULT_LANG
+
 
 def question(question_id: str) -> Question:
     for q in QUESTIONS:
@@ -403,29 +470,59 @@ def _recommended_expertises(stacks: tuple[str, ...], stack_skills: tuple[str, ..
     return tuple(out)
 
 
-def deduce(answers: Answers, *, extra_expertises: tuple[str, ...] = ()) -> Deduction:
+#: La ligne de déduction du cockpit, seule sortie mise en mots (la CLI imprime
+#: son propre résumé, en anglais, indépendamment de celle-ci).
+_DEDUCTION_WORDING: dict[str, dict[str, str]] = {
+    "en": {
+        "ops_infra": "ops people + infra stack declared → infra-ops added",
+        "no_need": "no need",
+        "who": "« {label} » → {level}, standard profile {profile} ({needs})",
+        "stack_skills": "stack skills attached to Atlas: ",
+        "expertises": "expertises to attach on request: ",
+    },
+    "fr": {
+        "ops_infra": "profils ops + pile d'infrastructure déclarée → infra-ops ajouté",
+        "no_need": "aucun besoin",
+        "who": "« {label} » → {level}, profil du standard {profile} ({needs})",
+        "stack_skills": "skills de pile attachés à Atlas : ",
+        "expertises": "expertises à attacher sur demande : ",
+    },
+}
+
+
+def deduce(
+    answers: Answers, *, extra_expertises: tuple[str, ...] = (), lang: str = DEFAULT_LANG
+) -> Deduction:
     """Archétype, niveau, besoins, profil, skills et expertises impliqués par les réponses.
 
     ``extra_expertises`` : identifiants déjà recommandés par la détection sur
     disque (famille cloud, :func:`grimoire.core.expertises.detect_expertises`)
     que la fonction pure ne peut pas voir ; ajoutés tels quels, dédupliqués.
+    ``lang`` ne change que le texte des ``reasons`` (le cockpit les affiche).
     """
+    words = _DEDUCTION_WORDING.get(lang, _DEDUCTION_WORDING[DEFAULT_LANG])
     reasons: list[str] = []
     primary = _DOMAIN_TO_ARCHETYPE.get(answers.domain, "stack")
     archetypes = [primary]
-    domain_label = next((o.label for o in DOMAIN_QUESTION.options if o.id == answers.domain), answers.domain)
+    domain_label = next(
+        (o.localized(lang)[0] for o in DOMAIN_QUESTION.options if o.id == answers.domain), answers.domain
+    )
     reasons.append(f"domain « {domain_label} » → {primary}")
 
     if answers.who == "team-ops" and primary != "infra-ops" and _INFRA_STACKS & set(answers.stacks):
         archetypes.append("infra-ops")
-        reasons.append("ops people + infra stack declared → infra-ops added")
+        reasons.append(words["ops_infra"])
 
     skill_level = _WHO_TO_SKILL_LEVEL.get(answers.who, "intermediate")
     needs = _WHO_TO_NEEDS.get(answers.who, ())
     profile = _standard_profile_for(needs)
-    who_label = next((o.label for o in WHO_QUESTION.options if o.id == answers.who), answers.who)
-    needs_text = ", ".join(needs) if needs else "no need"
-    reasons.append(f"« {who_label} » → {skill_level}, standard profile {profile} ({needs_text})")
+    who_label = next(
+        (o.localized(lang)[0] for o in WHO_QUESTION.options if o.id == answers.who), answers.who
+    )
+    needs_text = ", ".join(needs) if needs else words["no_need"]
+    reasons.append(
+        words["who"].format(label=who_label, level=skill_level, profile=profile, needs=needs_text)
+    )
 
     stack_skills = tuple(
         STACK_SKILL_BY_DETECTION[_STACK_TO_SCANNER[s]]
@@ -437,9 +534,9 @@ def deduce(answers: Answers, *, extra_expertises: tuple[str, ...] = ()) -> Deduc
         if extra not in expertises:
             expertises.append(extra)
     if stack_skills:
-        reasons.append("stack skills attached to Atlas: " + ", ".join(stack_skills))
+        reasons.append(words["stack_skills"] + ", ".join(stack_skills))
     if expertises:
-        reasons.append("expertises to attach on request: " + ", ".join(expertises))
+        reasons.append(words["expertises"] + ", ".join(expertises))
 
     return Deduction(
         archetypes=tuple(archetypes),
@@ -482,11 +579,17 @@ def answers_to_scan(answers: Answers, base: ScanResult | None, root: Any) -> Sca
 # ── Charge utile partagée avec le cockpit ─────────────────────────────────────
 
 
-def questions_payload(scan: ScanResult | None, raw_answers: dict[str, Any] | None = None) -> dict[str, Any]:
+def questions_payload(
+    scan: ScanResult | None,
+    raw_answers: dict[str, Any] | None = None,
+    lang: str = DEFAULT_LANG,
+) -> dict[str, Any]:
     """Questions, réponses par défaut, réponses effectives et déduction — en JSON.
 
     Ce que ``GET /api/setup/questions`` rend au cockpit : les mêmes fonctions
     que la CLI, pour que l'archétype déduit soit identique des deux côtés.
+    ``lang`` ne change que les libellés (question, option, aide, déduction) ;
+    la CLI garde l'anglais, son défaut.
     """
     defaults = prefill(scan)
     answers = answers_from_dict(raw_answers or {}, defaults)
@@ -494,13 +597,16 @@ def questions_payload(scan: ScanResult | None, raw_answers: dict[str, Any] | Non
         "questions": [
             {
                 "id": q.id,
-                "prompt": q.prompt,
+                "prompt": q.localized_prompt(lang),
                 "multiple": q.multiple,
-                "options": [{"id": o.id, "label": o.label, "hint": o.hint} for o in q.options],
+                "options": [
+                    {"id": o.id, "label": o.localized(lang)[0], "hint": o.localized(lang)[1]}
+                    for o in q.options
+                ],
             }
             for q in QUESTIONS
         ],
         "defaults": defaults.to_dict(),
         "answers": answers.to_dict(),
-        "deduction": deduce(answers).to_dict(),
+        "deduction": deduce(answers, lang=lang).to_dict(),
     }

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/src/grimoire/core/scaffold.py

@@ -1201,9 +1201,13 @@ class ProjectScaffolder:
 
         # Agent manifest (enriched with category + description)
         manifest_lines = ["name,file,category,description,icon\n"]
+        listed: set[str] = set()
         for fc in p.copies:
             if not _is_agent_markdown(fc.dst):
                 continue
+            # Un même agent planifié deux fois (pile + archétype) ne compte qu'une ligne (#908).
+            if fc.dst.stem in listed:
+                continue
             # The blank `custom-agent.md` template ships with an unrendered
             # `name: "{{agent_tag}}"` — not yet an agent (see `layout.
             # agent_identity`'s docstring). Listing it anyway made the
@@ -1213,6 +1217,7 @@ class ProjectScaffolder:
             if self._agent_identity(fc.src) is None:
                 continue
             name = fc.dst.stem
+            listed.add(name)
             category = fc.label.split("/")[0] if fc.label and "/" in fc.label else "—"
             desc = self._extract_agent_description(fc.src).replace(",", ";").replace("'", "''")
             manifest_lines.append(f"{name},{name}.md,{category},{desc},\n")

{grimoire_kit-3.78.1 → grimoire_kit-3.79.0}/src/grimoire/hosts/decisions/lease_brake.py

@@ -129,8 +129,8 @@ _CANCELLED = "cancelled"
 def _lease_state(root: Path, task_id: str, epoch: int) -> tuple[str, str]:
     """``(état, motif)`` du bail que la session croit tenir : ``held``, ``released``, ``stale_epoch`` ou ``cancelled``.
 
-    ``released`` : la session a quitté son bail par la porte — release, blocage, échec ou
-    clôture (barrière ``hand_back`` à l'epoch suivant le sien). Elle ne tient plus rien,
+    ``released`` : la session a quitté son bail par la porte — release, blocage, échec,
+    remise en revue (``needs_verification``) ou clôture (barrière ``hand_back`` à l'epoch suivant le sien). Elle ne tient plus rien,
     mais personne ne lui a pris : le frein se tait, comme pour une session sans bail
     (K3-S1-01). Une barrière posée par la récolte, un autre titulaire, un autre epoch ou
     une annulation restent des refus.
@@ -162,9 +162,12 @@ def _lease_state(root: Path, task_id: str, epoch: int) -> tuple[str, str]:
         task is not None
         and task.claim is not None
         and task.claim.lease_epoch == epoch
-        and task.status in (TaskState.CLOSED, TaskState.BLOCKED, TaskState.FAILED)
+        and task.status in (TaskState.CLOSED, TaskState.BLOCKED, TaskState.FAILED, TaskState.NEEDS_VERIFICATION)
     ):
-        return _RELEASED, ""  # le claim de la session, rendu par une sortie légitime
+        # le claim de la session, rendu par une sortie légitime. ``needs_verification`` en est une : la
+        # transition garde le claim (le titulaire a remis sa preuve), mais ``check_holder`` ne la tient
+        # plus pour un bail — fichier de bail absent, la session était gelée (#1117). Un autre epoch reste refusé.
+        return _RELEASED, ""
     return _STALE, check.reason