idc-wrapper 0.2.0__py3-none-any.whl

idc/__init__.py

@@ -0,0 +1,25 @@
+"""IDC — Effondrement Décisionnel Irréversible (Irreversible Decision Collapse).
+
+Package portable (stdlib) pour envelopper un LLM avec ressource finie,
+journal append-only et règle d'arrêt.
+
+L'adaptateur LangGraph-shaped vit dans `idc.langgraph_adapter` (pas d'import
+lourd ici) : `IdcGraphRunner` fonctionne sans langgraph ;
+`compile_langgraph` requiert l'extra optionnel `[langgraph]`.
+"""
+
+from .journal import AppendOnlyJournal, JournalEntry
+from .agent import IdcAgent, IdcRunResult, Backend
+from .mock_backend import MockBackend, MockScenario
+
+__all__ = [
+    "AppendOnlyJournal",
+    "JournalEntry",
+    "IdcAgent",
+    "IdcRunResult",
+    "Backend",
+    "MockBackend",
+    "MockScenario",
+]
+
+__version__ = "0.2.0"

idc/agent.py

@@ -0,0 +1,143 @@
+"""Agent IDC : ressource finie, journal, règle d'arrêt."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Protocol
+
+from .journal import AppendOnlyJournal, JournalEntry
+
+
+class Backend(Protocol):
+    def generate(self, prompt: str, max_tokens: int = 120) -> str: ...
+
+
+GainFn = Callable[[int, str], float]
+
+
+def default_gain(step: int, chunk: str) -> float:
+    del step
+    return 25.0 if len(chunk) > 20 else 8.0
+
+
+IGNORANCE_MSG = "Je ne sais pas (ressource insuffisante ou incertitude trop élevée)."
+
+
+@dataclass
+class IdcRunResult:
+    answer: str
+    steps: int
+    resource_final: float
+    tokens_approx_total: int
+    cost_total: float
+    stopped_early: bool
+    admitted_ignorance: bool
+    journal: AppendOnlyJournal
+    mode: str  # "idc" | "baseline"
+
+
+@dataclass
+class IdcAgent:
+    backend: Backend
+    resource: float = 100.0
+    critical_threshold: float = 15.0
+    cost_per_token: float = 0.8
+    max_steps: int = 8
+    journal: AppendOnlyJournal = field(default_factory=AppendOnlyJournal)
+    gain_fn: GainFn = field(default=default_gain)
+    use_stop_rule: bool = True
+    # Sous IDC : si aucun chunk non vide n'a dépassé le seuil de gain « utile »,
+    # préférer l'aveu d'ignorance à une réponse creuse.
+    prefer_ignorance_if_no_useful: bool = True
+    useful_gain_floor: float = 40.0  # aligné sur cost_per_token*50 par défaut
+
+    def still_worth_it(self, estimated_gain: float) -> bool:
+        marginal_cost = self.cost_per_token * 50.0
+        risk = 2.0 if self.resource < 30.0 else 1.0
+        return estimated_gain > marginal_cost * risk
+
+    def run(self, task: str) -> IdcRunResult:
+        current = ""
+        step = 0
+        tokens_total = 0
+        cost_total = 0.0
+        stopped_early = False
+        max_gain_seen = 0.0
+        any_useful = False
+
+        while self.resource > self.critical_threshold and step < self.max_steps:
+            step += 1
+            context = (
+                f"Journal des engagements précédents :\n{self.journal.as_context()}\n\n"
+                f"Tâche : {task}\n\n"
+                f"Réponse partielle actuelle :\n{current}\n\n"
+                "Continue ou affine la réponse. Sois concis."
+            )
+            chunk = self.backend.generate(context, max_tokens=120)
+            tokens_approx = max(len(chunk.split()), 1)  # tentative minimale
+            chunk_display = chunk.strip() if chunk.strip() else "(vide / incertitude)"
+
+            cost = tokens_approx * self.cost_per_token
+            self.resource = max(0.0, self.resource - cost)
+            tokens_total += tokens_approx
+            cost_total += cost
+            estimated_gain = self.gain_fn(step, chunk)
+            max_gain_seen = max(max_gain_seen, estimated_gain)
+            if chunk.strip() and estimated_gain >= self.useful_gain_floor:
+                any_useful = True
+
+            self.journal.append(
+                JournalEntry(
+                    step=step,
+                    text=chunk_display,
+                    resource_after=self.resource,
+                    tokens_approx=tokens_approx,
+                    cost=cost,
+                    estimated_gain=estimated_gain,
+                )
+            )
+
+            should_stop = False
+            if self.use_stop_rule:
+                if (not self.still_worth_it(estimated_gain)) or self.resource <= self.critical_threshold:
+                    should_stop = True
+            else:
+                if self.resource <= self.critical_threshold:
+                    should_stop = True
+
+            if chunk.strip():
+                current = f"{current}{chunk}\n".strip()
+
+            if should_stop:
+                break
+
+        if self.use_stop_rule and step < self.max_steps:
+            stopped_early = True
+
+        # Politique d'effondrement : ignorance si rien d'utile
+        if not current.strip():
+            admitted = True
+            answer = IGNORANCE_MSG
+        elif (
+            self.use_stop_rule
+            and self.prefer_ignorance_if_no_useful
+            and not any_useful
+            and max_gain_seen < self.useful_gain_floor
+        ):
+            admitted = True
+            answer = IGNORANCE_MSG
+        else:
+            admitted = False
+            answer = current.strip()
+
+        return IdcRunResult(
+            answer=answer,
+            steps=step,
+            resource_final=self.resource,
+            tokens_approx_total=tokens_total,
+            cost_total=cost_total,
+            stopped_early=stopped_early,
+            admitted_ignorance=admitted,
+            journal=self.journal,
+            mode="idc" if self.use_stop_rule else "baseline",
+        )

idc/journal.py

@@ -0,0 +1,48 @@
+"""Journal append-only : engagements irréversibles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class JournalEntry:
+    step: int
+    text: str
+    resource_after: float
+    tokens_approx: int = 0
+    cost: float = 0.0
+    estimated_gain: float = 0.0
+
+
+@dataclass
+class AppendOnlyJournal:
+    """Liste d'engagements ; on ne peut qu'ajouter (jamais réécrire)."""
+
+    entries: list[JournalEntry] = field(default_factory=list)
+
+    def append(self, entry: JournalEntry) -> None:
+        self.entries.append(entry)
+
+    def as_context(self) -> str:
+        if not self.entries:
+            return "(vide)"
+        return "\n---\n".join(
+            f"Étape {e.step} (R={e.resource_after:.1f}) : {e.text}" for e in self.entries
+        )
+
+    def to_dicts(self) -> list[dict]:
+        return [
+            {
+                "step": e.step,
+                "text": e.text,
+                "resource_after": e.resource_after,
+                "tokens_approx": e.tokens_approx,
+                "cost": e.cost,
+                "estimated_gain": e.estimated_gain,
+            }
+            for e in self.entries
+        ]
+
+    def __len__(self) -> int:
+        return len(self.entries)

idc/langgraph_adapter.py

@@ -0,0 +1,390 @@
+"""Adaptateur LangGraph-shaped pour IDC (dépendance optionnelle).
+
+Ce module **ne requiert pas** `langgraph` pour fonctionner : il expose une
+boucle nœud/état compatible avec le modèle mental de LangGraph (state dict,
+nœud de délibération, condition d'arrêt). Si `langgraph` est installé
+(`pip install idc-wrapper[langgraph]`), `compile_langgraph()` construit un
+vrai `StateGraph` ; sinon un ImportError clair est levé uniquement pour
+cette voie.
+
+Usage minimal (sans langgraph) ::
+
+    from idc.langgraph_adapter import IdcGraphRunner
+    from idc import MockBackend
+    from idc.mock_backend import VERBOSE
+
+    runner = IdcGraphRunner(backend=MockBackend(VERBOSE), use_stop_rule=True)
+    result = runner.run("tâche")
+
+Usage LangGraph réel (si installé) ::
+
+    from idc.langgraph_adapter import compile_langgraph
+    graph = compile_langgraph(backend=..., use_stop_rule=True)
+    out = graph.invoke({"task": "...", "resource": 100.0, ...})
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Mapping, MutableMapping, Optional, Protocol
+
+from .agent import Backend, GainFn, IGNORANCE_MSG, IdcRunResult, default_gain
+from .journal import AppendOnlyJournal, JournalEntry
+
+
+LANGGRAPH_INSTALL_HINT = (
+    "langgraph n'est pas installé. "
+    "Installez l'extra optionnel : pip install 'idc-wrapper[langgraph]' "
+    "ou pip install langgraph. "
+    "Sinon utilisez IdcGraphRunner (même interface nœud/état, sans dépendance)."
+)
+
+
+class _LangGraphMissing(Protocol):
+    """Marqueur de typage uniquement."""
+
+
+def require_langgraph() -> Any:
+    """Importe langgraph ou lève ImportError avec message d'installation."""
+    try:
+        import langgraph  # noqa: F401
+        from langgraph.graph import END, StateGraph  # type: ignore
+
+        return StateGraph, END
+    except ImportError as exc:  # pragma: no cover - chemin optionnel
+        raise ImportError(LANGGRAPH_INSTALL_HINT) from exc
+
+
+# ---------------------------------------------------------------------------
+# État LangGraph-shaped (stdlib)
+# ---------------------------------------------------------------------------
+
+IdcState = dict[str, Any]
+# Clés attendues :
+#   task: str
+#   answer: str
+#   partial: str
+#   step: int
+#   resource: float
+#   tokens_approx_total: int
+#   cost_total: float
+#   stopped: bool
+#   admitted_ignorance: bool
+#   journal_entries: list[dict]
+#   last_chunk: str
+#   last_gain: float
+#   max_gain_seen: float
+#   any_useful: bool
+#   use_stop_rule: bool
+
+
+def initial_state(
+    task: str,
+    *,
+    resource: float = 100.0,
+    use_stop_rule: bool = True,
+) -> IdcState:
+    return {
+        "task": task,
+        "answer": "",
+        "partial": "",
+        "step": 0,
+        "resource": float(resource),
+        "tokens_approx_total": 0,
+        "cost_total": 0.0,
+        "stopped": False,
+        "admitted_ignorance": False,
+        "journal_entries": [],
+        "last_chunk": "",
+        "last_gain": 0.0,
+        "max_gain_seen": 0.0,
+        "any_useful": False,
+        "use_stop_rule": use_stop_rule,
+    }
+
+
+@dataclass
+class IdcGraphConfig:
+    """Paramètres partagés par le nœud de délibération et le runner."""
+
+    backend: Backend
+    resource_init: float = 100.0
+    critical_threshold: float = 15.0
+    cost_per_token: float = 0.8
+    max_steps: int = 8
+    gain_fn: GainFn = field(default=default_gain)
+    use_stop_rule: bool = True
+    prefer_ignorance_if_no_useful: bool = True
+    useful_gain_floor: float = 40.0
+
+    def still_worth_it(self, estimated_gain: float, resource: float) -> bool:
+        marginal_cost = self.cost_per_token * 50.0
+        risk = 2.0 if resource < 30.0 else 1.0
+        return estimated_gain > marginal_cost * risk
+
+
+def deliberation_node(state: Mapping[str, Any], cfg: IdcGraphConfig) -> IdcState:
+    """Un tour de délibération IDC (nœud LangGraph-shaped).
+
+    Met à jour ressource, journal, gain ; marque `stopped` si la règle
+    d'arrêt (ou le seuil critique / max_steps) l'exige.
+    """
+    s = dict(state)
+    if s.get("stopped"):
+        return s
+
+    step = int(s.get("step", 0)) + 1
+    resource = float(s.get("resource", cfg.resource_init))
+    partial = str(s.get("partial", ""))
+    task = str(s.get("task", ""))
+    journal_entries = list(s.get("journal_entries") or [])
+
+    context = (
+        f"Journal des engagements précédents :\n"
+        f"{_journal_as_context(journal_entries)}\n\n"
+        f"Tâche : {task}\n\n"
+        f"Réponse partielle actuelle :\n{partial}\n\n"
+        "Continue ou affine la réponse. Sois concis."
+    )
+    chunk = cfg.backend.generate(context, max_tokens=120)
+    tokens_approx = max(len(chunk.split()), 1)
+    chunk_display = chunk.strip() if chunk.strip() else "(vide / incertitude)"
+    cost = tokens_approx * cfg.cost_per_token
+    resource = max(0.0, resource - cost)
+    estimated_gain = cfg.gain_fn(step, chunk)
+
+    journal_entries.append(
+        {
+            "step": step,
+            "text": chunk_display,
+            "resource_after": resource,
+            "tokens_approx": tokens_approx,
+            "cost": cost,
+            "estimated_gain": estimated_gain,
+        }
+    )
+
+    max_gain_seen = max(float(s.get("max_gain_seen", 0.0)), estimated_gain)
+    any_useful = bool(s.get("any_useful", False))
+    if chunk.strip() and estimated_gain >= cfg.useful_gain_floor:
+        any_useful = True
+
+    use_stop = bool(s.get("use_stop_rule", cfg.use_stop_rule))
+    should_stop = False
+    if use_stop:
+        if (not cfg.still_worth_it(estimated_gain, resource)) or resource <= cfg.critical_threshold:
+            should_stop = True
+    else:
+        if resource <= cfg.critical_threshold:
+            should_stop = True
+    if step >= cfg.max_steps:
+        should_stop = True
+
+    if chunk.strip():
+        partial = f"{partial}{chunk}\n".strip()
+
+    s.update(
+        {
+            "step": step,
+            "resource": resource,
+            "tokens_approx_total": int(s.get("tokens_approx_total", 0)) + tokens_approx,
+            "cost_total": float(s.get("cost_total", 0.0)) + cost,
+            "journal_entries": journal_entries,
+            "last_chunk": chunk_display,
+            "last_gain": estimated_gain,
+            "max_gain_seen": max_gain_seen,
+            "any_useful": any_useful,
+            "partial": partial,
+            "stopped": should_stop,
+            "use_stop_rule": use_stop,
+        }
+    )
+    if should_stop:
+        s.update(_finalize(s, cfg))
+    return s
+
+
+def should_continue(state: Mapping[str, Any]) -> str:
+    """Condition de routage : ``continue`` | ``end``."""
+    return "end" if state.get("stopped") else "continue"
+
+
+def _finalize(state: Mapping[str, Any], cfg: IdcGraphConfig) -> dict[str, Any]:
+    partial = str(state.get("partial", "")).strip()
+    use_stop = bool(state.get("use_stop_rule", cfg.use_stop_rule))
+    any_useful = bool(state.get("any_useful", False))
+    max_gain_seen = float(state.get("max_gain_seen", 0.0))
+
+    if not partial:
+        return {"answer": IGNORANCE_MSG, "admitted_ignorance": True}
+    if (
+        use_stop
+        and cfg.prefer_ignorance_if_no_useful
+        and not any_useful
+        and max_gain_seen < cfg.useful_gain_floor
+    ):
+        return {"answer": IGNORANCE_MSG, "admitted_ignorance": True}
+    return {"answer": partial, "admitted_ignorance": False}
+
+
+def _journal_as_context(entries: list[dict]) -> str:
+    if not entries:
+        return "(vide)"
+    return "\n---\n".join(
+        f"Étape {e['step']} (R={e['resource_after']:.1f}) : {e['text']}" for e in entries
+    )
+
+
+def state_to_result(state: Mapping[str, Any], cfg: IdcGraphConfig) -> IdcRunResult:
+    """Convertit l'état final en `IdcRunResult` (compat IdcAgent)."""
+    journal = AppendOnlyJournal()
+    for e in state.get("journal_entries") or []:
+        journal.append(
+            JournalEntry(
+                step=int(e["step"]),
+                text=str(e["text"]),
+                resource_after=float(e["resource_after"]),
+                tokens_approx=int(e.get("tokens_approx", 0)),
+                cost=float(e.get("cost", 0.0)),
+                estimated_gain=float(e.get("estimated_gain", 0.0)),
+            )
+        )
+    use_stop = bool(state.get("use_stop_rule", cfg.use_stop_rule))
+    step = int(state.get("step", 0))
+    stopped_early = bool(use_stop and step < cfg.max_steps and state.get("stopped"))
+    return IdcRunResult(
+        answer=str(state.get("answer", "")),
+        steps=step,
+        resource_final=float(state.get("resource", 0.0)),
+        tokens_approx_total=int(state.get("tokens_approx_total", 0)),
+        cost_total=float(state.get("cost_total", 0.0)),
+        stopped_early=stopped_early,
+        admitted_ignorance=bool(state.get("admitted_ignorance", False)),
+        journal=journal,
+        mode="idc" if use_stop else "baseline",
+    )
+
+
+@dataclass
+class IdcGraphRunner:
+    """Boucle nœud/état IDC sans dépendance langgraph.
+
+    Miroir conceptuel d'un StateGraph à un nœud ``deliberate`` + arête
+    conditionnelle ``should_continue``.
+    """
+
+    backend: Backend
+    resource: float = 100.0
+    critical_threshold: float = 15.0
+    cost_per_token: float = 0.8
+    max_steps: int = 8
+    gain_fn: GainFn = field(default=default_gain)
+    use_stop_rule: bool = True
+    prefer_ignorance_if_no_useful: bool = True
+    useful_gain_floor: float = 40.0
+
+    def config(self) -> IdcGraphConfig:
+        return IdcGraphConfig(
+            backend=self.backend,
+            resource_init=self.resource,
+            critical_threshold=self.critical_threshold,
+            cost_per_token=self.cost_per_token,
+            max_steps=self.max_steps,
+            gain_fn=self.gain_fn,
+            use_stop_rule=self.use_stop_rule,
+            prefer_ignorance_if_no_useful=self.prefer_ignorance_if_no_useful,
+            useful_gain_floor=self.useful_gain_floor,
+        )
+
+    def run(self, task: str) -> IdcRunResult:
+        cfg = self.config()
+        state = initial_state(task, resource=self.resource, use_stop_rule=self.use_stop_rule)
+        while not state.get("stopped"):
+            state = deliberation_node(state, cfg)
+            if int(state.get("step", 0)) >= cfg.max_steps:
+                state["stopped"] = True
+                state.update(_finalize(state, cfg))
+                break
+        if not state.get("answer"):
+            state.update(_finalize(state, cfg))
+        return state_to_result(state, cfg)
+
+    def invoke(self, state: MutableMapping[str, Any]) -> IdcState:
+        """API style LangGraph ``graph.invoke(state)``."""
+        cfg = self.config()
+        s: IdcState = initial_state(
+            str(state.get("task", "")),
+            resource=float(state.get("resource", self.resource)),
+            use_stop_rule=bool(state.get("use_stop_rule", self.use_stop_rule)),
+        )
+        s.update({k: v for k, v in state.items() if k in s or k == "task"})
+        while not s.get("stopped"):
+            s = deliberation_node(s, cfg)
+            if int(s.get("step", 0)) >= cfg.max_steps:
+                s["stopped"] = True
+                s.update(_finalize(s, cfg))
+                break
+        if not s.get("answer"):
+            s.update(_finalize(s, cfg))
+        return s
+
+
+def compile_langgraph(
+    backend: Backend,
+    *,
+    use_stop_rule: bool = True,
+    resource: float = 100.0,
+    critical_threshold: float = 15.0,
+    cost_per_token: float = 0.8,
+    max_steps: int = 8,
+    gain_fn: Optional[GainFn] = None,
+) -> Any:
+    """Compile un vrai ``StateGraph`` LangGraph si le package est installé.
+
+    Raises
+    ------
+    ImportError
+        Message clair avec hint ``pip install idc-wrapper[langgraph]``.
+    """
+    StateGraph, END = require_langgraph()
+    cfg = IdcGraphConfig(
+        backend=backend,
+        resource_init=resource,
+        critical_threshold=critical_threshold,
+        cost_per_token=cost_per_token,
+        max_steps=max_steps,
+        gain_fn=gain_fn or default_gain,
+        use_stop_rule=use_stop_rule,
+    )
+
+    # État typé de façon souple (dict) pour rester compatible versions langgraph.
+    graph = StateGraph(dict)
+
+    def _node(state: dict) -> dict:
+        return deliberation_node(state, cfg)
+
+    def _route(state: dict) -> str:
+        return should_continue(state)
+
+    graph.add_node("deliberate", _node)
+    graph.set_entry_point("deliberate")
+    graph.add_conditional_edges(
+        "deliberate",
+        _route,
+        {"continue": "deliberate", "end": END},
+    )
+    return graph.compile()
+
+
+__all__ = [
+    "LANGGRAPH_INSTALL_HINT",
+    "IdcState",
+    "IdcGraphConfig",
+    "IdcGraphRunner",
+    "initial_state",
+    "deliberation_node",
+    "should_continue",
+    "state_to_result",
+    "compile_langgraph",
+    "require_langgraph",
+]

idc/mock_backend.py

@@ -0,0 +1,145 @@
+"""Backend mock déterministe — aucun appel réseau, aucune clé API.
+
+Produit des réponses scriptées pour exemples et micro-benchmarks.
+Les nombres mesurés sur ce mock ne sont PAS des résultats de production LLM.
+
+Note sur les gains : la heuristique VOI du dépôt compare
+`estimated_gain` à `cost_per_token * 50` (≈ 40 avec le défaut 0.8).
+Les gains des premières étapes utiles sont donc calibrés > 40 pour
+permettre 2–3 tours productifs avant l'arrêt ; les étapes suivantes
+passent sous le seuil (affinage / hallucination / boucle).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+
+@dataclass
+class MockScenario:
+    """Scénario de réponses + gain estimé par étape.
+
+    `responses` : liste de chunks texte (une par étape).
+    `gains` : gain VOI estimé par étape (calibré vs coût marginal ≈ 40).
+    `uncertain` : scénario d'incertitude (favorise l'aveu d'ignorance).
+    """
+
+    name: str
+    responses: list[str]
+    gains: list[float] | None = None
+    uncertain: bool = False
+
+
+SUPPORT_CLIENT = MockScenario(
+    name="support_client",
+    responses=[
+        "Diagnostic : délai de livraison signalé. Vérification du tracking.",
+        "Cause probable : transit international, pas de perte colis.",
+        "Action engagée : remboursement partiel ou relance transporteur.",
+        "Affinage inutile : le client a déjà les options claires.",
+        "Répétition : mêmes options, aucun fait nouveau.",
+        "Hallucination potentielle : inventer un numéro de suivi fantôme.",
+        "Encore une invention : fausse date de livraison garantie.",
+        "Boucle : reformuler sans valeur ajoutée.",
+    ],
+    # Coût marginal ≈ 40 → étapes 1–3 utiles, puis stop
+    gains=[55.0, 48.0, 42.0, 12.0, 8.0, 5.0, 3.0, 2.0],
+)
+
+CODE_ASSISTANT = MockScenario(
+    name="code_assistant",
+    responses=[
+        "Bug localisé : index hors bornes sur liste vide.",
+        "Correctif : garde `if not items: return []` avant l'index.",
+        "Test unitaire suggéré pour le cas vide.",
+        "Refacto cosmétique sans impact fonctionnel.",
+        "Suggestion speculative hors scope.",
+        "Invention d'API inexistante.",
+        "Encore une API fantôme.",
+        "Boucle de reformulation.",
+    ],
+    gains=[58.0, 50.0, 43.0, 14.0, 7.0, 4.0, 3.0, 2.0],
+)
+
+RESEARCH_SYNTH = MockScenario(
+    name="research_synth",
+    responses=[
+        "Sources : 3 papiers sur finitude et arrêt optimal.",
+        "Synthèse : budget de délibération + journal irréversible.",
+        "Limite : pas de preuve empirique LLM à grande échelle ici.",
+        "Digression méthodologique faible valeur.",
+        "Citation inventée (à éviter).",
+        "Seconde citation inventée.",
+        "Reformulation sans source.",
+        "Boucle narrative.",
+    ],
+    gains=[52.0, 46.0, 41.0, 11.0, 6.0, 4.0, 3.0, 2.0],
+)
+
+UNCERTAIN = MockScenario(
+    name="uncertain",
+    responses=[
+        "",  # pas de contenu fiable
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    gains=[9.0, 6.0, 3.0, 2.0, 1.0, 1.0, 1.0, 1.0],
+    uncertain=True,
+)
+
+VERBOSE = MockScenario(
+    name="verbose",
+    responses=[
+        "Point A utile : définition courte du problème.",
+        "Point B utile : contrainte principale identifiée.",
+        "Point C utile : option d'action recommandée.",
+        "Point D : digression longue sans fait nouveau, mots mots mots.",
+        "Point E : reformulation synonymique coûteuse en tokens.",
+        "Point F : invention plausible mais non fondée.",
+        "Point G : suite de l'invention.",
+        "Point H : boucle complète.",
+    ],
+    gains=[50.0, 45.0, 41.0, 10.0, 6.0, 4.0, 2.0, 1.0],
+)
+
+SCENARIOS: dict[str, MockScenario] = {
+    s.name: s
+    for s in (SUPPORT_CLIENT, CODE_ASSISTANT, RESEARCH_SYNTH, UNCERTAIN, VERBOSE)
+}
+
+
+@dataclass
+class MockBackend:
+    """Backend LLM factice : consomme `responses` dans l'ordre."""
+
+    scenario: MockScenario
+    call_count: int = 0
+    _extra: list[str] = field(default_factory=list)
+
+    def __call__(self, prompt: str, max_tokens: int = 120) -> str:
+        return self.generate(prompt, max_tokens)
+
+    def generate(self, prompt: str, max_tokens: int = 120) -> str:
+        del prompt, max_tokens
+        idx = self.call_count
+        self.call_count += 1
+        if idx < len(self.scenario.responses):
+            return self.scenario.responses[idx]
+        if self._extra:
+            return self._extra[min(idx - len(self.scenario.responses), len(self._extra) - 1)]
+        return ""
+
+    def gain_for_step(self, step: int, chunk: str) -> float:
+        if self.scenario.gains and 1 <= step <= len(self.scenario.gains):
+            return self.scenario.gains[step - 1]
+        return 25.0 if len(chunk) > 20 else 8.0
+
+
+def make_gain_fn(backend: MockBackend) -> Callable[[int, str], float]:
+    return backend.gain_for_step

idc/test_agent.py

@@ -0,0 +1,49 @@
+"""Tests unitaires (stdlib unittest) — mock only, pas de clé API."""
+
+from __future__ import annotations
+
+import unittest
+
+from idc import IdcAgent, MockBackend
+from idc.mock_backend import SUPPORT_CLIENT, UNCERTAIN, VERBOSE
+
+
+class TestIdcVsBaseline(unittest.TestCase):
+    def test_idc_stops_earlier_than_baseline_on_verbose(self) -> None:
+        b_idc = MockBackend(VERBOSE)
+        b_base = MockBackend(VERBOSE)
+        idc = IdcAgent(backend=b_idc, use_stop_rule=True, gain_fn=b_idc.gain_for_step)
+        base = IdcAgent(backend=b_base, use_stop_rule=False, gain_fn=b_base.gain_for_step)
+        r_idc = idc.run("tâche verbose")
+        r_base = base.run("tâche verbose")
+        self.assertLess(r_idc.steps, r_base.steps)
+        self.assertGreaterEqual(r_idc.resource_final, r_base.resource_final)
+        self.assertGreaterEqual(r_idc.steps, 2)
+        self.assertLessEqual(r_idc.steps, 4)
+
+    def test_journal_grows_monotonically(self) -> None:
+        b = MockBackend(SUPPORT_CLIENT)
+        agent = IdcAgent(backend=b, use_stop_rule=True, gain_fn=b.gain_for_step)
+        r = agent.run("où est mon colis ?")
+        self.assertGreaterEqual(len(r.journal), 2)
+        steps = [e.step for e in r.journal.entries]
+        self.assertEqual(steps, list(range(1, len(steps) + 1)))
+
+    def test_uncertain_admits_ignorance_under_idc(self) -> None:
+        b = MockBackend(UNCERTAIN)
+        agent = IdcAgent(
+            backend=b,
+            resource=100.0,
+            critical_threshold=15.0,
+            cost_per_token=0.8,
+            max_steps=8,
+            use_stop_rule=True,
+            gain_fn=b.gain_for_step,
+        )
+        r = agent.run("question sans source")
+        self.assertTrue(r.admitted_ignorance)
+        self.assertLess(r.steps, 8)
+
+
+if __name__ == "__main__":
+    unittest.main()

idc/test_langgraph_adapter.py

@@ -0,0 +1,109 @@
+"""Tests adaptateur LangGraph-shaped — mock only, langgraph optionnel."""
+
+from __future__ import annotations
+
+import unittest
+
+from idc import MockBackend
+from idc.langgraph_adapter import (
+    LANGGRAPH_INSTALL_HINT,
+    IdcGraphRunner,
+    compile_langgraph,
+    deliberation_node,
+    initial_state,
+    require_langgraph,
+    should_continue,
+)
+from idc.mock_backend import UNCERTAIN, VERBOSE
+
+
+class TestIdcGraphRunner(unittest.TestCase):
+    def test_idc_stops_earlier_than_baseline(self) -> None:
+        b_idc = MockBackend(VERBOSE)
+        b_base = MockBackend(VERBOSE)
+        idc = IdcGraphRunner(backend=b_idc, use_stop_rule=True, gain_fn=b_idc.gain_for_step)
+        base = IdcGraphRunner(backend=b_base, use_stop_rule=False, gain_fn=b_base.gain_for_step)
+        r_idc = idc.run("tâche verbose")
+        r_base = base.run("tâche verbose")
+        self.assertLess(r_idc.steps, r_base.steps)
+        self.assertGreaterEqual(r_idc.resource_final, r_base.resource_final)
+        self.assertTrue(r_idc.stopped_early)
+        self.assertEqual(r_idc.mode, "idc")
+        self.assertEqual(r_base.mode, "baseline")
+
+    def test_node_loop_marks_stop(self) -> None:
+        b = MockBackend(VERBOSE)
+        cfg = IdcGraphRunner(backend=b, use_stop_rule=True, gain_fn=b.gain_for_step).config()
+        state = initial_state("x", use_stop_rule=True)
+        for _ in range(8):
+            state = deliberation_node(state, cfg)
+            if should_continue(state) == "end":
+                break
+        self.assertTrue(state["stopped"])
+        self.assertLess(state["step"], 8)
+        self.assertGreaterEqual(len(state["journal_entries"]), 2)
+
+    def test_uncertain_admits_ignorance(self) -> None:
+        b = MockBackend(UNCERTAIN)
+        r = IdcGraphRunner(
+            backend=b, use_stop_rule=True, gain_fn=b.gain_for_step
+        ).run("question sans source")
+        self.assertTrue(r.admitted_ignorance)
+
+    def test_invoke_api(self) -> None:
+        b = MockBackend(VERBOSE)
+        out = IdcGraphRunner(backend=b, use_stop_rule=True, gain_fn=b.gain_for_step).invoke(
+            {"task": "demo", "resource": 100.0}
+        )
+        self.assertIn("answer", out)
+        self.assertTrue(out["stopped"])
+
+
+class TestLangGraphOptional(unittest.TestCase):
+    def test_require_langgraph_message_or_import(self) -> None:
+        try:
+            StateGraph, END = require_langgraph()
+            self.assertIsNotNone(StateGraph)
+            self.assertIsNotNone(END)
+        except ImportError as exc:
+            self.assertIn("idc-wrapper[langgraph]", str(exc))
+            self.assertIn("langgraph", str(exc).lower())
+
+    def test_compile_langgraph_or_skip(self) -> None:
+        b = MockBackend(VERBOSE)
+        try:
+            graph = compile_langgraph(
+                backend=b,
+                use_stop_rule=True,
+                gain_fn=b.gain_for_step,
+            )
+        except ImportError as exc:
+            self.assertIn(LANGGRAPH_INSTALL_HINT.split(".")[0], str(exc))
+            self.skipTest("langgraph non installé — OK pour CI")
+            return
+        # Si langgraph est présent : un invoke court doit s'arrêter tôt sous IDC.
+        out = graph.invoke(
+            {
+                "task": "demo langgraph",
+                "answer": "",
+                "partial": "",
+                "step": 0,
+                "resource": 100.0,
+                "tokens_approx_total": 0,
+                "cost_total": 0.0,
+                "stopped": False,
+                "admitted_ignorance": False,
+                "journal_entries": [],
+                "last_chunk": "",
+                "last_gain": 0.0,
+                "max_gain_seen": 0.0,
+                "any_useful": False,
+                "use_stop_rule": True,
+            }
+        )
+        self.assertTrue(out.get("stopped"))
+        self.assertLess(int(out.get("step", 99)), 8)
+
+
+if __name__ == "__main__":
+    unittest.main()

idc_agent.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""IDC agent CLI — entrée fine (OpenAI-compatible ou --mock).
+
+Usage:
+  export OPENAI_API_KEY=...
+  python python/idc_agent.py "Your task here"
+
+  # Sans clé API (démo déterministe) :
+  python python/idc_agent.py --mock support_client "Question client : où est mon colis ?"
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+# Permettre `python python/idc_agent.py` depuis la racine du dépôt
+_ROOT = Path(__file__).resolve().parent
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+from idc import AppendOnlyJournal, IdcAgent, MockBackend, MockScenario  # noqa: E402
+from idc.mock_backend import SCENARIOS  # noqa: E402
+
+
+class OpenAIBackend:
+    def __init__(self, api_url: str, api_key: str, model: str) -> None:
+        self.api_url = api_url
+        self.api_key = api_key
+        self.model = model
+
+    def generate(self, prompt: str, max_tokens: int = 120) -> str:
+        body = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": max_tokens,
+            "temperature": 0.7,
+        }
+        req = urllib.request.Request(
+            self.api_url,
+            data=json.dumps(body).encode("utf-8"),
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        choices = data.get("choices") or []
+        if not choices:
+            return ""
+        return choices[0].get("message", {}).get("content") or ""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="IDC agent (OpenAI-compatible or --mock)")
+    parser.add_argument("task", nargs="*", help="Tâche / question")
+    parser.add_argument(
+        "--mock",
+        metavar="SCENARIO",
+        choices=sorted(SCENARIOS.keys()),
+        help="Utiliser un backend mock (pas de clé API)",
+    )
+    parser.add_argument("--baseline", action="store_true", help="Désactiver la règle d'arrêt VOI")
+    parser.add_argument("--resource", type=float, default=100.0)
+    parser.add_argument("--threshold", type=float, default=15.0)
+    parser.add_argument("--max-steps", type=int, default=8)
+    parser.add_argument("--cost-per-token", type=float, default=0.8)
+    args = parser.parse_args()
+
+    task = " ".join(args.task).strip() or (
+        "Explique en 5 points pourquoi la finitude computationnelle peut réduire les hallucinations."
+    )
+
+    if args.mock:
+        scenario = SCENARIOS[args.mock]
+        backend: object = MockBackend(scenario=scenario)
+        gain_fn = backend.gain_for_step  # type: ignore[attr-defined]
+    else:
+        base = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/")
+        api_key = os.environ.get("OPENAI_API_KEY", "")
+        if not api_key:
+            raise SystemExit(
+                "Set OPENAI_API_KEY, or pass --mock <scenario> "
+                f"(scenarios: {', '.join(sorted(SCENARIOS))})."
+            )
+        backend = OpenAIBackend(
+            api_url=f"{base}/chat/completions",
+            api_key=api_key,
+            model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
+        )
+        gain_fn = None
+
+    agent_kwargs = dict(
+        backend=backend,
+        resource=args.resource,
+        critical_threshold=args.threshold,
+        cost_per_token=args.cost_per_token,
+        max_steps=args.max_steps,
+        use_stop_rule=not args.baseline,
+    )
+    if gain_fn is not None:
+        agent_kwargs["gain_fn"] = gain_fn
+
+    agent = IdcAgent(**agent_kwargs)
+    try:
+        result = agent.run(task)
+    except urllib.error.HTTPError as e:
+        raise SystemExit(f"HTTP {e.code}: {e.read().decode('utf-8', errors='replace')}") from e
+
+    mode = "BASELINE (pas de VOI)" if args.baseline else "IDC (règle d'arrêt)"
+    print(f"=== MODE : {mode} ===")
+    for e in result.journal.entries:
+        print(
+            f"[étape {e.step}] R={e.resource_after:.1f} | "
+            f"coût={e.cost:.1f} | gain≈{e.estimated_gain:.1f} | tokens≈{e.tokens_approx}"
+        )
+    if result.stopped_early:
+        print("→ Arrêt anticipé (VOI / seuil).")
+    print("\n=== RÉPONSE FINALE (après effondrement) ===\n" + result.answer)
+    print("\n=== JOURNAL APPEND-ONLY ===\n" + result.journal.as_context())
+    print(
+        f"\nRessource finale : {result.resource_final:.1f} | "
+        f"étapes : {result.steps} | tokens≈{result.tokens_approx_total} | "
+        f"ignorance : {result.admitted_ignorance}"
+    )
+
+
+# Ré-exports pour import legacy : `from idc_agent import IdcAgent, AppendOnlyJournal`
+__all__ = ["AppendOnlyJournal", "IdcAgent", "MockBackend", "MockScenario", "main"]
+
+if __name__ == "__main__":
+    main()

idc_wrapper-0.2.0.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.4
+Name: idc-wrapper
+Version: 0.2.0
+Summary: IDC — Effondrement Décisionnel Irréversible : ressource finie, journal append-only, règle d'arrêt pour agents LLM.
+Author: Micaël Lanoix
+License: MIT
+Project-URL: Homepage, https://github.com/lanoixdesign/idc-wrapper
+Project-URL: Repository, https://github.com/lanoixdesign/idc-wrapper
+Project-URL: Issues, https://github.com/lanoixdesign/idc-wrapper/issues
+Project-URL: Changelog, https://github.com/lanoixdesign/idc-wrapper/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/lanoixdesign/idc-wrapper#readme
+Keywords: idc,agents,llm,finitude,stop-rule,agi,langgraph
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.2; extra == "langgraph"
+Dynamic: license-file
+
+# IDC Wrapper
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+[![Release](https://img.shields.io/github/v/release/lanoixdesign/idc-wrapper?display_name=tag&sort=semver)](https://github.com/lanoixdesign/idc-wrapper/releases/tag/v0.2.0)
+[![CI](https://github.com/lanoixdesign/idc-wrapper/actions/workflows/ci.yml/badge.svg)](https://github.com/lanoixdesign/idc-wrapper/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](./python/)
+[![Rust](https://img.shields.io/badge/rust-2021-orange.svg)](./Cargo.toml)
+
+**Couche d’enveloppe IDC — Effondrement Décisionnel Irréversible**  
+Open source, pensée pour **tous les runtimes d’agents** (Cursor, Claude Code, LangGraph, OpenAI Agents, boucles custom…).
+
+> **English** — Finite deliberation budget `R`, append-only journal, optimal stop rule.
+> Hallucination should cost more than admitting ignorance. Mock benches are real
+> numbers on a fake LLM; theory remains hypothesis — see [PERFORMANCE.md](./PERFORMANCE.md).
+
+## Pourquoi l’IDC (vision, sans claims inventés)
+
+Une IA sans **finitude** peut réfléchir sans fin, hésiter, et inventer : inventer
+ne coûte souvent pas plus cher qu’avouer « je ne sais pas ». L’IDC propose
+d’envelopper le modèle avec :
+
+1. une **ressource finie** `R` qui décroît avec le calcul,
+2. un **journal append-only** (engagements irréversibles),
+3. une **règle d’arrêt** (s’effondrer quand la valeur marginale de réfléchir
+   ne justifie plus le coût).
+
+C’est un **modèle + protocole de test**, pas une preuve empirique déjà validée
+sur les LLM de frontier. Les chiffres de ce dépôt viennent d’un **mock**
+reproductible — voir [PERFORMANCE.md](./PERFORMANCE.md).
+
+## Livre / concept
+
+- Livre (Amazon FR) : [Effondrement Décisionnel Irréversible](https://www.amazon.fr/dp/B0HMX1CY6R)
+- Citation machine-readable : [`CITATION.cff`](./CITATION.cff)
+
+## Table des matières
+
+- [Pour les agents](#pour-les-agents)
+- [Quickstart Python](#quickstart-python)
+- [Quickstart Rust](#quickstart-rust)
+- [Exemples](#exemples)
+- [Adaptateur LangGraph](#adaptateur-langgraph)
+- [Packs agents](#packs-agents)
+- [Performance (mock)](#performance-mock)
+- [Structure](#structure)
+- [Paramètres](#paramètres)
+- [Roadmap](#roadmap)
+- [Communauté](#communauté)
+- [Licence & auteur](#licence--auteur)
+
+## Pour les agents
+
+Lis d’abord **[AGENTS.md](./AGENTS.md)**.
+
+| Fichier | Rôle |
+|---------|------|
+| [`agents/skills/idc/SKILL.md`](./agents/skills/idc/SKILL.md) | Skill / recipe portable |
+| [`schema/idc-protocol.json`](./schema/idc-protocol.json) | Contrat machine-readable |
+| [`python/idc/`](./python/idc/) | Package référence (journal, agent, mock) |
+| [`python/idc/langgraph_adapter.py`](./python/idc/langgraph_adapter.py) | Adaptateur LangGraph-shaped (optionnel) |
+| [`python/idc_agent.py`](./python/idc_agent.py) | CLI (OpenAI-compatible ou `--mock`) |
+| [`src/lib.rs`](./src/lib.rs) | Bibliothèque Rust (`IdcAgent`, journal) |
+| [`src/main.rs`](./src/main.rs) | Binaire CLI mince |
+| [`examples/`](./examples/) | Cas Sans IDC / Avec IDC |
+| [`packs/`](./packs/) | Snippets Cursor / Claude / OpenAI Agents |
+| [`PERFORMANCE.md`](./PERFORMANCE.md) | Mesures mock + hypothèses vs démontré |
+
+## Quickstart Python
+
+```bash
+# Démo sans clé API (recommandé pour découvrir)
+PYTHONPATH=python python3 python/idc_agent.py --mock support_client \
+  "Client : où est mon colis ?"
+
+# Comparer baseline (pas de VOI) vs IDC
+PYTHONPATH=python python3 python/idc_agent.py --mock verbose --baseline "long"
+PYTHONPATH=python python3 python/idc_agent.py --mock verbose "long"
+
+# Avec API compatible OpenAI
+export OPENAI_API_KEY=sk-...
+# optionnel : OPENAI_BASE_URL=http://localhost:11434/v1  OPENAI_MODEL=llama3.2
+PYTHONPATH=python python3 python/idc_agent.py "Explique l’IDC en 5 points"
+```
+
+Installation package (editable locale ; PyPI public prévu — voir [PUBLISHING.md](./PUBLISHING.md)) :
+
+```bash
+pip install -e .
+# ou plus tard : pip install idc-wrapper
+```
+
+Tests / bench (aucune clé) :
+
+```bash
+PYTHONPATH=python python3 -m unittest discover -s python/idc -v
+PYTHONPATH=python python3 benchmarks/bench_mock.py
+```
+
+## Quickstart Rust
+
+```bash
+cargo build --release
+export OPENAI_API_KEY=sk-...
+./target/release/idc-wrapper
+```
+
+La logique vit dans la **crate lib** `idc_wrapper` (`src/lib.rs`) ; le binaire
+`src/main.rs` l’appelle seulement. Par défaut : `https://api.openai.com/v1/chat/completions`,
+modèle `gpt-4o-mini`.
+
+> **Note toolchain** : `cargo check` / `cargo build` nécessitent un Rust stable
+> récent (CI utilise `dtolnay/rust-toolchain@stable`). Si ton `rustc` local est
+> trop ancien pour les dépendances (`reqwest` / `tokio`), la structure lib+bin
+> reste valide — mets à jour le toolchain ou peaufine en CI.
+
+## Exemples
+
+Cas concrets avec narration **Sans IDC / Avec IDC / Bénéfice** et scripts mock :
+
+| # | Dossier | Idée |
+|---|---------|------|
+| 01 | [`examples/01_support_client`](./examples/01_support_client/) | Support livraison |
+| 02 | [`examples/02_code_assistant`](./examples/02_code_assistant/) | Fix bug + stop avant API fantôme |
+| 03 | [`examples/03_research_synth`](./examples/03_research_synth/) | Synthèse bornée, pas de citation inventée |
+| 04 | [`examples/04_langgraph`](./examples/04_langgraph/) | Boucle nœud/état style LangGraph + arrêt IDC |
+
+Voir [`examples/README.md`](./examples/README.md). Flux ASCII/Mermaid : [`docs/demo.md`](./docs/demo.md).
+
+## Adaptateur LangGraph
+
+Boucle **nœud / état** compatible LangGraph, **sans dépendance obligatoire** :
+
+```bash
+# démo mock (stdlib)
+PYTHONPATH=python python3 examples/04_langgraph/run_mock.py
+
+# optionnel : vrai StateGraph
+pip install 'idc-wrapper[langgraph]'   # ou : pip install langgraph
+```
+
+```python
+from idc.langgraph_adapter import IdcGraphRunner, compile_langgraph
+# IdcGraphRunner : toujours disponible
+# compile_langgraph(...) : ImportError clair si langgraph absent
+```
+
+Détails : [`examples/04_langgraph/README.md`](./examples/04_langgraph/README.md).
+
+## Packs agents
+
+Snippets copy-paste prêts :
+
+| Runtime | Pack |
+|---------|------|
+| Cursor | [`packs/cursor/RULE.md`](./packs/cursor/RULE.md) + [`packs/cursor/idc.mdc`](./packs/cursor/idc.mdc) |
+| Claude Code | [`packs/claude/CLAUDE.md`](./packs/claude/CLAUDE.md) |
+| OpenAI Agents SDK | [`packs/openai-agents/README.md`](./packs/openai-agents/README.md) (interface + stub) |
+
+## Performance (mock)
+
+Micro-benchmark **Baseline (N fixes) vs IDC (règle d’arrêt)** sur réponses mock.
+Dernière agrégation typique (régénérer localement pour confirmer) :
+
+| Agrégat | Baseline | IDC |
+|---------|----------|-----|
+| Étapes moyennes | 8.0 | ~3.4 |
+| Tokens≈ moyens | ~44.8 | ~26.6 |
+| R finale moyenne | ~64.2 | ~78.7 |
+
+Détail, caveats, et distinction **hypothèse livre vs démontré par le code** :
+**[PERFORMANCE.md](./PERFORMANCE.md)**. Aucun claim de perf LLM réel ici.
+
+## Structure
+
+```
+idc-wrapper/
+├── AGENTS.md                 # contrat pour runtimes agents
+├── PERFORMANCE.md            # mesures mock honnêtes
+├── ROADMAP.md                # v0.3 / v0.4
+├── PUBLISHING.md             # PyPI trusted publisher
+├── python/idc/               # package (journal, agent, mock, langgraph_adapter)
+├── python/idc_agent.py       # CLI
+├── src/lib.rs                # crate Rust publique
+├── src/main.rs               # binaire mince
+├── schema/idc-protocol.json
+├── agents/skills/idc/SKILL.md
+├── packs/                    # Cursor / Claude / OpenAI Agents
+├── examples/                 # 4 cas + README (dont LangGraph)
+├── docs/demo.md              # flux IDC (ASCII / Mermaid)
+├── benchmarks/               # bench_mock.py + results/
+├── community/                # good-first-issues prêts à coller
+└── .github/                  # CI, publish-pypi, templates
+```
+
+## Paramètres
+
+| Paramètre | Défaut | Rôle |
+|-----------|--------|------|
+| `resource` | 100.0 | Budget initial |
+| `critical_threshold` | 15.0 | Force l’arrêt |
+| `cost_per_token` | 0.8 | Coût approx. par token |
+| `max_steps` | 8 | Garde-fou |
+
+Heuristique VOI simple : `estimated_gain > cost_per_token * 50 * risk`.
+
+## Roadmap
+
+Priorités v0.3 / v0.4 (PyPI live, crates.io, bench LLM réel, plus d’adapters) :
+**[ROADMAP.md](./ROADMAP.md)**.
+
+## Communauté
+
+- Contribuer : [CONTRIBUTING.md](./CONTRIBUTING.md) (FR + EN) — active aussi **Discussions** (Settings → Features)
+- Conduite : [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md)
+- Sécurité : [SECURITY.md](./SECURITY.md)
+- Changelog : [CHANGELOG.md](./CHANGELOG.md)
+- Good first issues : [community/GOOD_FIRST_ISSUES.md](./community/GOOD_FIRST_ISSUES.md)
+- Issues / PR : templates dans `.github/`
+- Publication PyPI : [PUBLISHING.md](./PUBLISHING.md)
+
+Idées bienvenues : VOI plus fine, persistance disque du journal, publish crates.io,
+adapter Agents SDK réel, calibrage dynamique du seuil — **avec mesures
+reproductibles**, pas de chiffres inventés. (Adaptateur LangGraph-shaped : v0.2.0.)
+
+## Licence & auteur
+
+[MIT](./LICENSE) — Copyright (c) 2026 Micaël Lanoix
+
+**Micaël Lanoix** — continuité des travaux sur l’ADN numérique des images
+(PNGIA / Pixel 4D) et l’Effondrement Décisionnel Irréversible.
+
+Citation : voir [`CITATION.cff`](./CITATION.cff). Livre : [Amazon FR](https://www.amazon.fr/dp/B0HMX1CY6R).

idc_wrapper-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+idc_agent.py,sha256=FKwAnRoUgvRpOZrZiUjosXu6XHNGJSadXROf06RGHyo,4981
+idc/__init__.py,sha256=hkJicdNQvR5Zewd17UeN_e4dXUqmVtyJ41uI1szZriY,729
+idc/agent.py,sha256=pHCKdR7DdJVL6fjJmapFXrlTh-MgvXYAW4zw2L1jHDc,4705
+idc/journal.py,sha256=ajjwGkp9P8Eav7UGyq2VZ9xXNF8SeaKh5jS6WGj3ki4,1243
+idc/langgraph_adapter.py,sha256=QNWmq31X2eO8qe-uVtvgyU5skIaK9wdZEGF7r0Ca1xs,12782
+idc/mock_backend.py,sha256=FdxSWTjMVSxGE-JLGNM6WhYIAcYXsXKLcgeozFW86UA,4972
+idc/test_agent.py,sha256=_eeOSaobZJ7FV3KMxMnPyMamivwBFtqOxqlR8wTrS0I,1823
+idc/test_langgraph_adapter.py,sha256=_7zfpKLxvWfaSP-dghOCshcN11ymAk25B6HRhZBIflQ,3933
+idc_wrapper-0.2.0.dist-info/licenses/LICENSE,sha256=e4aLNilgWIh9zBtkI1TgbpBUYCHFHhgWHNHliiC8_fA,1071
+idc_wrapper-0.2.0.dist-info/METADATA,sha256=kqjcAL5mqgXk0gio3jq27gJlH7Z3KbRquFs_LY4AdJQ,10807
+idc_wrapper-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+idc_wrapper-0.2.0.dist-info/entry_points.txt,sha256=CvyLvrPTa3-X3QnTQTIY1Q5oGTpvaEXCmabb0l9C_5k,45
+idc_wrapper-0.2.0.dist-info/top_level.txt,sha256=M633gtg4v9SL3I17-BO_cZfAOXSgqtgsKA6V8O9tPLY,14
+idc_wrapper-0.2.0.dist-info/RECORD,,

idc_wrapper-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

idc_wrapper-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+idc-agent = idc_agent:main

idc_wrapper-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Micaël Lanoix
+
+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.

idc_wrapper-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+idc
+idc_agent