grimoire-kit 3.76.0__tar.gz → 3.77.0__tar.gz

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/CHANGELOG.md

@@ -7,6 +7,18 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.77.0] - 2026-10-30
+
+- chore(release): correctifs intermédiaires des PR fusionnées par commit de fusion, déjà décrits par le fragment de leur PR : e56b9bde, 643cd839, 45360126, ea109781, efb3ea4e, 00f1a297, 195fcb60
+- fix(missions): le relecteur ne juge plus une tâche sur un run d'E2E périmé — un check relancé (échec ancien, run en cours) est en cours, pas rouge — et chaque `task.review_judged` porte le verdict CI lu (`ci`, `ci_detail`) (GAO-i8-le-relec-001)
+- fix(cockpit): « À traiter » ne compte plus les consignes des tâches finies ; une consigne non lue sur une tâche ouverte est « à entretenir », le badge et le titre d'onglet ne comptent que les gestes, et clôturer une tâche acquitte ses consignes (raison « tâche close »)
+- feat(missions): boîte à idées — `grimoire idea add|list|drop|promote`, outil MCP `idea_add` et « Garder pour plus tard » dans « Une idée ? » du cockpit : une idée se garde sans être triée, et se transforme en tâches plus tard (I13)
+- fix(cockpit): les cibles tactiles font 44 px à 390 px ou au doigt (jeton `--hit`) et les rubriques de Savoir et de Configuration ne s'effondrent plus à 18 px (GAO-i14-rendre-002)
+- perf(cockpit): le pouls porte une empreinte par projet et l'interface ne relit que le projet affiché quand il a bougé ; l'écart entre deux relectures suit leur durée réelle (3 à 15 s) et la barre d'état compte les relectures par minute (GAO-i11-ne-rech-001)
+- perf(cockpit): le panneau Preuves lit le board et les politiques une fois par requête, ne calcule que les tâches actives (les terminales sont comptées, `?all=1` les détaille) et borne son calcul à 5 s (`truncated`) — 283 tâches en moins de 1,5 s au lieu de plus de 30 s (GAO-i9-rendre-l-001)
+- fix(cockpit): `GET /api/workspace/evidence` n'écrit plus de `gate.checked` dans `runtime-journal.jsonl` (`check_evidence_gates(record=False)`), un journal périmé n'est plus rendu « frais » par l'ouverture du panneau (GAO-i9-rendre-l-001)
+- feat(missions): l'usage réel de chaque session est replié dans sa tâche à chaque tick (journal retrouvé dans le worktree ou par identifiant de session, au plus 5 journaux et 50 Mo par tick) ; `grimoire task usage --backfill [--dry-run]` rattrape les tâches closes ; un journal absent est dit « journal de session introuvable »
+
 ## [3.76.0] - 2026-10-29
 
 - chore(release): correctifs intermédiaires des PR fusionnées par commit de fusion, déjà décrits par le fragment de leur PR : a4b0e8a7, 077bba97, e82f2a3f, 7198f1de, abd4ef41, d17c4672, 27fe2020, 5de84791, 773d7441, bcb735df

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.76.0
+Version: 3.77.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.76.0 → grimoire_kit-3.77.0}/registry/kit-file-hashes.json

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

grimoire_kit-3.77.0/src/grimoire/__version__.py

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

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/cli/_lazy_extra.py

@@ -13,4 +13,5 @@ from grimoire.cli._lazy import LazyGroupSpec
 #: Nom → groupe, dans l'ordre d'affichage de ``grimoire --help --all``.
 EXTRA_GROUPS: dict[str, LazyGroupSpec] = {
     "steward": LazyGroupSpec("grimoire.cli.cmd_steward", "steward_app", rich_help_panel="Project"),
+    "idea": LazyGroupSpec("grimoire.cli.cmd_idea", "idea_app", rich_help_panel="Project"),
 }

grimoire_kit-3.77.0/src/grimoire/cli/cmd_idea.py

@@ -0,0 +1,118 @@
+"""CLI ``grimoire idea`` — la boîte à idées : garder maintenant, décider plus tard (I13)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+
+if TYPE_CHECKING:
+    from grimoire.missions.ideas import Idea, IdeaStore
+
+idea_app = typer.Typer(help="Boîte à idées : add, list, drop, promote.", no_args_is_help=True)
+console = Console()
+
+_PROJECT_ROOT = typer.Option("--project-root", help="Racine du projet.", show_default=False)
+_LEDGER_ROOT = typer.Option("--ledger-root", help="Racine du Mission Ledger (relative au projet).")
+_DEFAULT_LEDGER = Path("_grimoire-runtime-output/ledger")
+
+
+def _store(project_root: Path, ledger_root: Path) -> IdeaStore:
+    from grimoire.missions.ideas import IdeaStore
+
+    return IdeaStore(project_root.resolve(), ledger_root)
+
+
+def _fail(message: str) -> typer.Exit:
+    console.print(f"[red]✗[/red] {escape(message)}")
+    return typer.Exit(1)
+
+
+def _line(idea: Idea) -> str:
+    tasks = f" → {', '.join(idea.tasks)}" if idea.tasks else ""
+    return f"{idea.id}  {escape(f'[{idea.state}]')}  {escape(idea.text)}{tasks}"
+
+
+@idea_app.command("add")
+def idea_add(
+    text: Annotated[str, typer.Argument(help="L'idée, en une phrase (500 caractères au plus).")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Garde une idée sans la trier."""
+    from grimoire.missions.ideas import IdeaError
+
+    try:
+        idea = _store(project_root, ledger_root).add(text, "cli")
+    except IdeaError as exc:
+        raise _fail(str(exc)) from exc
+    if json_output:
+        typer.echo(json.dumps(idea.to_dict(), indent=2, ensure_ascii=False))
+        return
+    console.print(f"[green]✓[/green] {_line(idea)}")
+
+
+@idea_app.command("list")
+def idea_list(
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    state: Annotated[str, typer.Option("--state", help="Filtrer : open, promoted ou dropped.")] = "",
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Les idées, dans l'ordre où elles ont été gardées."""
+    ideas = _store(project_root, ledger_root).list(state)
+    if json_output:
+        typer.echo(json.dumps([i.to_dict() for i in ideas], indent=2, ensure_ascii=False))
+        return
+    if not ideas:
+        console.print("[dim]Aucune idée.[/dim]")
+    for idea in ideas:
+        console.print(_line(idea))
+
+
+@idea_app.command("drop")
+def idea_drop(
+    idea_id: Annotated[str, typer.Argument(help="Identifiant de l'idée.")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+) -> None:
+    """Écarte une idée ouverte (le journal garde la trace)."""
+    from grimoire.missions.ideas import IdeaError
+
+    try:
+        idea = _store(project_root, ledger_root).drop(idea_id)
+    except IdeaError as exc:
+        raise _fail(str(exc)) from exc
+    console.print(f"[green]✓[/green] {_line(idea)}")
+
+
+@idea_app.command("promote")
+def idea_promote(
+    idea_id: Annotated[str, typer.Argument(help="Identifiant de l'idée.")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Crée les tâches que l'intake propose (comme `task add --intake --create`), puis marque l'idée promue."""
+    from grimoire.core.exceptions import GrimoireError
+    from grimoire.missions.ideas import IdeaError
+    from grimoire.missions.service import TaskService
+
+    service = TaskService(project_root.resolve(), ledger_root)
+    try:
+        idea, created = _store(project_root, ledger_root).promote(idea_id, service)
+    except (IdeaError, GrimoireError, ValueError) as exc:
+        raise _fail(str(exc)) from exc
+    if json_output:
+        typer.echo(json.dumps({"idea": idea.to_dict(), "created": created}, indent=2, ensure_ascii=False))
+        return
+    console.print(f"[green]✓[/green] {_line(idea)}")
+    for entry in created:
+        console.print(f"    {entry['id']} ({entry['status']}) {escape(entry['title'])}")
+        if entry["reason"]:
+            console.print(f"    [yellow]{escape(entry['reason'])}[/yellow]")

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/cli/cmd_task_usage.py

@@ -15,8 +15,9 @@ from rich.markup import escape
 
 
 def register_usage_commands(app: typer.Typer) -> None:
-    """Accroche ``fold-usage`` au groupe *app*."""
+    """Accroche ``fold-usage`` et ``usage`` au groupe *app*."""
     app.command("fold-usage")(task_fold_usage)
+    app.command("usage")(task_usage_fold)
 
 
 def _usage_of(task: Any, root: Path) -> dict[str, Any]:
@@ -103,3 +104,36 @@ def task_fold_usage(
             f"[yellow]![/yellow] {count} appel(s) déjà attribué(s) à {escape(holder)}, non réattribués"
             " (un appel n'appartient qu'à une tâche ; --since/--until répartit un journal)."
         )
+
+
+def task_usage_fold(
+    ctx: typer.Context,
+    backfill: Annotated[bool, typer.Option("--backfill", help="Les tâches closes déjà là, sans plafond de journaux.")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Dit combien de journaux et d'octets seraient lus, n'écrit rien.")] = False,
+    project_root: Annotated[Path, typer.Option("--project-root", help="Racine du projet.")] = Path(),
+    ledger_root: Annotated[Path, typer.Option("--ledger-root", help="Racine du Mission Ledger.")] = Path("_grimoire-runtime-output/ledger"),
+) -> None:
+    """Replie l'usage des sessions rattachées aux tâches, comme le fait le tick (GAO-i12).
+
+    Sans option : le pas du tick (au plus 5 journaux et 50 Mo). ``--backfill`` :
+    les tâches closes seulement, tous leurs journaux d'une traite. Un journal
+    absent est dit « journal de session introuvable », jamais compté pour zéro.
+    """
+    from grimoire.cli.cmd_task import _fmt, _service, console
+    from grimoire.missions.usage_fold import MAX_LOGS, fold_pending
+
+    service = _service(project_root.resolve(), ledger_root)
+    report = fold_pending(service, max_logs=0 if backfill else MAX_LOGS, only_terminal=backfill, dry_run=dry_run)
+    if _fmt(ctx) == "json":
+        typer.echo(json.dumps(report.to_dict(), indent=2, ensure_ascii=False))
+        return
+    if dry_run:
+        console.print(f"{report.logs} journal(aux), {report.bytes} octet(s) seraient lus ; rien n'est écrit.")
+    else:
+        console.print(f"[green]OK[/green] {report.logs} journal(aux) lu(s) : {report.new_calls} appel(s) replié(s), {report.already_folded} déjà connu(s)")
+    for status in ("missing", "refused", "deferred", "error"):
+        outcomes = report.of(status)
+        if outcomes:
+            console.print(f"[yellow]![/yellow] {len(outcomes)} {status} :")
+            for o in outcomes[:10]:
+                console.print(f"  {escape(o.task_id)} — {escape(o.detail)}")

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/core/agentic_standard.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import Any
 
 from grimoire.core import standard_generation as gen
+from grimoire.core.request_memo import memoized
 from grimoire.core.standard_checks.base import (
     BOARD_STATES as BOARD_STATES,
 )
@@ -65,10 +66,7 @@ from grimoire.core.standard_checks.registry import (
 from grimoire.core.standard_checks.registry import (
     dimension_for,
 )
-from grimoire.core.standard_checks.verifiers import (
-    _verify_memory_policy,
-    run_verifiers,
-)
+from grimoire.core.standard_checks.verifiers import memory_policy_checks, run_verifiers
 from grimoire.core.standard_effective_profile import effective_manifest_profile
 from grimoire.core.standard_generation import (
     CONTEXT_DIR,
@@ -909,11 +907,13 @@ def verify_standard_profile(
     return result
 
 
+@memoized
 def _selected_profile(project_root: Path, profile_id: str | None) -> StandardProfile:
     selected_profile = profile_id or effective_manifest_profile(project_root) or "starter"
     return get_profile(selected_profile)
 
 
+@memoized
 def _read_yaml_mapping(root: Path, rel_path: Path) -> dict[str, Any]:
     path = root / rel_path
     if not path.is_file():
@@ -1447,8 +1447,9 @@ def check_evidence_gates(
     task_id: str = "bootstrap",
     target_state: str | None = None,
     profile_id: str | None = None,
+    record: bool = True,
 ) -> StandardGateResult:
-    """Evaluate task evidence gates against generated runtime artifacts."""
+    """Evaluate task evidence gates; ``record=False`` n'écrit rien au journal (lecture pure du cockpit)."""
     root = project_root.resolve()
     normalized_task_id = normalize_task_id(task_id)
     profile = _selected_profile(root, profile_id)
@@ -1495,9 +1496,7 @@ def check_evidence_gates(
         if not (root / required_paths["memory_policy"]).is_file():
             missing.append("memory_policy")
         else:
-            memory_result = StandardVerificationResult(profile=profile.id, project_root=root)
-            _verify_memory_policy(root, profile, memory_result)
-            checks.extend(memory_result.checks)
+            checks.extend(memory_policy_checks(root, profile))
     if state in {"review", "accepted", "released"}:
         for key in ("evidence_pack", "claim_ledger", "decision_trace"):
             if not (root / required_paths[key]).is_file():
@@ -1519,7 +1518,8 @@ def check_evidence_gates(
             path=required_paths.get(key),
         ))
     ok = not any(check.is_error for check in checks)
-    _append_runtime_event(root, event_type="gate.checked", task_id=normalized_task_id, profile=profile.id, details={"ok": ok, "target_state": state, "missing": missing})
+    if record:
+        _append_runtime_event(root, event_type="gate.checked", task_id=normalized_task_id, profile=profile.id, details={"ok": ok, "target_state": state, "missing": missing})
     return StandardGateResult(ok=ok, task_id=normalized_task_id, profile=profile.id, state=state or None, missing=tuple(missing), checks=tuple(checks))
 
 

grimoire_kit-3.77.0/src/grimoire/core/request_memo.py

@@ -0,0 +1,40 @@
+"""Mémo borné à une requête : une surface qui évalue beaucoup de tâches d'un coup
+(le panneau Preuves) relirait sinon le board et les politiques à chaque tâche.
+
+Hors bloc :func:`request_memo` rien n'est mémorisé ; jamais de cache entre requêtes.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import contextvars
+import functools
+from collections.abc import Callable, Iterator
+from typing import Any
+
+_MEMO: contextvars.ContextVar[dict[Any, Any] | None] = contextvars.ContextVar("grimoire_request_memo", default=None)
+
+
+@contextlib.contextmanager
+def request_memo() -> Iterator[None]:
+    token = _MEMO.set({})
+    try:
+        yield
+    finally:
+        _MEMO.reset(token)
+
+
+def memoized[F: Callable[..., Any]](fn: F) -> F:
+    """Mémorise ``fn`` (arguments hachables) pendant le bloc :func:`request_memo` courant."""
+
+    @functools.wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        memo = _MEMO.get()
+        if memo is None:
+            return fn(*args, **kwargs)
+        key = (fn.__qualname__, args, tuple(sorted(kwargs.items())))
+        if key not in memo:
+            memo[key] = fn(*args, **kwargs)
+        return memo[key]
+
+    return wrapper  # type: ignore[return-value]

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/core/standard_checks/verifiers.py

@@ -12,6 +12,7 @@ from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
+from grimoire.core.request_memo import memoized
 from grimoire.core.standard_checks.base import (
     BOARD_STATES,
     KNOWN_HOOK_ACTIONS,
@@ -885,6 +886,14 @@ def _verify_memory_os_contract(
         )
 
 
+@memoized
+def memory_policy_checks(root: Path, profile: StandardProfile) -> tuple[Any, ...]:
+    """Constats de la politique mémoire, lus une fois par requête (voir request_memo)."""
+    result = StandardVerificationResult(profile=profile.id, project_root=root)
+    _verify_memory_policy(root, profile, result)
+    return tuple(result.checks)
+
+
 def _verify_memory_policy(root: Path, profile: StandardProfile, result: StandardVerificationResult) -> None:
     rel_path = STANDARD_DIR / "memory-policy.yaml"
     data = _load_yaml_file(root, rel_path, result)

grimoire_kit-3.77.0/src/grimoire/mcp/idea_tools.py

@@ -0,0 +1,60 @@
+"""Outil MCP ``idea_add`` : garder une idée hors périmètre au lieu de la perdre (I13).
+
+Module voisin de :mod:`grimoire.mcp.server` (au plafond du cliquet de lignes) : la fonction est
+nue, :func:`register` l'enregistre avec le décorateur et les annotations du serveur. Même journal
+que ``grimoire idea add`` (:class:`grimoire.missions.ideas.IdeaStore`), source ``agent``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+__all__ = ["IDEA_ADD_LIMIT", "idea_add", "register"]
+
+#: Idées qu'une session peut garder : de quoi ne pas perdre ce qu'on croise, pas de quoi noyer la boîte.
+IDEA_ADD_LIMIT = 20
+_idea_adds: dict[str, int] = {}
+
+
+def _error(message: str) -> Any:
+    from grimoire.mcp.server import _tool_error
+
+    return _tool_error({"error": message})
+
+
+def idea_add(text: str, project_path: str = ".", ledger_root: str = "_grimoire-runtime-output/ledger") -> Any:
+    """Park an out-of-scope idea in the project's idea box instead of losing it (I13).
+
+    Use it when you cross an idea that does not belong to your task: it is appended to
+    `ideas.jsonl` (source `agent`) and a human decides later with `grimoire idea promote|drop`
+    or from the cockpit. Nothing is triaged and no task is created. Bounded: 500 characters
+    per idea, 20 ideas per session; a refused call says why.
+
+    Args:
+        text: The idea, one or two sentences, at most 500 characters.
+        project_path: Path to project root (default: current directory).
+        ledger_root: Mission Ledger directory, relative to the project root.
+    """
+    from grimoire.missions.ideas import IDEA_MAX_CHARS, IdeaError, IdeaStore
+
+    session = os.environ.get("GRIMOIRE_SESSION_ID") or os.environ.get("CLAUDE_CODE_SESSION_ID") or ""
+    key = f"{Path(project_path).resolve()}|{session}"
+    if len(text.strip()) > IDEA_MAX_CHARS:
+        return _error(f"idée trop longue : {len(text.strip())} caractères, {IDEA_MAX_CHARS} au plus")
+    if _idea_adds.get(key, 0) >= IDEA_ADD_LIMIT:
+        return _error(f"limite atteinte : {IDEA_ADD_LIMIT} idées par session ; le reste attend la prochaine session")
+    try:
+        idea = IdeaStore(Path(project_path).resolve(), Path(ledger_root)).add(text, "agent")
+    except (IdeaError, OSError) as exc:
+        return _error(str(exc))
+    _idea_adds[key] = _idea_adds.get(key, 0) + 1
+    return json.dumps(idea.to_dict(), indent=2, ensure_ascii=False)
+
+
+def register(tool: Callable[[Any], Callable[[Any], Any]], writes: Callable[..., Any]) -> None:
+    """Enregistre ``idea_add`` avec le décorateur et les annotations du serveur (écriture, non destructive)."""
+    tool(writes(destructive=False, idempotent=False))(idea_add)

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/mcp/memory_gestures.py

@@ -108,3 +108,7 @@ def register(tool: Callable[[Any], Callable[[Any], Any]], writes: Callable[...,
     tool(writes(destructive=False, idempotent=False))(grimoire_memory_retract)
     tool(writes(destructive=False, idempotent=False))(grimoire_memory_unretract)
     tool(writes(destructive=False, idempotent=True))(grimoire_memory_update_tags)
+    # Boîte à idées (I13) : même raison, ``server.py`` est au plafond du cliquet de lignes.
+    from grimoire.mcp import idea_tools
+
+    idea_tools.register(tool, writes)

grimoire_kit-3.77.0/src/grimoire/missions/ideas.py

@@ -0,0 +1,190 @@
+"""La boîte à idées du projet : garder une idée sans la trier (I13).
+
+Un journal append-only ``<ledger>/ideas.jsonl`` ; l'état d'une idée (``open``,
+``promoted``, ``dropped``) se dérive du pli de ses événements, jamais d'une
+réécriture. Un « annuler » est un événement de plus (``restore``), pas une
+suppression de ligne. L'écriture tient le verrou de fichier du kit
+(:func:`grimoire.core.fsio.locked`) : deux processus qui ajoutent ne perdent
+aucune ligne.
+
+``promote`` passe par l'intake déterministe (:mod:`grimoire.missions.intake_tasks`),
+comme ``grimoire task add --intake --create``.
+"""
+
+from __future__ import annotations
+
+import builtins
+import json
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from grimoire.core.fsio import locked
+from grimoire.missions.ledger_append import append_bytes
+
+__all__ = ["IDEA_MAX_CHARS", "IDEA_SOURCES", "Idea", "IdeaError", "IdeaStore"]
+
+IDEAS_FILE = "ideas.jsonl"
+DEFAULT_LEDGER = Path("_grimoire-runtime-output/ledger")
+#: Borne d'une idée : une phrase à garder, pas un brief (le même plafond que le champ du cockpit).
+IDEA_MAX_CHARS = 500
+IDEA_SOURCES = ("cli", "cockpit", "agent")
+
+
+class IdeaError(ValueError):
+    """Une demande refusée sur la boîte à idées : le message dit pourquoi."""
+
+
+@dataclass
+class Idea:
+    id: str
+    text: str
+    source: str
+    created_at: str
+    state: str = "open"
+    tasks: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "text": self.text,
+            "source": self.source,
+            "created_at": self.created_at,
+            "state": self.state,
+            "tasks": list(self.tasks),
+        }
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+class IdeaStore:
+    """Lecture et écriture de ``ideas.jsonl`` pour un projet."""
+
+    def __init__(self, project_root: Path, ledger_root: Path = DEFAULT_LEDGER) -> None:
+        root = ledger_root if ledger_root.is_absolute() else project_root / ledger_root
+        self.path = root / IDEAS_FILE
+
+    # ── lecture ──────────────────────────────────────────────────────────────
+
+    def _events(self) -> builtins.list[dict[str, Any]]:
+        try:
+            raw = self.path.read_text(encoding="utf-8")
+        except OSError:
+            return []
+        events: builtins.list[dict[str, Any]] = []
+        for line in raw.splitlines():
+            try:
+                event = json.loads(line)
+            except ValueError:
+                continue  # une fin tronquée ne casse pas la boîte
+            if isinstance(event, dict):
+                events.append(event)
+        return events
+
+    @staticmethod
+    def _fold(events: builtins.list[dict[str, Any]]) -> dict[str, Idea]:
+        ideas: dict[str, Idea] = {}
+        for event in events:
+            kind, idea_id = event.get("event"), str(event.get("id") or "")
+            if kind == "add":
+                ideas[idea_id] = Idea(
+                    idea_id,
+                    str(event.get("text") or ""),
+                    str(event.get("source") or "cli"),
+                    str(event.get("ts") or ""),
+                )
+                continue
+            idea = ideas.get(idea_id)
+            if idea is None:
+                continue
+            if kind == "drop" and idea.state == "open":
+                idea.state = "dropped"
+            elif kind == "restore" and idea.state == "dropped":
+                idea.state = "open"
+            elif kind == "promote" and idea.state != "promoted":
+                idea.state = "promoted"
+                idea.tasks = [str(t) for t in event.get("tasks") or ()]
+        return ideas
+
+    def list(self, state: str = "") -> builtins.list[Idea]:
+        """Les idées dans l'ordre d'ajout ; *state* filtre (``open``, ``promoted``, ``dropped``)."""
+        return [i for i in self._fold(self._events()).values() if not state or i.state == state]
+
+    def get(self, idea_id: str) -> Idea:
+        idea = self._fold(self._events()).get(idea_id)
+        if idea is None:
+            raise IdeaError(f"idée inconnue : {idea_id}")
+        return idea
+
+    # ── écriture ─────────────────────────────────────────────────────────────
+
+    def _append(self, event: dict[str, Any]) -> None:
+        append_bytes(self.path, (json.dumps(event, ensure_ascii=False, sort_keys=True) + "\n").encode("utf-8"))
+
+    def add(self, text: str, source: str = "cli") -> Idea:
+        text = " ".join(text.split())
+        if not text:
+            raise IdeaError("une idée vide n'est pas gardée")
+        if len(text) > IDEA_MAX_CHARS:
+            raise IdeaError(f"idée trop longue : {len(text)} caractères, {IDEA_MAX_CHARS} au plus")
+        if source not in IDEA_SOURCES:
+            raise IdeaError(f"source inconnue : {source} (attendu : {', '.join(IDEA_SOURCES)})")
+        with locked(self.path):
+            events = self._events()
+            number = 1 + sum(1 for e in events if e.get("event") == "add")
+            idea_id = f"IDEA-{number:04d}"
+            ts = _now()
+            self._append({"event": "add", "id": idea_id, "text": text, "source": source, "ts": ts})
+        return Idea(idea_id, text, source, ts)
+
+    def _transition(self, idea_id: str, kind: str, allowed: str, why: str, extra: dict[str, Any] | None = None) -> Idea:
+        with locked(self.path):
+            idea = self._fold(self._events()).get(idea_id)
+            if idea is None:
+                raise IdeaError(f"idée inconnue : {idea_id}")
+            if idea.state != allowed:
+                raise IdeaError(f"{idea_id} est {idea.state} : {why}")
+            self._append({"event": kind, "id": idea_id, "ts": _now(), **(extra or {})})
+        return self.get(idea_id)
+
+    def drop(self, idea_id: str) -> Idea:
+        return self._transition(idea_id, "drop", "open", "seule une idée ouverte s'écarte")
+
+    def restore(self, idea_id: str) -> Idea:
+        return self._transition(idea_id, "restore", "dropped", "seule une idée écartée se restaure")
+
+    def mark_promoted(self, idea_id: str, task_ids: builtins.list[str]) -> Idea:
+        """Marque l'idée ``promoted`` avec les tâches créées (le cockpit crée par l'intake, puis marque)."""
+        return self._transition(
+            idea_id,
+            "promote",
+            "open",
+            "elle a déjà été promue ou écartée",
+            {"tasks": [str(t) for t in task_ids]},
+        )
+
+    def promote(
+        self, idea_id: str, service: Any, *, actor: str = "cli", origin: str = "cli"
+    ) -> tuple[Idea, builtins.list[dict[str, Any]]]:
+        """Crée les tâches non critiques que l'intake propose, puis marque l'idée ``promoted``.
+
+        Une seconde promotion est refusée avant toute création. Les propositions critiques
+        ne sont jamais créées d'office : elles sont rendues dans ``skipped`` du premier retour.
+        """
+        from grimoire.missions.intake_tasks import create_from_proposals, proposals_for
+
+        with locked(self.path):
+            idea = self._fold(self._events()).get(idea_id)
+            if idea is None:
+                raise IdeaError(f"idée inconnue : {idea_id}")
+            if idea.state != "open":
+                raise IdeaError(f"{idea_id} est {idea.state} : seule une idée ouverte se promeut")
+            chosen = [p for p in proposals_for(idea.text) if p["checked"]]
+            if not chosen:
+                raise IdeaError(f"{idea_id} : l'intake ne propose que des tâches critiques, à créer à la main")
+            created = create_from_proposals(service, [{**p, "check": ""} for p in chosen], actor=actor, origin=origin)
+            self._append({"event": "promote", "id": idea_id, "ts": _now(), "tasks": [c["id"] for c in created]})
+        return self.get(idea_id), created

{grimoire_kit-3.76.0 → grimoire_kit-3.77.0}/src/grimoire/missions/ledger.py

@@ -684,9 +684,13 @@ class MissionLedger:
         with _ledger_file_lock(self._events_path):
             self._refresh()
             self._load()
-            return self._transition_locked(
+            moved = self._transition_locked(
                 task_id, to_state, actor_id, reason, claim, extra_payload, expected_from, lease_epoch, step
             )
+        if to_state in (TaskState.CLOSED, TaskState.CANCELLED):  # plus de session pour lire : tout est acquitté
+            for directive in moved.unacknowledged_directives:
+                moved = self.acknowledge_directive(task_id, directive.id, actor_id=actor_id, reason="tâche close")
+        return moved
 
     def _transition_locked(
         self,
@@ -1259,8 +1263,10 @@ class MissionLedger:
         self._load()
         return self._tasks[task_id]
 
-    def acknowledge_directive(self, task_id: str, directive_id: str, *, actor_id: str) -> MissionTask:
-        """Horodate l'accusé de réception d'une consigne connue de la tâche."""
+    def acknowledge_directive(
+        self, task_id: str, directive_id: str, *, actor_id: str, reason: str = ""
+    ) -> MissionTask:
+        """Horodate l'accusé de réception d'une consigne connue de la tâche ; *reason* dit pourquoi, s'il y a lieu."""
         self._load()
         task = self._tasks.get(task_id)
         if task is None:
@@ -1269,7 +1275,8 @@ class MissionLedger:
             raise GrimoireMissionError(f"Consigne inconnue sur {task_id} : {directive_id}")
         self._append_event(
             "task.directive_acknowledged", task_id, "task", actor_id,
-            {"task_id": task_id, "directive_id": directive_id, "acknowledged_at": _now_iso(), "actor_id": actor_id},
+            {"task_id": task_id, "directive_id": directive_id, "acknowledged_at": _now_iso(), "actor_id": actor_id,
+             **({"reason": reason} if reason else {})},
         )
         self._load()
         return self._tasks[task_id]