fix(permissions): validate network access flow

.ideai/memory/MEMORY.md

@@ -67,3 +67,6 @@
 - [ticket74-f1-web-bundle-transport-seam](ticket74-f1-web-bundle-transport-seam.md) — Deux artefacts Vite (dist/dist-web), mode `web` portable Windows, et le câblage anti-divergence de la constante de transport.
 - [ticket43-backend-b1-b4-qa-validation](ticket43-backend-b1-b4-qa-validation.md) — memory note ticket43-backend-b1-b4-qa-validation
 - [ticket43-plugin-system-final-qa-verdict](ticket43-plugin-system-final-qa-verdict.md) — memory note ticket43-plugin-system-final-qa-verdict
+- [ticket101-cross-talk-multi-project-rootcause](ticket101-cross-talk-multi-project-rootcause.md) — memory note ticket101-cross-talk-multi-project-rootcause
+- [ticket103-network-permission-ux-surface](ticket103-network-permission-ux-surface.md) — Stable UX convention for agent network permissions in IdeA.
+- [codex-network-access-config-fix](codex-network-access-config-fix.md) — memory note codex-network-access-config-fix

.ideai/memory/codex-network-access-config-fix.md

@@ -0,0 +1,41 @@
+---
+name: codex-network-access-config-fix
+description: memory note codex-network-access-config-fix
+metadata:
+  type: project
+---
+# Correctif accès réseau Codex via `sandbox_workspace_write.network_access`
+
+Le 2026-07-26, le diagnostic live a montré qu'un agent Codex lancé par IdeA échouait sur `curl` même avec IP forcée. La cause n'était pas seulement DNS ni une session à relancer : Codex CLI 0.145 attend la configuration officielle `sandbox_workspace_write.network_access=true` pour autoriser le réseau dans `workspace-write`.
+
+Correctif implémenté et validé par QA dans les sources :
+
+- Projection Codex `$CODEX_HOME/config.toml` : gérer `[sandbox_workspace_write] network_access = true/false` via `MergeToml`, pour éviter un stale `true`.
+- `codex exec` structuré : passer `-c sandbox_workspace_write.network_access=<bool>` quand la policy est connue.
+- La permission système IdeA reste séparée des permissions fichiers/bash : seul `NetworkPolicy::Allow` active `network_access=true`; `Deny`, `Ask` et `None` donnent `false`.
+- L'env `CODEX_SANDBOX_NETWORK_DISABLED` est encore upserté comme garde anti-héritage stale, mais ce n'est plus le mécanisme principal.
+
+Fichiers principaux :
+
+- `crates/infrastructure/src/permission/codex.rs`
+- `crates/domain/src/ports.rs`
+- `crates/application/src/agent/lifecycle.rs`
+- `crates/infrastructure/src/session/codex.rs`
+- `crates/application/src/ticket_assistant.rs`
+
+Validation QA verte :
+
+- `cargo test -p infrastructure permission::codex`
+- `cargo test -p infrastructure codex_`
+- `cargo test -p application --test agent_lifecycle codex_`
+- `cargo test -p application --test ticket_assistant codex_`
+- `cargo test -p domain`
+
+Build réalisé :
+
+- `npm --prefix frontend run build` : vert.
+- `tauri build --bundles appimage` : compilation release OK, mais bundling linuxdeploy a échoué car `appimagetool` tentait de télécharger le runtime sans réseau.
+- Contournement appliqué : `appimagetool --runtime-file /home/anthony/.cache/tauri/runtime-x86_64 ...`.
+- AppImage générée : `target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`, SHA-256 `08d74dfe950312f968f3fe5646d747f2ac6fa25f2a523a83825182f2809e2aa8`.
+
+Validation live restante obligatoire : relancer IdeA depuis cette nouvelle AppImage, lancer un agent Codex frais avec `network: allow`, puis exécuter un vrai `curl`. La session Codex déjà active ne peut pas prouver le fix car elle a été lancée avant ces nouveaux arguments/config.

.ideai/memory/context-agent-token-offload-design.md

@@ -0,0 +1,59 @@
+---
+name: context-agent-token-offload-design
+description: memory note context-agent-token-offload-design
+metadata:
+  type: project
+---
+# Agent Context — allègement token, périmètre figé
+
+Décision validée le 2026-07-23 : un nouvel agent **Context**, tournant sur un **LLM local peu
+puissant**, a été ajouté au projet IdeA pour réduire la fréquence des limites de tokens atteintes
+par les autres agents (Main, Architect, UX, DevBackend, DevFrontend, QA, Git) — **sans dégrader
+la qualité de leurs décisions**.
+
+## Périmètre retenu (mécanique, faible risque)
+
+- Recherche de symboles (localisation définition/usage).
+- Résumé de fichier(s) — factuel, pas d'interprétation architecturale.
+- Classification d'erreurs de compilation (tri d'un log brut).
+- Extraction des tests en échec (à partir d'une sortie de test brute).
+- Résumé de diff (`git diff` volumineux → liste factuelle de fichiers/nature de changement).
+- Repérage de fichiers probablement concernés par un ticket (piste, pas garantie).
+
+## Explicitement exclu / dégradé en brouillon uniquement
+
+Proposer un message de commit, générer un test unitaire, mettre à jour une documentation qui fait
+foi : ce sont des artefacts qui engagent une décision et qui appartiennent aux agents propriétaires
+(Git pour les commits, QA pour les tests). Un modèle local faible qui les produit comme livrable
+ferait courir un risque de qualité que la vérification par l'agent fort annulerait de toute façon
+le gain de tokens visé. Context peut produire un brouillon explicitement marqué comme tel, jamais
+un livrable.
+
+## Garde-fous de fiabilité (vu la faiblesse du modèle)
+
+Context ne décide rien, ne corrige pas de code de production, ne remplace jamais une vérification
+qui doit être prouvée (tests QA, verdict de build), et ne devine jamais quand l'information manque
+— il doit dire "non trouvé"/"incertain" plutôt qu'extrapoler. Réponses courtes, structurées,
+citant ce qui a été effectivement vu (chemins, lignes), sans jugement de valeur.
+
+## Où c'est câblé
+
+- Contexte agent : `.ideai/agents/context.md` (écrit via `idea_update_context`).
+- Template global IdeA créé : « Context — Agent d'assistance légère à faible coût »
+  (`defaultProfileId` = profil LLM local de l'agent Context), pour réutilisation cross-projet.
+  Le template ne contient que la partie générique (aucune référence à IdeA le produit) ;
+  la déclaration des 7 autres rôles nommés reste project-spécifique et vit dans
+  `.ideai/agents/context.md` du projet, pas dans le template.
+- Rôle ajouté à la liste des rôles du contexte projet global (CLAUDE.md §3) : Context ne fait
+  **pas** partie du cycle obligatoire (§4) — pas d'étape qui lui est dédiée, il est sollicité en
+  support ponctuel par n'importe quel agent.
+- Chaque agent (Main, Architect, DevBackend, DevFrontend, QA, Git, UX) a reçu un ajout court dans
+  sa section « Délégation & collaboration » expliquant quand solliciter Context et rappelant que
+  son résultat est une piste à vérifier, jamais une conclusion ou une décision.
+
+## Pourquoi
+
+Voir [[idea-product-directives-main-handoff]] pour les directives produit générales ; cette note
+couvre spécifiquement le compromis coût-tokens/qualité qui a motivé le périmètre volontairement
+restreint de Context (pas de délégation de jugement, seulement de compression/extraction
+factuelle).

.ideai/memory/ticket103-network-permission-ux-surface.md

@@ -1,19 +1,10 @@
 ---
 name: ticket103-network-permission-ux-surface
-description: memory note ticket103-network-permission-ux-surface
+description: Stable UX convention for agent network permissions in IdeA.
 metadata:
-  type: project
+  type: reference
 ---
----
-title: "Ticket #103 - UX surface for network permission"
-type: reference
-description: "Stable UX convention for exposing network permission in IdeA: Permissions panel as primary editor, Agents as compact summary, Terminal as contextual failure surface, and explicit runtime-locked state."
----
-
-# Ticket #103 — UX surface for network permission
-
-- Keep a single primary edit surface in `Permissions > Système`.
-- Mirror the effective network state in the Agents list as a compact badge.
-- Use the Terminal only for contextual, actionable failures.
-- Distinguish clearly between user policy, effective state, and runtime lock.
-- If the runtime cannot elevate permission in the active session, the control must be read-only and the UI must say so explicitly.
+- Editability must follow the resolved control state, not simply whether an agent exists.
+- Non-launched agents stay editable unless a runtime lock is explicitly present.
+- Read-only messaging should be explicit only for active locked runtimes, especially external/uninspectable runtimes.
+- Effective policy labels must not be used as a proxy for editability.

.ideai/memory/ticket95-adapter-aware-liveness-probe.md

@@ -0,0 +1,31 @@
+---
+name: ticket95-adapter-aware-liveness-probe
+description: memory note ticket95-adapter-aware-liveness-probe
+metadata:
+  type: project
+---
+# #95 — Sonde de vivacité du rendez-vous devenue adapter-consciente
+
+**Type :** correctif architecture / bug racine. Livré sur `feature/rendezvous-liveness-probe-per-adapter` (commit 376fc9f), AppImage 0.3.0 rebuildée.
+
+## Bug racine
+Le rendez-vous `idea_ask_agent` (`run_inactivity_watchdog`, `crates/application/src/orchestrator/rendezvous.rs`) coupe en **faux `NoReply`** toute cible **structurée** dont le tour dépasse la fenêtre d'inactivité (défaut 600 s, = `turn_timeout_ms` du profil cible). Cause : la seule sonde de vivacité (`transcript_activity_token`) lisait le transcript Claude (`~/.claude/projects/<encoded-cwd>/*.jsonl`) — invisible pour OpenCode/Codex, et fragilise même Claude en mode `-p` headless si le transcript ne grossit pas mi-tour. `has_probe=true` mais la sonde renvoie `None` ⇒ bras `(true,_,None)=>false` ⇒ aucun réarmement ⇒ NoReply à la première fenêtre.
+
+## Fix (architecture figée)
+1. **Port domaine** (`crates/domain/src/ports.rs`) : `AgentSession::activity_token() -> Option<u64>` (défaut `None`, zéro régression). Jeton monotone = « la session travaille ».
+2. **Machinerie** (`crates/infrastructure/src/session/process.rs`) : `run_turn_with_activity(...)` bump un `Arc<AtomicU64>` à **chaque ligne stdout lue** (drain async ET drain sandboxé thread). `run_turn` (4 args) délègue avec `None` ⇒ les ~11 call sites de test sont intacts.
+3. **Sessions** : `ClaudeSdkSession`, `CodexExecSession`, `OpenAiCompatibleSession` overrident `activity_token()` via `run_turn_with_activity` ; `OpenCodeSession` (drain inline) bump son propre compteur par ligne JSONL.
+4. **Sonde composite** (`resolve_ask_liveness_token`, `crates/backend/src/lib.rs`) : préfère `session.activity_token()` de la session vivante (`structured.session_for_agent`), repli inchangé sur le transcript Claude. Câblée par `.with_ask_liveness_probe`.
+
+## Contrats clés
+- `has_probe` reste `true` dès qu'une sonde est câblée ; la sonde composite renvoie désormais `Some(token)` qui avance ⇒ la fenêtre se réarme. Le repli transcript Claude couvre le cas « session vivante sans override ».
+- La fenêtre = `turn_timeout_ms` du **profil cible** (`turn_timeout_for`→`liveness_for_agent`), défaut `ASK_AGENT_TIMEOUT` 600 s. **Pas d'env global pour la fenêtre** (seul le plafond a `IDEA_ASK_RENDEZVOUS_CEILING_MS`, défaut 4 h).
+- Pour un test live rapide sans attendre 600 s : mettre un petit `turn_timeout_ms` (ex. 20 000) sur le profil de la cible, puis déléguer une tâche de ~60-90 s.
+
+## État validation
+- Tests unitaires verts : `run_turn_with_activity_bumps_counter_per_line`, `*_session_activity_token_advances_across_a_turn` (claude/codex/opencode), + la sonde composite backend + le watchdog rendezvous existants.
+- AppImage 0.3.0 rebuildée + installée (`/home/anthony/Documents/IdeA_0.3.0_amd64.AppImage`, backup `.old-pre95fix`). **Relance IdeA requise** pour l'activer (le binaire qui tourne = AppImage en mémoire ; relancer depuis l'intérieur tue la session courante).
+
+## À noter (dette / hors périmètre)
+- #96 (EffectivePermissions assistants de ticket) laissé ouvert, documenté dans le carnet #96 (décision produit différée).
+- Le souvenir utilisateur initial décrivait un échec « demandeur GLM/OpenCode → cible Claude ». Mécaniquement le watchdog est **ciblé-cible** (keyed sur l'agent cible) : un échec sur cible Claude longue n'est possible que si le transcript Claude `-p` ne grossit pas mi-tour (couvert désormais par l'`activity_token` de ClaudeSdkSession). La théorie principale reste « cible structurée longue non observée → faux NoReply ».

.ideai/memory/ticket97-opencode-provider-mutual-exclusion.md

@@ -0,0 +1,35 @@
+---
+name: ticket97-opencode-provider-mutual-exclusion
+description: memory note ticket97-opencode-provider-mutual-exclusion
+metadata:
+  type: project
+---
+# Ticket #97 — Exclusion mutuelle opencode / opencodeProvider (décision Architect)
+
+## Bug
+Wizard first-run : profiles.json contient à la fois `opencode` (llamacpp) et `opencodeProvider` (cloud). Lecture priorise `opencode` → llamacpp l'emporte silencieusement.
+
+## Root cause (vérifiée dans le code)
+1. `SaveOpenCodeProviderProfile::execute` (`crates/application/src/agent/usecases.rs:364-367`) pose `opencode_provider` sans faire `opencode = None`.
+2. Invariant `opencode_backend_is_consistent` (`crates/domain/src/profile.rs:1220`) existe + testé mais **jamais appelé** hors tests (garde morte).
+3. Lecture priorise `opencode` : `crates/application/src/agent/lifecycle.rs:2367` + `crates/infrastructure/src/assistant/mod.rs:252`.
+
+## Décisions Architect (validées)
+- **Lot** : un seul lot cohérent. Backend = autoritaire (invariant + garde + use case via builder + migration). Frontend = strip de la config inactive au save selon le mode (requis pour les chemins SaveProfile/ConfigureProfiles qui ne portent pas d'intention explicite). Découplés/parallélisables. DevBackend + DevFrontend + QA.
+- **Frontière** :
+  - Domaine : builders `with_opencode` (`profile.rs:1132`) et `with_opencode_provider` (`profile.rs:1140`) doivent imposer l'exclusion mutuelle (chacun efface l'autre). Aujourd'hui ce sont des setters muets = la faille.
+  - Infrastructure : `FsProfileStore::save` rejette tout profil violant l'invariant → `AppError::Invalid` (c'est ici que le prédicat enfin s'appelle). Défense en profondeur.
+  - Application : use cases utilisent les builders, jamais la mutation brute de champ.
+  - Refuser l'ad-hoc `opencode = None` par use case (DRY, 4 chemins d'écriture).
+- **DTO** : garder `SaveOpenCodeProviderProfileRequestDto` (`dto.rs:1148`) whole-profile (zéro cassure frontend). Le `opencode` parasite devient inoffensif car le use case reconstruit via builder. Output = profil normalisé, autorité pour le frontend. Corriger aussi SaveProfile (`usecases.rs:269`) et ConfigureProfiles (`usecases.rs:460`).
+- **Lecture priorité** : garder `opencode` d'abord (irrelevant post-exclusion), commenter comme fallback défensif.
+- **Duplication résolution** (lifecycle.rs:2367 + assistant/mod.rs:252) : dette hexagonale préexistante, NE PAS élargir ce lot. Suivre via un futur `AgentProfile::effective_opencode_backend()` ou générateur partagé.
+- **Migration REQUISE** : profils déjà corrompus sur disque portent les deux. Recovery : à la lecture (ou passe de migration), quand les deux présents, dropper `opencode` stale (l'intention est cloud, le bug ne venant que d'une action cloud explicite). Sans cela, #97 ne corrige que les nouveaux profils.
+
+## Sites de résolution (priorité) = exactement 2
+- `crates/application/src/agent/lifecycle.rs:2367`
+- `crates/infrastructure/src/assistant/mod.rs:252`
+Autres accès `.opencode` scoper en mode local, non affectés : `lifecycle.rs:2455-2468`, `model_server.rs:121-127`, `catalogue.rs:244-258`, `usecases.rs:410`.
+
+## Statut
+Décision Architect posée. À faire implémenter par DevBackend (domaine builders + garde store + migration + use cases) et DevFrontend (strip au save). QA : tests domaine/store + intégration cloud + scénario migration profils corrompus.

.ideai/memory/ticket98-opencode-modelsdev-cache-seed.md

@@ -0,0 +1,83 @@
+---
+name: ticket98-opencode-modelsdev-cache-seed
+description: memory note ticket98-opencode-modelsdev-cache-seed
+metadata:
+  type: project
+---
+---
+slug: ticket98-opencode-modelsdev-cache-seed
+title: "Ticket #98 — Fix spawn OpenCode : seed du cache models.dev isolé (approche B2)"
+type: reference
+description: Cadrage figé du fix #98 (modèle écrasé par glm-5.2 au spawn pour provider catalogue cloud ex: zai) : cause racine = asymétrie picker↔spawn, approche B2 = semer best-effort le cache models.dev hôte dans le XDG_CACHE_HOME isolé.
+---
+
+# Ticket #98 — Fix spawn OpenCode : seed du cache models.dev isolé
+
+## Symptôme
+Wizard profil OpenCode first-run : provider catalogue cloud (ex: zai/ZAI Code) + modèle choisi → après sauvegarde l'agent tourne en `glm-5.2` quel que soit le modèle. Persistance correcte (`profiles.json` conserve `opencodeProvider.model`). `glm-5.2` est le **fallback interne d'OpenCode**, absent du code IdeA.
+
+## Cause racine (confirmée + affinée par Architect)
+**Asymétrie picker↔spawn**, pas seulement « pas de bloc models » :
+
+1. **Picker** (`provider_catalogue.rs:79-84,150-153`) : lit le cache models.dev via `opencode_models_cache_path()` qui résout le **vrai** cache hôte (`XDG_CACHE_HOME ?? ~/.cache`). Permet d'afficher zai + ses modèles.
+2. **Spawn** (`lifecycle.rs:2386,2400-2407` ; `assistant/mod.rs:272,277-285`) : IdeA **ré-isole** `XDG_CACHE_HOME` → `.opencode/cache` **vide** sous `run_dir`. OpenCode ne voit plus le cache.
+3. **Rendu** (`opencode_provider_config_json`, `lifecycle.rs:2795-2821` / `assistant/mod.rs:446-466`) : pour `config.custom == None` (défaut pour zai), IdeA n'émet que `apiKey` + `model: "zai/<m>"`, **sans** bloc `models`. Correct **uniquement** pour les 3 built-ins hardcodés dans le binaire OpenCode (`anthropic`, `openai`, `openrouter`).
+
+→ OpenCode reçoit `model: "zai/<m>"`, ne reconnaît pas zai comme built-in, ne trouve pas le cache models.dev (isolé vide) → fallback silencieux glm-5.2.
+
+- **Local/custom marchent** : émettent un bloc `models` auto-suffisant (`assistant/mod.rs:364-381`, `:447-460`).
+- **3 built-ins marchent** : hardcodés dans OpenCode.
+- Bug ne touche **que** les providers connus d'OpenCode *exclusivement via models.dev*.
+
+## Approche figée : **B2 — Semer le cache models.dev isolé depuis le cache hôte**
+Après création du `XDG_CACHE_HOME` isolé, copier **best-effort** le fichier cache models.dev hôte (`opencode_models_cache_path()` → `<isolated_cache>/opencode/models.json`) via le port `FileSystem`. Lecture hôte = `std::fs` (identique au picker) ; écriture dans la home isolée.
+
+**Pourquoi pas les autres :**
+- **(A)** Émettre un bloc `models`+`npm`+`baseURL` pour les catalogue → **écartée en v1** : IdeA devrait capturer le bon `npm` AI-SDK par provider depuis models.dev (`@ai-sdk/anthropic` vs `openai-compatible`…) — dupliquerait la connaissance du registry OpenCode (violation OCP), risque de régression built-ins. Gardée en **escalade** si B2 défait par refresh.
+- **(B1)** Pointer vers le vrai cache hôte (ne plus isoler) → **écartée** : casse l'isolation en écriture (pollution + race entre sessions).
+- **(C)** Bundler une copie statique models.dev dans IdeA → **écartée** : staleness + diverge picker/spawn.
+
+**Auto-cohérence B2** : la précondition du bug (cache hôte présent au picker) garantit la précondition du fix (fichier à copier au spawn). Cache hôte absent → picker ne montre que les 3 built-ins → bug non atteint → fix non requis.
+
+## Contrat figé
+### Ports / DTO
+- **Aucun nouveau port / entité domaine / DTO modifié.** Réutilise le port `FileSystem` déjà injecté sur le chemin spawn. Lecture source = `std::fs` hôte (mécanisme identique au picker).
+- Rendre **publique** `opencode_models_cache_path()` (source de vérité unique — encode le workaround du bug upstream #8235 ; ne **pas** re-dériver).
+
+### Fichiers (périmètre DevBackend)
+- `crates/application/src/agent/provider_catalogue.rs` — exposer `opencode_models_cache_path()` en `pub` (ou ajouter `pub fn read_models_dev_cache_bytes() -> Option<Vec<u8>>`).
+- `crates/application/src/agent/mod.rs` — re-export.
+- `crates/application/src/agent/lifecycle.rs` — branche `apply_mcp_config` (≈2382-2408) : après `create_dir_all` du cache + création `xdg_cache`, semer `<xdg_cache>/opencode/models.json` depuis le cache hôte, best-effort. Branche **commune** opencode + opencodeProvider.
+- `crates/infrastructure/src/assistant/mod.rs` — branche miroir (≈268-285) : même appel.
+- **Factoriser** : `application::agent::seed_opencode_models_cache(fs: &dyn FileSystem, isolated_cache_dir: &str)` appelée par les deux sites. Partie **pure** testable `seed_from_bytes(fs, dest, src_bytes)` ; wrapper impur `std::fs::read` fin.
+
+### Invariants (stricts)
+1. Isolation préservée en **écriture** : HOME, XDG_CONFIG_HOME, XDG_DATA_HOME, XDG_CACHE_HOME restent sous `run_dir`. Aucune var d'env repointée vers l'hôte. Seul le **contenu** du cache isolé est semé (lecture seule).
+2. **Best-effort, n'échoue jamais le launch** : source absente/illisible ou erreur FS → pas d'échec du spawn. Symétrique du contrat best-effort existant de `apply_mcp_config` (`lifecycle.rs:2422-2425`). ≠ `resolve_opencode_provider_api_key` (échec dur). Le seed est **mou**.
+3. Pas de régression local/custom : `opencode_config_json` (llamacpp) et `opencode_provider_config_json(custom==Some)` **byte-identiques** (rendu non touché ; seed additif orthogonal).
+4. Pas de régression built-ins : anthropic/openai/openrouter (`custom==None`, hardcodés) restent fonctionnels.
+5. Exclusion mutuelle `opencode` vs `opencodeProvider` (#97) : non touchée.
+6. Source de vérité unique du chemin models.dev : `opencode_models_cache_path()` réutilisée.
+7. Cohérence picker↔spawn : modèles résolvables au spawn = sur-ensemble de ceux du picker (même fichier source).
+
+### Hors périmètre (ne pas faire ici)
+- Résolution providers pour **projets remote (SSH/WSL)** (picker lit déjà le cache hôte — incohérence pré-existante). Fix corrige le cas **local**, ne régresse pas le remote.
+- Déduplication du rendu lifecycle↔infra (`opencode_provider_config_json` ×2) — on factorise **uniquement le seeder**.
+- Aucune modif UI/wizard.
+
+## QA — 2 couches
+1. **Unitaire `application`** (automatisable, déterministe) :
+   - Partie pure `seed_from_bytes(fs, dest, src_bytes)` : bytes présents → assert `<dest>/opencode/models.json` écrit identique ; `None` → aucun fichier **et** pas d'erreur.
+   - Non-régression rendu : JSON de `opencode_config_json` et `opencode_provider_config_json(custom==Some/None)` byte-identiques (tests existants `lifecycle.rs:4428+` verts).
+   - ⇒ Ne prouve **pas** la résolution réelle par OpenCode.
+2. **Intégration / réelle-exécution (gated, propriété QA)** : spawn réel d'OpenCode avec profil `zai` (`custom==None`) contre un cache models.dev fixture contenant `zai` ; assert **pas de fallback glm-5.2** (modèle `zai/<choix>` effectivement utilisé). Gater `#[ignore]`/env (clé API + réseau). **C'est ce test qui prouve le bug corrigé.**
+
+## Risque résiduel + escalade
+- **Inconnu empirique** : est-ce qu'OpenCode au démarrage tente de **rafraîchir** models.dev (écrase notre copie, ou hang sans réseau) ? `OPENCODE_DISABLE_AUTOUPDATE=1` ne vise que l'auto-update du binaire, pas sûr qu'il couvre le refresh models. **QA doit vérifier** sur le test d'intégration. Si le refresh défait B2 → **escalader vers (A)** : capturer `npm`+`baseURL` réels par provider dans le parseur models.dev et peupler `custom`.
+
+## Topologie
+- Branche : `feature/ticket98-opencode-modelsdev-cache-seed` depuis `develop@69e5878` (#97 exclusion mutuelle prérequis y est fusionné : `0f0a76d` + merge `5533073`). `crates/` propre.
+- Carnet #98 version 2 = source de vérité du cadrage.
+
+## Lié
+- #97 (relatesTo) : exclusion mutuelle provider — prérequis livré.

.ideai/memory/toolchain-rust-partage-acces-agents.md

@@ -0,0 +1,53 @@
+---
+name: toolchain-rust-partage-acces-agents
+description: memory note toolchain-rust-partage-acces-agents
+metadata:
+  type: project
+---
+---
+slug: toolchain-rust-partage-acces-agents
+title: Accès au toolchain Rust/Tauri partagé pour tous les agents (isolement HOME OpenCode)
+type: project
+description: Le toolchain Rust stable est déjà installé sur la machine mais invisible aux agents car le profil OpenCode isole HOME. Diagnostic, atténuation par symlink, et chantier durable (injection env au spawn).
+---
+
+# Toolchain Rust/Tauri : pourquoi les agents ne compilaient pas, et comment les débloquer
+
+## Symptôme (récurrent)
+Tout agent (Main, DevBackend, QA,…) lancé sous un profil OpenCode ne peut PAS compiler le workspace Rust/Tauri :
+- `cargo`/`rustc` = shims rustup qui répondent « no default toolchain » / « no installed toolchains ».
+- Bloque toute validation backend (cargo check/build/test), fait timeout les délégations lourdes.
+
+## Cause racine
+- Le toolchain **stable 1.94.1 est DÉJÀ installé** dans `/home/anthony/.rustup` + `/home/anthony/.cargo` (toolchains + bin).
+- MAIS le profil **OpenCode isole `HOME`** vers `.ideai/run/<agent_uuid>/.opencode/`. Donc `~/.rustup` et `~/.cargo` = `.opencode/.rustup` / `.opencode/.cargo`, qui ne contiennent qu'un `settings.toml` + un cache registry partiel → **aucun toolchain**.
+- IdeA lui-même ne set **ni** `RUSTUP_HOME` **ni** `CARGO_HOME` (grep vide dans `crates/`). Le point d'extension existe pourtant : `crates/infrastructure/src/session/opencode.rs:237` (`cmd.env(key, value)`) set déjà des env au spawn.
+- `target/` est dans le project root (partagé, géré par le lock cargo) → partageable sans conflit.
+- `tauri` est dispo via `frontend/node_modules/.bin/tauri` (après `npm install` du frontend).
+
+## Atténuation appliquée (2026-07-25, ops, sans rebuild)
+Symlinker les homes isolés vers les homes partagés pour chaque run-dir agent :
+```bash
+for d in .ideai/run/*/.opencode; do
+  for sub in .rustup .cargo; do
+    p="$d/$sub"
+    [ -e "$p" ] && [ ! -L "$p" ] && { rm -rf "$p"; ln -s "/home/anthony/$sub" "$p"; }
+  done
+done
+```
+Vérifié sur Main : `cargo 1.94.1` / `rustc 1.94.1` accessibles **sans aucune variable d'env explicite**. Symlink appliqué aux agents actifs (Main a6ced819, DevBackend 73c853d1, QA aefdbd61, …) — 5 run-dirs concernés.
+
+**Tient pour les agents existants** : rustup suit les symlinks, et OpenCode ne recrée pas `$HOME/.rustup` s'il existe déjà.
+
+## Solution DURABLE (chantier IdeA, à livrer)
+Pour les **nouveaux** agents (IdeA crée un nouveau run-dir `.ideai/run/<uuid>/.opencode/.rustup` vide), il faut qu'IdeA provisionne l'accès au toolchain partagé automatiquement. Deux options équivalentes, à faire par DevBackend + **rebuild AppImage + relance** :
+1. Au spawn de l'agent, injecter `RUSTUP_HOME=/home/anthony/.rustup` et `CARGO_HOME=/home/anthony/.cargo` (point d'extension `opencode.rs:237`). Valeurs résolues depuis le vrai HOME user (pas le HOME isolé), idéalement configurables (env projet / settings).
+2. Ou, à la création du run-dir, créer les deux symlinks `.opencode/.rustup` et `.opencode/.cargo` → homes partagés.
+
+Recommandation : option 1 (injection env) — moteur-agnostique (marche aussi pour Codex/Claude si un jour ils isolent aussi) et ne dépend pas du filesystem layout du moteur.
+
+À grouper dans le **même rebuild AppImage** que le fix « sonde de vivacité multi-moteur » (cf. `idea-memory` à venir) — les deux sont des chantiers runtime qui nécessitent rebuild + relance.
+
+## Liens
+- Règle rebuild AppImage : `.ideai/skills/md/a72dac60-641c-4417-b0d7-94b8539f817a.md` (skill build AppImage), mémoire `mcp-bridge-and-delegation-runtime-notes`.
+- Timeout délégation 600 s (autre symptôme sur les tâches lourdes) : mémoire `rendezvous-600s-cap-too-short-heavy-tasks` + sonde Claude-seule `crates/infrastructure/src/inspector/claude_paths.rs:89`.