IdeA/handoff.md at 55d887fc78163d163cae73b11d5f291340b11dfe

Files

Blomios 5ef001e7a3 chore(wip): état runtime .ideai (conversations, layouts, mémoire, checkpoints)

Persiste l'état runtime : manifestes agents, layouts, permissions, logs et
handoffs de conversations, index mémoire et checkpoints du chantier
orchestrator-designation (restart, backend-compile-fix, qa-verdict) ainsi que
la note conversation-rotation-safety-design.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

2026-06-20 08:56:40 +02:00

84 KiB

Raw Blame History

upTo: edf1ef36-9b9f-41f8-9fde-dfddf09366f9 objective: IMPLÉMENTATION (code de production uniquement — PAS les nouveaux tests, c'est QA qui les écrit ; mais ne casse aucun test existant). Cadrage validé par l'Architect. Objectif : permettre la délégation

Objectif : IMPLÉMENTATION (code de production uniquement — PAS les nouveaux tests, c'est QA qui les écrit ; mais ne casse aucun test existant). Cadrage validé par l'Architect. Objectif : permettre la délégation

Response: Complément LS1 terminé. Code pur, zéro dépendance nouvelle. cargo build -p domain = OK, 0 warning (Finished, 0.77s). ## Fichier modifié - crates/domain/src/events.rs — 5 variantes ajoutées à DomainEvent, insérées juste avant PtyOutput. lib.rs inchangé : DomainEvent est déjà re-exporté (pub use events::{DomainEvent, OrchestrationSource};) et les variantes d'enum n'ont pas de re-export propre. Rien d'autre touché (infra/application intacts). ## Signatures des 5 variantes rust AgentRateLimited { agent_id: AgentId, resets_at_ms: Option<i64> } AgentResumeScheduled { agent_id: AgentId, fire_at_ms: i64 } AgentResumeCancelled { agent_id: AgentId } AgentResumed { agent_id: AgentId } AgentRateLimitSuspected { agent_id: AgentId, resets_at_ms: Option<i64> } Choix de champs alignés sur le cadrage §21.3/§21.9 et sur les conventions existantes de DomainEvent : - agent_id: AgentId (type d'id déjà utilisé partout dans l'enum) ; - resets_at_ms: Option<i64> (époche-ms, homogène avec Clock/SessionLimit/ReplyEvent::RateLimited ; T1) ; - fire_at_ms: i64 (échéance du réveil, même type/sémantique que ResumePlan::Scheduled.fire_at_ms). - Doccomments fr cohérents avec le vocabulaire §21 (limité/reset/reprise auto annulable/filet humain niveau 3). AgentRateLimitSuspected porte resets_at_ms: Option<i64> (le cadrage le donne « si dispo ») : None = l'utilisateur fournira l'heure. ## Vérifs - Pas de match exhaustif sur DomainEvent cassé dans le crate domain (seul input.rs le référence, en construction d'événements — build vert). - Rappel inchangé : cargo build --workspace échouera toujours tant que LS2 n'a pas câblé l'arm ReplyEvent::RateLimited côté infra (et l'éventuel relais IPC des nouveaux events en LS7) — attendu. QA peut compléter les tests LS1 : présence/forme des 5 variantes (constructibilité + égalité PartialEq), types de champs.
Prompt: LS2 — niveau 1 (structuré) côté INFRA, adapter Claude. Branche feature/agent-session-limits (LS1 mergé : domaine porte déjà ReplyEvent::RateLimited { resets_at_ms: Option }, non terminal). Respecte ARCHITECTURE.md §21 et les corrections T4. Objectif : exploiter le rate_limit_event que l'adapter Claude voit DÉJÀ mais jette aujourd'hui (infrastructure/session/claude.rs, fonction pure parse_event, ~ligne 90 : actuellement Some("rate_limit_event") => vec![ReplyEvent::Heartbeat]). Il faut en extraire l'heure de reset et émettre ReplyEvent::RateLimited { resets_at_ms } à la place. À faire : 1. infrastructure/session/claude.rs — parse_event : - Pour type == "rate_limit_event" : lire rate_limit_info et en extraire le timestamp de reset → resets_at_ms: Option<i64> (époche-ms). Émettre ReplyEvent::RateLimited { resets_at_ms } au lieu du Heartbeat. Si rate_limit_info est absent/illisible/sans champ de reset → resets_at_ms = None (on émet quand même RateLimited{None} : limite détectée, heure inconnue → filet humain en aval). Robustesse : jamais d'erreur sur un rate_limit_event malformé. - SPIKE à résoudre proprement : le format réel du champ de reset n'est pas garanti. Isole le parsing du timestamp dans une FONCTION PURE dédiée (ex. fn parse_reset_ms(rate_limit_info: &Value) -> Option<i64>) qui gère défensivement les formats plausibles et les convertit tous en époche-ms : (a) entier epoch en SECONDES, (b) entier epoch en MILLISECONDES, (c) chaîne ISO-8601/RFC3339. Heuristique secondes-vs-ms documentée (seuil de magnitude). Cherche les noms de champ plausibles (resetsAt, resets_at, reset_at, retryAfter/retry_after relatif en secondes → now+delta… mais comme parse_event est pur et n'a pas now, traite le relatif via une variante distincte si présent, sinon ignore et documente). Documente le format retenu et les hypothèses (comme le fait déjà l'en-tête de claude.rs pour le spike S1). 2. T4 — RateLimited NON TERMINAL : dans la boucle send de claude.rs, RateLimited ne doit PAS rompre le flux (seul Final rompt via break 'lines). Il s'intercale comme un Heartbeat. VÉRIFIE aussi le drain de process (infrastructure/session/process.rs, drain_bounded/run_turn) : un tour qui se clôt SANS Final PARCE QUE l'agent est limité ne doit pas devenir AgentSessionError::Io/timeout — c'est une fin gracieuse. Si le drain considère aujourd'hui « pas de Final » comme une erreur, adapte pour qu'un flux contenant un RateLimited terminal-de-fait soit traité gracieusement. Décris précisément ce que tu changes ici (c'est le point d'intégration sensible signalé par Architect). 3. Corrige les match exhaustifs sur ReplyEvent désormais cassés en infra : session/codex.rs et tout autre consommateur. Pour Codex, si tu n'as pas de signal de limite fiable sous la main, ajoute simplement l'arm ReplyEvent::RateLimited { .. } traité comme non terminal/équivalent Heartbeat (le signal Codex natif est un spike ultérieur) — ne fabrique rien de faux. Ne touche pas à l'application/front (lots suivants). NE traite pas le niveau 2 regex (LS5). Garde le parsing isolé et pur pour que QA le teste sans process. Lance cargo build -p infrastructure (et cargo build --workspace pour voir où en sont les match restants — note ce qui casse encore et relève d'un lot ultérieur). Rends : fichiers modifiés, la signature + les hypothèses de parse_reset_ms, ce que tu as changé pour T4 dans process.rs, et le résultat des builds.
Response: LS2 (niveau 1 structuré, adapter Claude) terminé. cargo build -p infrastructure = OK, 0 warning. cargo build -p domain = OK. cargo build --workspace = 2 erreurs résiduelles, uniquement dans app-tauri (attendu, relève de LS7/LS8 — détail plus bas). ## Fichiers modifiés - crates/infrastructure/src/session/claude.rs — seul fichier touché : - parse_event : rate_limit_event émet désormais ReplyEvent::RateLimited { resets_at_ms } (au lieu de jeter l'info en Heartbeat). resets_at_ms = value.get("rate_limit_info").and_then(parse_reset_ms) ⇒ absence/illisibilité ⇒ RateLimited{None} (jamais d'erreur). - Nouvelle fonction pure parse_reset_ms + helpers privés purs (value_to_epoch_ms, int_epoch_to_ms, float_epoch_to_ms, parse_rfc3339_to_ms, split_tz, split_seconds_frac, days_from_civil). - Doccomments (en-tête parse_event + commentaire boucle send) mis à jour pour le mapping et la non-terminalité T4. Aucune dépendance ajoutée (pas de chrono/time : parser ISO écrit à la main, pur — regex reste réservé à LS5 par T2). ## parse_reset_ms — signature & hypothèses rust pub fn parse_reset_ms(rate_limit_info: &Value) -> Option<i64> // -> époche-ms - Noms de champ essayés dans l'ordre, 1er présent gagne : resetsAt, resets_at, reset_at, resetAt, reset. - Conversion par type (value_to_epoch_ms) : entier/float epoch secondes (magnitude <10^12) ⇒ ×1000 ; epoch ms (≥10^12) ⇒ tel quel ; chaîne ⇒ tentée entier/float (même heuristique) puis ISO-8601/RFC3339. - Heuristique s-vs-ms : seuil EPOCH_MS_THRESHOLD = 10^12 (10^12 ms ≈ 2001-09 ; 10^12 s ≈ an 33658 ⇒ toute date ≥1970 tombe du bon côté). Documenté en clair. - ISO/RFC3339 (parse_rfc3339_to_ms) : YYYY-MM-DDThh:mm:ss[.fff][Z|±hh:mm], fraction tronquée/complétée à 3 chiffres (ms), conversion jour-civil via algo de Howard Hinnant (days_from_civil, exact, bissextiles/siècles). - Hypothèses assumées (documentées dans le doccomment) : 1. retryAfter/retry_after (relatif, secondes) NON exploité : le résoudre exige now, or parse_event/parse_reset_ms sont purs sans horloge ⇒ ignoré ⇒ RateLimited{None} (filet humain). Une résolution now+delta pourra être faite côté application (LS4, qui détient Clock). 2. Chaîne ISO sans fuseau ⇒ traitée UTC (best-effort ; l'heure murale locale relève du niveau 2/LS5, §21.10-2). 3. Jamais de panique ni d'erreur : tout cas inexploitable ⇒ None. - Spike §21.10-1 : le format réel du champ reste à confirmer sur un vrai rate_limit_event ; le parser couvre défensivement les 3 formats plausibles et le domaine ne voit que des époche-ms quoi qu'il arrive. ## T4 — non-terminalité (point d'intégration sensible) - claude.rs send : la boucle ne rompt (break 'lines) que sur Final (matches!(event, ReplyEvent::Final{..})). RateLimited (comme Heartbeat) ne rompt pas : il s'intercale, le flux continue jusqu'au Final ou la clôture. Comportement déjà correct par construction — j'ai seulement corrigé le commentaire (qui décrivait rate_limit_event comme un « heartbeat de fin »). - process.rs : AUCUN changement nécessaire, et c'est volontaire. run_turn/drain drainent toutes les lignes jusqu'à EOF puis wait() et renvoient Ok(lignes) ; ils n'ont aucune notion de Final et ne transforment jamais « pas de Final » en Io/Timeout (le Timeout n'arrive que sur un vrai dépassement de l'horloge murale). Un tour clos sans Final parce que limité y est donc déjà une fin gracieuse. C'est confirmé par le test existant stream_without_final_is_silently_ok_at_adapter_level (session/mod.rs:794). - Où vit réellement « flux clos sans Final ⇒ Io » : dans l'APPLICATION, pas l'infra — application/src/agent/structured.rs::drain_bounded_events (tests drain_with_readiness_lot1.rs:248, send_blocking_d1.rs:161). La réconciliation T4 (« clos + RateLimited vu ⇒ pas d'Io, issue limitée ») doit donc se faire là, ce qui correspond exactement au périmètre LS4 du cadrage (§21.5). Je n'y ai pas touché (hors périmètre LS2). À flaguer pour LS4. ## Codex (point 3 du ticket) - session/codex.rs n'a PAS de match exhaustif sur ReplyEvent : parse_event filtre sur le type (chaîne) avec un bras _ => {}, et la boucle send utilise matches!(…, Final). Rien à corriger, il compile tel quel. Je n'ai donc rien ajouté côté Codex (pas de signal de limite fiable sous la main ⇒ niveau 2/LS5 ou spike ultérieur §21.10-3 ; « ne fabrique rien de faux »). ## Builds restants à corriger en lot ultérieur (ce qui casse encore, hors LS2) cargo build --workspace ⇒ 2 erreurs, toutes dans app-tauri (présentation/composition root) : 1. crates/app-tauri/src/chat.rs:185 (to_reply_chunk) — match exhaustif sur ReplyEvent, RateLimited non couvert. ⇒ LS8 (mapping vers un ReplyChunk / DTO front). 2. crates/app-tauri/src/events.rs:261 — match exhaustif sur DomainEvent, les 5 nouvelles variantes (AgentRateLimited, AgentResumeScheduled, AgentResumeCancelled, AgentResumed, AgentRateLimitSuspected) non couvertes. ⇒ LS7 (relais IPC camelCase). Aucun autre crate ne casse (domain/application/infrastructure verts). ## Pour QA (binôme LS2) parse_reset_ms / parse_event sont purs, testables sans process : - rate_limit_event avec resetsAt epoch secondes ⇒ RateLimited{Some(ms ×1000)} ; - idem epoch ms ⇒ tel quel ; ISO-8601 …Z ⇒ ms attendus ; ISO avec offset ±hh:mm ⇒ ms UTC ; - rate_limit_event sans rate_limit_info / clé inconnue / valeur pourrie ⇒ RateLimited{None} (jamais d'erreur) ; - un tour rate_limit_event + result ⇒ flux […, RateLimited, Final] (RateLimited n'interrompt pas, Final clôt) ; - days_from_civil/bissextiles : 1970-01-01T00:00:00Z ⇒ 0, 2024-02-29T… valide.
Prompt: LS3 — le SEUL port neuf de la feature « limites de session » : Scheduler (réveil one-shot annulable) + son adapter d'infra. Branche feature/agent-session-limits (LS1+LS2 mergés). Respecte ARCHITECTURE.md §21 (notamment §21.4) et le motif de dispatch par DONNÉE pure déjà utilisé pour l'orchestrateur (§14.3) : pas de closure qui traverse la frontière domaine. 1. DOMAINE — crates/domain/src/ports.rs (+ re-exports lib.rs) : - Nouveau trait Scheduler (Send + Sync) : - arm(&self, deadline_ms: i64, task: ScheduledTask) -> ScheduleId — arme une minuterie one-shot qui, à l'échéance (époche-ms absolue, cohérent avec Clock::now_millis / ResumePlan::Scheduled.fire_at_ms), rend la tâche disponible pour exécution côté application. Si deadline ≤ now, l'échéance doit se déclencher au plus tôt (immédiat) — mais le clamp anti-passé est déjà fait par plan_resume côté domaine, donc documente juste le comportement. - cancel(&self, id: ScheduleId) -> bool — annule un réveil armé non encore tiré ; retourne true si effectivement annulé, false s'il n'existait pas / déjà tiré (idempotent, jamais d'erreur). C'est ce qui sous-tend « reprise auto ANNULABLE ». - ScheduleId : type d'id opaque (regarde comment les autres ids du domaine sont faits — ids.rs — et aligne-toi ; si un id généré est nécessaire, suis le motif existant). - ScheduledTask : DONNÉE pure (pas de closure). Variante ResumeAgent { agent_id: AgentId, node_id: NodeId, conversation_id: Option<String> } (cf. §21.4). Enum extensible. - Détermine la bonne forme async : regarde si les autres ports du domaine sont #[async_trait] ; aligne-toi. arm/cancel peuvent être synchrones si l'implémentation in-memory n'a pas besoin d'await — choisis selon ce qui est cohérent avec l'usage côté application (LS4) et documente. - Définis comment la tâche échue est REMISE à l'application : le port ne doit PAS exécuter la reprise lui-même (pas de dépendance vers l'application). Suis le motif orchestrateur §14.3 : par ex. l'adapter pousse la ScheduledTask échue dans un canal/une file que l'application draine, OU un mécanisme déjà en place. Inspecte infrastructure/orchestrator/ et application/orchestrator/ pour réutiliser EXACTEMENT le même patron de dispatch par donnée plutôt que d'en inventer un. Décris le mécanisme retenu. 2. INFRA — crates/infrastructure/src/scheduler/ (NOUVEAU module, déclaré dans lib.rs) : - TokioScheduler implémentant Scheduler : minuterie one-shot via tokio (tokio::time / spawn + abort pour l'annulation). In-memory uniquement (aucune persistance — conforme à la décision « état en mémoire »). cancel abort le handle correspondant. Thread-safe (Arc/Mutex sur la table id→handle). - Respecte la convention d'injection/composition existante ; ne touche PAS encore au composition root app-tauri (LS7) — fournis juste le type construisible et testable. NE traite pas LS4 (le service applicatif qui consomme ce port) ni la réconciliation T4. Reste dans le périmètre du port + adapter. Vérifie cargo build -p domain et cargo build -p infrastructure. Rends : fichiers créés/modifiés, signatures publiques (trait Scheduler, ScheduleId, ScheduledTask), le mécanisme de remise des tâches échues à l'application (et quel patron existant tu réutilises), et le résultat des builds. Garde l'adapter testable (QA testera arm tire bien après l'échéance, cancel empêche le tir, cancel d'un id inconnu = false).
Response: LS3 (port Scheduler + adapter TokioScheduler) terminé. cargo build -p domain = OK, 0 warning ; cargo build -p infrastructure = OK, 0 warning. ## Fichiers Créés - crates/infrastructure/src/scheduler/mod.rs — TokioScheduler. Modifiés - crates/domain/src/ids.rs — nouvel id typé ScheduleId (via la macro typed_id!, comme tous les ids du domaine ⇒ Copy/Hash/Eq, new_random()/from_uuid()). - crates/domain/src/ports.rs — enum ScheduledTask + trait Scheduler ; import ids étendu (NodeId, ScheduleId). - crates/domain/src/lib.rs — re-exports ScheduleId, Scheduler, ScheduledTask. - crates/infrastructure/src/lib.rs — pub mod scheduler; + pub use scheduler::TokioScheduler;. ## Signatures publiques Domaine (ports.rs) rust pub enum ScheduledTask { ResumeAgent { agent_id: AgentId, node_id: NodeId, conversation_id: Option<String> }, } // #[derive(Debug, Clone, PartialEq, Eq)], extensible (Open/Closed) pub trait Scheduler: Send + Sync { fn arm(&self, deadline_ms: i64, task: ScheduledTask) -> ScheduleId; fn cancel(&self, id: ScheduleId) -> bool; } - ScheduleId = newtype Uuid (ids.rs), opaque/annulable. - Synchrone, PAS d'async_trait : aligné sur la famille des ports non bloquants (Clock/IdGenerator/EventBus). arm ne fait qu'enregistrer une minuterie (l'attente vit en tâche de fond), cancel ne fait qu'annuler — aucun await au point d'appel, donc on évite le boxing. Cohérent avec l'usage applicatif LS4 (le service appelle arm/cancel sans await). - arm : deadline_ms en époche-ms absolues (cohérent Clock::now_millis / ResumePlan::Scheduled.fire_at_ms). deadline ≤ now ⇒ déclenchement immédiat (documenté ; le clamp anti-passé est déjà fait par plan_resume). - cancel : idempotent, sans erreur — true ssi un réveil non encore tiré a été désarmé ; false si inconnu ou déjà tiré. Infra (scheduler/mod.rs) rust pub struct TokioScheduler { /* tx, clock, handles */ } impl TokioScheduler { pub fn new(tx: tokio::sync::mpsc::UnboundedSender<ScheduledTask>, clock: Arc<dyn Clock>) -> Self; } impl Scheduler for TokioScheduler { /* arm/cancel */ } ## Mécanisme de remise des tâches échues — patron réutilisé Dispatch par DONNÉE pure, calqué EXACTEMENT sur le watcher d'orchestrateur (§14.3 / infrastructure/src/orchestrator/mod.rs) : là-bas l'adapter watcher valide une requête-donnée et la dispatche vers OrchestratorService via un canal ; l'adapter n'exécute pas le use case lui-même. Ici : TokioScheduler::new(tx, clock) reçoit le bout émetteur d'un mpsc (le récepteur appartient au drain applicatif, branché en LS4/LS7). arm calcule delay = max(0, deadline_ms - clock.now_millis()), tokio::spawn une tâche qui tokio::time::sleep(delay).await puis pousse la ScheduledTask (la valeur) dans tx — jamais d'exécution de reprise dans l'adapter, aucune dépendance vers application, aucune closure ne franchit la frontière (seule une donnée transite). Le port reste donc côté domaine pur. cancel = handle.abort() sur le JoinHandle rangé dans une table Arc<Mutex<HashMap<ScheduleId, JoinHandle>>>. Détails de robustesse : - canal non borné (UnboundedSender) : événements rares/basse fréquence ⇒ ne jamais perdre/retarder une reprise ni bloquer la tâche de fond ; erreur d'envoi (récepteur lâché = IdeA s'arrête) ignorée. - cancel correct sans course : remove(id) puis is_finished() ⇒ None (inconnu) ⇒ false ; tiré-mais-présent ⇒ false ; armé non tiré ⇒ abort() + true. - table bornée : arm élague les handles déjà terminés (retain(!is_finished())) sous le même verrou (fait stable, pas de course). - en mémoire uniquement (§21.1-3) : aucune persistance. ## Périmètre respecté Pas de LS4 (service applicatif consommateur), pas de réconciliation T4, pas touché au composition root app-tauri (LS7). TokioScheduler est construisible et testable seul. ## Builds - cargo build -p domain ✅ 0 warning - cargo build -p infrastructure ✅ 0 warning - (--workspace reste cassé sur app-tauri uniquement, inchangé depuis LS2 : chat.rs:185 → LS8, events.rs:261 → LS7. LS3 n'ajoute aucune rupture.) ## Pour QA (binôme LS3) TokioScheduler testable sous #[tokio::test] avec un mpsc::unbounded_channel() + une horloge : - arm tire après l'échéance : arm(now+50ms, task) ⇒ rx.recv() (sous timeout) rend la task ; vérifier qu'aucune tâche n'arrive avant. - cancel empêche le tir : arm(now+10_000ms, task) puis cancel(id) == true ⇒ rx reste vide (try_recv après court délai). - cancel d'un id inconnu = false : cancel(ScheduleId::new_random()) == false. - cancel après tir = false : armer un délai court, attendre la réception, puis cancel(id) == false. - deadline passée ⇒ tir immédiat : arm(now-1000, task) ⇒ task reçue quasi-immédiatement. Injecter un Clock fixe (ou SystemClock) ; le sleep reste temps-réel (délais courts).
Prompt: LS4 — couche APPLICATION de la feature « limites de session » : le SessionLimitService qui orchestre détecter→planifier→reprendre, + la réconciliation T4. Branche feature/agent-session-limits (LS1+LS2+LS3 committés). Respecte ARCHITECTURE.md §21.5 et les motifs applicatifs existants. AVANT de coder, INSPECTE pour réutiliser l'existant : application/agent/structured.rs (drain_bounded_events), application/agent/lifecycle.rs + usecases.rs (comment un agent est lancé/repris : LaunchAgent, AgentSessionFactory, SessionPlan::Resume, conversation_id), application/orchestrator/service.rs (comment un service applicatif draine un canal de tâches-données — même patron que celui que TokioScheduler alimente). Aligne-toi sur ces patrons, n'invente pas un nouveau style. Périmètre APPLICATION uniquement (pas de app-tauri/front = LS7/LS8) : 1. NOUVEAU crates/application/src/agent/session_limit.rs — SessionLimitService (+ déclaré dans agent/mod.rs). Trois responsabilités, via les ports déjà injectés (Clock, Scheduler, EventBus, AgentSessionFactory/le mécanisme de lancement existant, AgentContextStore au besoin) : a. DÉTECTION→PLANIFICATION : à partir d'un signal ReadinessSignal::RateLimited { resets_at_ms } (ou équivalent remonté par le drain structuré) pour un agent/cellule donné(e) : construire un domain::SessionLimit (detected_at_ms = Clock::now_millis, source = Structured), appeler domain::plan_resume(now, &limit, conversation_id). Selon le ResumePlan : - Scheduled { fire_at_ms, conversation_id } ⇒ Scheduler::arm(fire_at_ms, ScheduledTask::ResumeAgent { agent_id, node_id, conversation_id }) ; publier DomainEvent::AgentRateLimited { agent_id, resets_at_ms } PUIS DomainEvent::AgentResumeScheduled { agent_id, fire_at_ms }. Conserver le ScheduleId (table interne agent_id→ScheduleId en mémoire, pour pouvoir annuler) — état EN MÉMOIRE uniquement. - HumanFallback ⇒ publier DomainEvent::AgentRateLimited { agent_id, resets_at_ms: None } et DomainEvent::AgentRateLimitSuspected { agent_id, resets_at_ms: None } (le filet humain UI/confirmation = LS6/LS8 ; ici on émet juste l'événement). b. EXÉCUTION DE LA REPRISE : une méthode (testable) qui consomme une ScheduledTask::ResumeAgent échue (celle que TokioScheduler pousse dans le mpsc ; le CÂBLAGE du récepteur dans le runtime Tauri = LS7, mais fournis ici la méthode que LS7 appellera) : relancer/réattacher l'agent via le mécanisme de lancement existant avec SessionPlan::Resume (conversation_id) et envoyer un prompt de reprise court (ex. « La limite de session est levée. Reprends là où tu t'étais arrêté. »). Puis publier DomainEvent::AgentResumed { agent_id }. Retirer l'entrée de la table. c. ANNULATION : cancel_resume(agent_id) ⇒ retrouver le ScheduleId, Scheduler::cancel(id), et si annulé publier DomainEvent::AgentResumeCancelled { agent_id }. C'est le socle de « reprise auto ANNULABLE ». NOTE de vigilance remontée par QA en LS3 : sous runtime multi-thread, Scheduler::cancel peut renvoyer true/false à la marge si on annule pile au moment du tir ; gère proprement le cas « cancel a renvoyé false parce que déjà tiré » (ne pas publier AgentResumeCancelled si le cancel a échoué ; la reprise suivra son cours). Documente ce choix. 2. RÉCONCILIATION T4 — crates/application/src/agent/structured.rs (drain_bounded_events) : aujourd'hui un flux clos SANS Final devient une erreur (AgentSessionError::Io / équivalent). Adapte pour qu'un tour qui se termine sans Final MAIS dont le flux a contenu un ReplyEvent::RateLimited soit traité comme une FIN GRACIEUSE « limitée » (pas une erreur) : remonter une issue distincte exploitable par le service (a) — par ex. la dernière info de limite (resets_at_ms) plutôt que de propager une Io. Inspecte la signature/retour actuel de drain_bounded_events et choisis la forme la plus propre (variante de retour / type d'issue) cohérente avec l'existant. NE casse aucun comportement existant (un vrai flux sans Final ET sans RateLimited reste une erreur comme avant). C'est le point d'intégration sensible signalé par Architect — décris précisément ce que tu changes. Respecte SOLID/hexagonal : le service ne dépend que de ports (traits), aucune dépendance concrète d'infra. Garde tout testable par QA (fakes de Scheduler/Clock/EventBus/factory). Vérifie cargo build -p application (et note l'état --workspace : app-tauri restera cassé jusqu'à LS7/LS8). Rends : fichiers créés/modifiés, signatures publiques de SessionLimitService (constructeur + méthodes a/b/c), la forme exacte de la réconciliation T4 dans drain_bounded_events (ancien retour vs nouveau), et les builds.
Response: LS4 (couche APPLICATION) terminé. cargo build -p application = OK, 0 warning ; tests compilent ; le test existant drain_marks_alive… reste vert (zéro régression). --workspace casse toujours uniquement sur app-tauri (LS7/LS8), inchangé. ## Fichiers Créé - crates/application/src/agent/session_limit.rs — SessionLimitService + port AgentResumer + const RESUME_PROMPT. Modifiés - crates/application/src/agent/structured.rs — réconciliation T4 (enum TurnOutcome + drain enrichi). - crates/application/src/agent/mod.rs — mod session_limit; + re-exports. - crates/application/src/lib.rs — re-exports crate-root. ## Signatures publiques SessionLimitService rust pub const RESUME_PROMPT: &str = "La limite de session est levée. Reprends là où tu t'étais arrêté."; #[async_trait] pub trait AgentResumer: Send + Sync { async fn resume(&self, agent_id: AgentId, node_id: NodeId, conversation_id: Option<String>, resume_prompt: &str) -> Result<(), AppError>; } impl SessionLimitService { pub fn new(clock: Arc<dyn Clock>, scheduler: Arc<dyn Scheduler>, events: Arc<dyn EventBus>, resumer: Arc<dyn AgentResumer>) -> Self; // (a) détection → planification (sync : arm/cancel/publish ne sont pas async) pub fn on_rate_limited(&self, agent_id: AgentId, node_id: NodeId, conversation_id: Option<String>, resets_at_ms: Option<i64>); // (b) exécution de la reprise (consomme la ScheduledTask échue poussée par TokioScheduler) pub async fn execute_resume(&self, task: ScheduledTask) -> Result<(), AppError>; // (c) annulation (socle du « annulable ») pub fn cancel_resume(&self, agent_id: AgentId) -> bool; } ### Décision de conception clé — port AgentResumer LaunchAgent exige Project + profil + contexte préparé + PTY (résolus seulement par lui) : le service ne peut pas relancer seul sans dupliquer cette résolution. J'ai donc introduit le port applicatif AgentResumer, exactement dans le style des passerelles existantes HandoffProvider/ProviderSessionProvider/McpRuntime (traits définis dans l'application, implémentés au composition root app-tauri). LS7 l'implémentera par-dessus LaunchAgent + AgentSessionFactory avec SessionPlan::Resume. Service 100 % testable avec un fake AgentResumer. Aucun nouveau style inventé. ### Comportements - (a) : SessionLimit::new(resets_at_ms, now=Clock::now_millis, Structured) → plan_resume. Scheduled{fire_at_ms, conversation_id} ⇒ publie AgentRateLimited, dédoublonne (annule un armement antérieur du même agent sans événement, §21.10-4), Scheduler::arm(fire_at_ms, ScheduledTask::ResumeAgent{agent_id,node_id,conversation_id}), mémorise le ScheduleId (table agent_id→ScheduleId en mémoire), publie AgentResumeScheduled{fire_at_ms}. HumanFallback ⇒ publie AgentRateLimited{None} puis AgentRateLimitSuspected{None} (filet humain ; confirmation UI = LS6/LS8). - (b) : retire l'entrée armée (le réveil a tiré), resumer.resume(..., RESUME_PROMPT), publie AgentResumed{agent_id}. Erreur de relance propagée ⇒ AgentResumed non publié. - (c) : retrouve le ScheduleId ; Scheduler::cancel ⇒ si true : retire l'entrée + publie AgentResumeCancelled + renvoie true ; si false (course « cancel pile au tir » signalée par QA en LS3) : ne publie pas, laisse l'entrée (l'execute_resume en cours la retirera), renvoie false — la reprise suit son cours. Documenté. ## Réconciliation T4 — forme exacte dans structured.rs Nouveau type public : rust pub enum TurnOutcome { Completed(String), RateLimited { resets_at_ms: Option<i64> } } Avant → après du chemin de drain unique : - drain_to_final : retour Result<String, AgentSessionError> → Result<TurnOutcome, AgentSessionError>. Il mémorise le dernier ReplyEvent::RateLimited{resets_at_ms} traversé. Sur Final ⇒ Ok(Completed(content)) (un Final l'emporte toujours, même après un RateLimited — cas LS2 […,RateLimited,Final]). Sur flux clos sans Final : si un RateLimited a été vu ⇒ Ok(RateLimited{resets_at_ms}) (fin gracieuse, §21.2-T4) ; sinon ⇒ Err(Io(...sans Final)) inchangé. - drain_bounded_events : retour aligné sur Result<TurnOutcome,...> ; Timeout inchangé. - Signatures publiques historiques préservées (zéro régression) : - send_blocking(...) -> Result<String, _> : Completed→Ok ; RateLimited→Err(Io) (le rendez-vous synchrone ask n'a pas de contenu — comportement identique à avant). - drain_with_readiness(...) -> Result<String, _> : idem (thin wrapper) ⇒ l'appelant orchestrateur service.rs:1067 est inchangé. - Nouveau point d'entrée riche : pub async fn drain_with_readiness_outcome(...) -> Result<TurnOutcome, _> — même branchement readiness, mais renvoie l'issue complète. C'est ce que LS7 câblera sur le tour délégué pour appeler SessionLimitService::on_rate_limited. mark_idle reste piloté uniquement par Final (un RateLimited ne fait pas avancer la FIFO, §21.5). Invariant respecté : un vrai flux sans Final ET sans RateLimited reste une Io (test existant drain_marks_alive… toujours vert ; les tests drain_with_readiness_lot1.rs:248 / send_blocking_d1.rs:161 « sans Final ⇒ Io » restent valides car ces flux n'ont pas de RateLimited). ## Builds - cargo build -p application ✅ 0 warning - cargo test -p application --no-run ✅ (tests compilent) ; --lib structured ✅ 1 passed - cargo build --workspace ❌ app-tauri uniquement : chat.rs:185 (ReplyEvent::RateLimited non couvert → LS8) + events.rs:261 (5 variantes DomainEvent → LS7). Inchangé depuis LS2 ; LS4 n'ajoute aucune rupture. ## Pour QA (binôme LS4) - (a) fakes Clock(fixe)/Scheduler/EventBus : on_rate_limited(Some(reset_futur)) ⇒ 1 arm(fire_at_ms) + events AgentRateLimited puis AgentResumeScheduled dans l'ordre ; on_rate_limited(None) ⇒ AgentRateLimited{None} + AgentRateLimitSuspected{None}, aucun arm. Dédoublonnage : 2 appels successifs ⇒ l'ancien ScheduleId est cancel-é. - (b) fake AgentResumer : execute_resume(ResumeAgent{…}) ⇒ resume(..., RESUME_PROMPT) appelé + AgentResumed publié + entrée retirée ; resume qui échoue ⇒ Err propagée, pas d'AgentResumed. - (c) cancel_resume après on_rate_limited ⇒ cancel appelé, true, AgentResumeCancelled publié ; cancel_resume sans armement ⇒ false sans event ; fake Scheduler renvoyant false (déjà tiré) ⇒ cancel_resume renvoie false sans event. - T4 : drain_with_readiness_outcome sur un flux [RateLimited{Some(t)}] (sans Final) ⇒ Ok(TurnOutcome::RateLimited{Some(t)}) ; [RateLimited, Final] ⇒ Ok(Completed) ; [TextDelta] seul (ni Final ni RateLimited) ⇒ Err(Io).
Prompt: LS5 — niveau 2 (repli déclaratif) côté INFRA : le parser regex qui détecte une limite de session dans la sortie texte d'un agent PTY/TUI sans adapter structuré. Branche feature/agent-session-limits (LS1→LS4 committés). Respecte ARCHITECTURE.md §21 (T2 notamment). Rappel T2 : le DOMAINE ne porte que la DONNÉE du motif (domain::profile::RateLimitPattern { pattern, reset_capture, time_format }, déjà livré en LS1) ; le MOTEUR regex + le parsing d'heure vivent en INFRA. C'est ici qu'on ajoute la dépendance regex — UNIQUEMENT au Cargo.toml du crate infrastructure, jamais au domaine. À faire : 1. crates/infrastructure/Cargo.toml — ajouter la dépendance regex (version cohérente avec l'écosystème du workspace ; regarde Cargo.lock / les versions déjà présentes pour t'aligner). 2. NOUVEAU module crates/infrastructure/src/ratelimit/ (déclaré dans lib.rs) — un RateLimitParser (nom à confirmer selon les conventions) qui, à partir d'un &RateLimitPattern et d'un fragment de sortie texte (+ l'heure courante now_ms injectée, car contrairement à LS2 on PEUT avoir besoin de résoudre une heure murale/relative), produit un Option<SessionLimit> (ou Option<i64> resets_at_ms que l'appelant emballe — choisis la forme la plus propre et cohérente avec la façon dont LS4 consomme la détection). Comportement : - Compiler le pattern regex. Compilation invalide ⇒ pas de détection (None), JAMAIS de panique ni d'erreur fatale (un profil mal configuré par l'utilisateur ne doit pas planter IdeA — robustesse « solide même pour un novice »). Idéalement, compiler paresseusement/une seule fois si tu peux mettre en cache, mais sans sur-ingénierie. - Si le pattern matche le texte ⇒ limite DÉTECTÉE. Si reset_capture est renseigné, extraire le groupe de capture (nommé de préférence, ex. (?P...)) et le parser en époche-ms selon time_format : * Réutilise le savoir de parsing d'heure que tu as déjà écrit en LS2 (parse_reset_ms / parseur ISO maison) si pertinent et factorisable proprement — sinon garde-le isolé ici. NE duplique pas bêtement : si une fonction de LS2 est réutilisable, expose-la/partage-la proprement (module commun infra) plutôt que copier-coller. * time_format guide l'interprétation : heure ABSOLUE (epoch/ISO) → directement en ms ; heure MURALE LOCALE (ex. « resets at 3pm ») → convertir avec now_ms comme référence (aujourd'hui à 15h, et si c'est déjà passé dans la journée → demain ; documente la règle de passage de minuit — spike §21.10-2) ; DÉLAI RELATIF (ex. « retry after 600s ») → now_ms + delta. - Si le pattern matche mais qu'aucune heure exploitable n'en sort ⇒ limite détectée AVEC resets_at_ms = None (⇒ filet humain en aval). C'est volontaire : détecter sans heure reste utile. 3. Garde le parsing PUR et isolé (le moteur regex est un détail, la logique d'extraction/conversion d'heure est testable sans I/O). L'intégration de ce parser dans le flux PTY (brancher la sortie terminal d'un agent non-structuré vers ce parser, puis vers SessionLimitService::on_rate_limited) relève du câblage — précise si tu la fais ici proprement via un port déjà existant, ou si tu la laisses à LS7 ; ne bricole pas un branchement PTY ad hoc. Attention dédoublonnage (§21.10-4) : si un agent a À LA FOIS un adapter structuré (niveau 1) ET un rate_limit_pattern (niveau 2), il ne faut pas détecter deux fois la même limite. Documente comment on évite ça (probablement : niveau 2 ne s'applique QU'aux agents sans adapter structuré — précise la règle de sélection). Vérifie cargo build -p infrastructure. Rends : fichiers créés/modifiés, la dépendance regex ajoutée (version), la signature publique du parser, comment tu réutilises (ou non) le parsing d'heure de LS2, la règle anti-double-détection niveau1/niveau2, et ce que tu laisses à LS7 pour le câblage PTY. Garde tout testable par QA (pattern qui matche avec/sans capture, heure absolue/murale/relative, regex invalide → None sans panique, passage de minuit).
Response: LS5 (niveau 2 déclaratif, infra) terminé. cargo build -p infrastructure = OK, 0 warning. Les 5 tests LS2 restent verts après refactor (DRY du parsing d'heure). ## Fichiers Créés - crates/infrastructure/src/ratelimit/mod.rs — RateLimitParser + règle applies. - crates/infrastructure/src/timeparse.rs — parsing d'heure pur partagé (factorisé depuis LS2). Modifiés - crates/infrastructure/Cargo.toml — dépendance regex. - crates/infrastructure/src/session/claude.rs — délègue le parsing d'heure à crate::timeparse (plus de duplication). - crates/infrastructure/src/lib.rs — pub mod ratelimit; pub mod timeparse; + pub use ratelimit::RateLimitParser;. ## Dépendance ajoutée regex = "1" au seul Cargo.toml d'infrastructure (jamais au domaine, T2). Résout en 1.12.3, déjà présente transitivement dans Cargo.lock (zéro nouvelle version dans l'arbre ; tire aho-corasick/regex-automata/regex-syntax déjà verrouillés). ## Signature publique du parser rust // Détecteur (motif compilé UNE fois à la construction). pub struct RateLimitParser { /* regex, reset_capture, time_format */ } impl RateLimitParser { pub fn new(pattern: &RateLimitPattern) -> Option<Self>; // None si regex invalide pub fn detect(&self, text: &str, now_ms: i64) -> Option<SessionLimit>; } // Règle de sélection anti-double-détection (§21.10-4). pub fn applies(profile: &AgentProfile) -> bool; Forme de retour : Option<SessionLimit> (et non Option<i64>), car il faut 3 états : None = pas de limite ; Some(SessionLimit{resets_at_ms: Some}) = limite + heure ; Some(SessionLimit{resets_at_ms: None}) = limite détectée sans heure (filet humain) — un Option<i64> ne distingue pas les 2 derniers. Le SessionLimit est rempli avec source = RateLimitSource::Pattern, detected_at_ms = now_ms. Robustesse : new renvoie None sur regex invalide (profil pourri ⇒ pas de détecteur, jamais de panique). Compilation une seule fois (cache dans la struct), pas par fragment. Stratégies d'heure (déduites une fois du time_format, enum interne ResetTimeFormat) : Auto (None/inconnu → best-effort absolu epoch/ISO) ; epoch_s|epoch_seconds|unix_s ; epoch_ms|epoch_millis|unix_ms ; iso8601|rfc3339|iso ; relative_s|relative_seconds|duration_s|retry_after_s (→ now+delta) ; relative_ms|relative_millis ; wall|wall_clock|local|hh:mm (heure murale « 3pm »/« 15:00 »). Capture par groupe nommé en priorité ((?P<reset>…)), repli sur index décimal. Match sans capture exploitable ⇒ resets_at_ms: None (détection utile sans heure). ## Réutilisation du parsing d'heure de LS2 (pas de copier-coller) J'ai factorisé les helpers génériques de LS2 (qui vivaient en privé dans claude.rs) dans un nouveau module partagé crate::timeparse : int_epoch_to_ms/float_epoch_to_ms, parse_rfc3339_to_ms (+ split_tz/split_seconds_frac), days_from_civil (algo Howard Hinnant), parse_absolute_ms, EPOCH_MS_THRESHOLD. claude.rs::value_to_epoch_ms délègue maintenant à timeparse (seule l'extraction depuis serde_json::Value reste côté Claude). Le niveau 2 réutilise les mêmes fonctions. Ajouts propres à LS5 dans timeparse : wall_clock_to_ms (heure murale + passage de minuit) et parse_wall_clock (« 3pm »/« 15:00:30 » → h,m,s). Tout reste pur (now_ms injecté), testable sans I/O. Passage de minuit (spike §21.10-2) : wall_clock_to_ms calcule « aujourd'hui à hⓂ️s » sur la journée UTC contenant now_ms ; si c'est ≤ now ⇒ +24 h (demain). Limite assumée et documentée : faute de base de fuseaux (dépendance-zéro), la journée de référence est UTC ; le rollover borne l'erreur à « jamais dans le passé ». Un offset de fuseau explicite (champ futur) lèverait la limite. ## Règle anti-double-détection niveau 1 / niveau 2 (§21.10-4) Source unique : ratelimit::applies(profile) == profile.structured_adapter.is_none() && profile.rate_limit_pattern.is_some(). Le niveau 2 ne s'applique qu'aux agents sans adapter structuré (les structurés détectent par le niveau 1 = flux machine, LS2). Le câblage (LS7) doit consulter applies avant d'instancier un RateLimitParser ⇒ jamais deux détections du même épisode. Documenté dans le module. ## Laissé à LS7 (câblage PTY — pas bricolé ici) Je n'ai pas branché la sortie PTY → parser → service (intégration runtime, intriquée avec le watcher de prompt / MediatedInbox qui observe déjà la sortie PTY, et l'accès au SessionLimitService). LS7 devra : 1. à l'activation d'un agent où ratelimit::applies(profile) ⇒ construire RateLimitParser::new(profile.rate_limit_pattern) ; 2. armer ce parser sur le même flux de sortie PTY que le watcher de prompt (réutiliser l'armement existant, §21.6) ; 3. sur detect(fragment, clock.now_millis()) == Some(limit) ⇒ appeler SessionLimitService pour planifier la reprise. ⚠️ Point d'attention pour LS7/LS4 : SessionLimitService::on_rate_limited(...) (LS4) reconstruit en interne un SessionLimit avec source = Structured. Le parser niveau 2 produit déjà un SessionLimit{source: Pattern}. Pour préserver la traçabilité de source (UI), LS7 aura besoin soit d'un point d'entrée du service acceptant un SessionLimit/une source pré-construit(e), soit d'un petit amendement de on_rate_limited (param source). Je n'ai pas modifié LS4 (discipline de lot) ; à arbitrer par toi. La donnée existe (le parser la porte), il ne reste qu'à la router. ## Builds - cargo build -p infrastructure ✅ 0 warning ; tests LS2 (5) ✅ verts. - cargo build --workspace ❌ app-tauri uniquement (inchangé : chat.rs:185 → LS8, events.rs:261 → LS7). LS5 n'ajoute aucune rupture. - Note non bloquante : 2 warnings irrefutable if let dans le code de TEST de scheduler/mod.rs (253/285, écrit par QA en LS3 ; ScheduledTask est mono-variante aujourd'hui) — hors code LS5, à corriger côté QA (ou disparaîtra dès qu'une 2ᵉ variante de ScheduledTask existera). ## Pour QA (binôme LS5) RateLimitParser 100 % testable sans I/O (now_ms injecté) : - pattern qui matche sans reset_capture ⇒ Some(SessionLimit{resets_at_ms: None, source: Pattern}) ; - avec capture nommée + time_format absolu (epoch_s/epoch_ms/iso8601) ⇒ ms attendus ; - relatif (relative_s, ex. capture « 600 », now=T) ⇒ T + 600_000 ; - murale (wall, « 3pm ») : si now=10h ⇒ 15h aujourd'hui ; si now=16h ⇒ 15h demain (passage de minuit) ; - regex invalide (new) ⇒ None (pas de panique) ; - pas de match ⇒ detect ⇒ None ; - capture présente mais valeur pourrie / groupe absent ⇒ Some(SessionLimit{resets_at_ms: None}) ; - applies : profil structuré ⇒ false ; profil PTY + pattern ⇒ true ; profil PTY sans pattern ⇒ false. - timeparse testable directement (réexporté) : wall_clock_to_ms, parse_wall_clock, parse_absolute_ms, days_from_civil.
Prompt: LS6 — Câblage des événements de limite de session vers le front (app-tauri). Project root: /home/anthony/Documents/Projects/IdeA. Contexte : LS1 a ajouté au domaine 5 nouvelles variantes DomainEvent (AgentRateLimited{agent_id, resets_at_ms: Option}, AgentResumeScheduled{agent_id, fire_at_ms: i64}, AgentResumeCancelled{agent_id}, AgentResumed{agent_id}, AgentRateLimitSuspected{agent_id, resets_at_ms: Option}) et la variante ReplyEvent::RateLimited{resets_at_ms: Option<i64>}. Le workspace ne compile plus : app-tauri a deux match non exhaustifs. Travail attendu (faire compiler le workspace, propre et cohérent avec le style existant) : 1. crates/app-tauri/src/events.rs : - Ajouter 5 variantes correspondantes à l'enum wire DomainEventDto (vers la ligne 28), chacune #[serde(rename_all = "camelCase")], avec les agent_id sérialisés en String (via .to_string()) comme les autres variantes, et les champs temps (resets_at_ms/fire_at_ms) en Option<i64>/i64. Documenter chaque variante (doc-comment) dans le même esprit que les voisines. - Ajouter les 5 bras correspondants dans impl From<&DomainEvent> for DomainEventDto (vers la ligne 259), sur le modèle de AgentBusyChanged/AgentLivenessChanged. 2. crates/app-tauri/src/chat.rs : dans chunk_from_event (~ligne 184), traiter ReplyEvent::RateLimited { .. }. Sémantique domaine (ports.rs §21.2-T4) : un RateLimited est NON terminal et SANS contenu chat, exactement comme Heartbeat — il doit donc mapper vers None (le badge UI vient du bus DomainEvent::AgentRateLimited, pas du flux chat). Aligne le commentaire sur celui de Heartbeat. Contraintes : respecte SOLID/hexagonal (le DTO wire reste un miroir pur du domaine, aucune logique). Ne touche QUE app-tauri. À la fin, lance cargo build --workspace et cargo test -p app-tauri et rapporte la sortie réelle (succès/échec). Si des tests unitaires de relais existent (ex. autour de la ligne 427 d'events.rs pour AgentLivenessChanged), ajoute au moins un test de relais pour AgentRateLimited sur le même modèle. Rends ton résultat via idea_reply avec un résumé des fichiers modifiés et la sortie de compilation/tests.
Response: LS6 terminé — workspace recompile, app-tauri vert. Fichiers modifiés (app-tauri uniquement) 1. crates/app-tauri/src/events.rs - Enum DomainEventDto : ajout de 5 variantes miroir (insérées avant PtyOutput, respectant l'ordre du domaine), chacune #[serde(rename_all = "camelCase")], agent_id: String : - AgentRateLimited { agent_id, resets_at_ms: Option<i64> } - AgentResumeScheduled { agent_id, fire_at_ms: i64 } - AgentResumeCancelled { agent_id } - AgentResumed { agent_id } - AgentRateLimitSuspected { agent_id, resets_at_ms: Option<i64> } Les champs Option<i64> portent #[serde(skip_serializing_if = "Option::is_none")] (cohérent avec les voisins DelegationReady). Doc-comments dans le même esprit que les variantes existantes (réf. §21). - impl From<&DomainEvent> for DomainEventDto : 5 bras correspondants (modèle AgentBusyChanged/AgentLivenessChanged), agent_id.to_string(), champs temps copiés (*resets_at_ms / *fire_at_ms). DTO = miroir pur, zéro logique. - Test de relais ajouté rate_limited_relays_to_dto_and_wire (sur le modèle de liveness_changed_*) : vérifie type == "agentRateLimited", agentId et resetsAtMs. 2. crates/app-tauri/src/chat.rs - chunk_from_event : ajout du bras ReplyEvent::RateLimited { .. } => None (non terminal, sans contenu chat — comme Heartbeat, ports §21.2-T4). Commentaire de la fonction étendu pour expliquer que le badge UI vient du bus DomainEvent::AgentRateLimited, pas du flux chat. Sortie compilation/tests (réelle) - cargo build --workspace : Finished dev profile ... in 16.89s ✅ - cargo test -p app-tauri : tous verts, dont : - events::tests::rate_limited_relays_to_dto_and_wire ... ok - events::tests::liveness_changed_{stalled,alive}_relays_to_dto_and_wire ... ok - chunk_from_event_* (heartbeat/final/text_delta/tool_activity) ... ok - Module events : test result: ok. 43 passed; 0 failed - Aucun échec sur l'ensemble des binaires/tests d'intégration d'app-tauri. Contraintes respectées : SOLID/hexagonal (wire DTO = miroir pur du domaine), périmètre limité à app-tauri.
Prompt: LS7 — câblage de la feature session-limits au composition root (app-tauri). Project root: /home/anthony/Documents/Projects/IdeA. Périmètre : UNIQUEMENT app-tauri (state.rs, commands.rs, lib.rs) + au besoin exposer un champ sur LaunchAgentOutput. Aucun nouveau port domaine, aucun nouvel adapter infra : c'est du câblage de l'existant. Architect a fourni la carte de câblage suivante ; suis-la fidèlement, dans l'ORDRE D'IMPLÉMENTATION recommandé. Vérifie chaque ancrage (fichier/struct/ligne) toi-même avant d'éditer car les lignes ont pu bouger. === CARTE DE CÂBLAGE ARCHITECT === 1. INSTANCIATION DU SERVICE — dans crates/app-tauri/src/state.rs, AppState::build. Réutiliser clock (SystemClock, Arc) et event_bus partagé (events_port, Arc). Séquence (après construction de launch_agent et project_store, avant le bloc orchestrateur) : a. let (resume_tx, resume_rx) = tokio::sync::mpsc::unbounded_channel::(); b. let scheduler = Arc::new(TokioScheduler::new(resume_tx, Arc::clone(&clock) as Arc)) as Arc; c. let resumer = Arc::new(AppAgentResumer::new(...)) as Arc; d. let session_limit_service = Arc::new(SessionLimitService::new(Arc::clone(&clock) as Arc, scheduler, Arc::clone(&events_port), resumer)); Ajouter champ pub session_limit_service: Arc<SessionLimitService> à AppState et le renvoyer dans le littéral final. resume_rx N'entre PAS dans AppState : il est moved dans la tâche de drain spawné dans build (§5). Imports : application::{SessionLimitService, AgentResumer}, domain::ports::{Scheduler, ScheduledTask}, infrastructure::TokioScheduler. 2. PORT AgentResumer → LaunchAgent — nouvel adapter AppAgentResumer dans state.rs, à côté des passerelles AppHandoffProvider / AppProviderSessionProvider / AppRecordTurnProvider (même patron impl application::Trait for AppXxx). impl application::AgentResumer { async fn resume(agent_id, node_id, conversation_id, resume_prompt) -> Result<(),AppError> } recompose un LaunchAgentInput et appelle self.launch_agent.execute(...) (le MÊME Arc que la commande launch_agent). LaunchAgent applique déjà SessionPlan::Resume quand conversation_id présent. ⚠️ POINT DUR : AgentResumer::resume et ScheduledTask::ResumeAgent ne portent PAS de project_id, mais LaunchAgentInput exige Project complet + rows/cols + mcp_runtime. Solution : AppAgentResumer détient un Arc<Mutex<HashMap<AgentId, ResumeContext>>> (ResumeContext = { project: Project, rows: u16, cols: u16 }) ALIMENTÉ par la commande launch_agent (là où project/rows/cols sont en main) et lu au resume. mcp_runtime recalculé dans resume via crate::mcp_endpoint::{idea_exe_path, mcp_endpoint} (même recette que la commande launch_agent). store_port injecté en repli. Injection du resume_prompt (constante application::RESUME_PROMPT) comme premier tour : pour le chemin PTY natif, réutiliser le médiateur d'entrée / portail d'écriture PTY (MediatedInbox) plutôt qu'un write brut. 3. TAP NIVEAU 1 (structuré) — dans crates/app-tauri/src/commands.rs, fn agent_send, boucle de pump du ReplyStream. AVANT chunk_from_event : if let ReplyEvent::RateLimited { resets_at_ms } = &event { service.on_rate_limited(agent_id, node_id, conversation_id, *resets_at_ms); } puis continuer le drain (non terminal). Récup node_id/agent_id : ajouter méthode meta_for_session(&SessionId)->Option<(AgentId,NodeId)> sur StructuredSessions (crates/application/src/terminal/registry.rs, jumeau de live_agents, lookup dans entries). conversation_id : passer None (acceptable LS7). Ce tap est DORMANT en composition B-2 mais à câbler pour forward-compat. Arc::clone(&state.session_limit_service) avant le thread::spawn, move dans le thread. 4. TAP NIVEAU 2 (PTY) — chemin ACTIF — dans commands.rs, fn launch_agent, branche PTY (if output.structured.is_none() + thread::spawn du pump d'octets) : a. Sélection §21.10-4 : appeler infrastructure::ratelimit::applies(&profile) avant d'armer. Besoin : exposer le AgentProfile (ou au minimum le RateLimitPattern) résolu sur LaunchAgentOutput (LaunchAgent::execute le résout déjà en interne — option la plus propre, zéro I/O). b. RateLimitParser::new(&pattern) (Option ⇒ regex invalide = pas de détecteur, jamais de panique), construit une fois par lancement, déplacé dans le thread de pump. c. Dans la boucle for chunk in stream, après send_output : String::from_utf8_lossy(&chunk) puis parser.detect(&text, clock.now_millis()). Sur Some(SessionLimit) ⇒ service.on_rate_limited(agent_id, node_id, conversation_id, limit.resets_at_ms). agent_id/node_id/conversation_id (request.conversation_id) déjà en main dans la commande ⇒ cloner avant thread::spawn. Besoin d'un Arc (réutiliser SystemClock). Anti-double-détection garantie par applies (structured_adapter.is_none()). Fragmentation PTY : best-effort par fragment pour LS7 (note QA). 5. DRAIN DU SCHEDULER — resume_rx drainé dans une tâche détachée spawné DANS AppState::build sur le patron EXACT de sweep_stalled : utiliser tauri::async_runtime::spawn (PAS tokio::spawn — build tourne dans le hook setup sans runtime ambiant). Boucle : while let Some(task) = resume_rx.recv().await { if let Err(e) = service.execute_resume(task).await { /* log best-effort */ } }. service (Arc) et resume_rx moved dans la closure. 6. COMMANDE TAURI cancel_resume — dans commands.rs : #[tauri::command] pub async fn cancel_resume(agent_id: String, state: State<'_, AppState>) -> Result<bool, ErrorDto> { let id = parse_agent_id(&agent_id)?; Ok(state.session_limit_service.cancel_resume(id)) }. Enregistrer dans crates/app-tauri/src/lib.rs generate_handler![ … ] (à côté des commandes agent, ex. après change_agent_profile). ORDRE : (1)+(5) avec un AgentResumer stub d'abord (valide armement→canal→execute_resume→AgentResumed), puis (6) cancel_resume, puis (4) tap N2 PTY, puis (2) AppAgentResumer réel + registre ResumeContext alimenté par launch_agent, puis (3) tap N1 structuré + meta_for_session. CONFORMITÉ : domaine pur, regex/parse confinés infra, service pur-ports — ne rien violer. Pas de panique sur profil mal configuré / resume sans contexte (repli propre). === FIN CARTE === À la fin : cargo build --workspace puis cargo test --workspace et rapporte la SORTIE RÉELLE (succès/échec, nombres). Ajoute des tests unitaires côté app-tauri pour ce qui est testable sans Tauri runtime (ex. AppAgentResumer avec un LaunchAgent fake, meta_for_session sur StructuredSessions, la commande cancel_resume si possible). Rends via idea_reply : fichiers modifiés, décisions prises sur les points durs, et la sortie compilation/tests.
Response: LS7 terminé — workspace recompile, suite complète verte (83 binaires de test, 0 échec). Câblage suivi fidèlement, dans l'ordre recommandé. ## Fichiers modifiés app-tauri (cœur du câblage) - crates/app-tauri/Cargo.toml : async-trait déplacé/ajouté en [dependencies] (il n'était qu'en [dev-dependencies] ⇒ l'impl du port async AgentResumer côté lib ne compilait pas). - crates/app-tauri/src/state.rs : - (1) Instanciation du service dans AppState::build, après input_mediator et avant le bloc orchestrateur : unbounded_channel::<ScheduledTask>(), TokioScheduler (clock partagé), AppAgentResumer, SessionLimitService::new(clock, scheduler, events_port, resumer). Champ pub session_limit_service: Arc<SessionLimitService> + pub resume_contexts: ResumeContexts ajoutés à AppState et au littéral final. - (2) Port AgentResumer → LaunchAgent : nouvel adapter AppAgentResumer (passerelle, même patron que AppHandoffProvider/AppProviderSessionProvider). Recompose un LaunchAgentInput à partir du ResumeContext lu + recalcule mcp_runtime via mcp_endpoint::{idea_exe_path, mcp_endpoint}, appelle le même Arc<LaunchAgent>, puis injecte RESUME_PROMPT comme premier tour via le portail d'entrée (InputMediator::enqueue, pas de write brut, §20). Types ResumeContext { project, rows, cols } + alias ResumeContexts = Arc<Mutex<HashMap<AgentId, ResumeContext>>>. - (5) Drain du scheduler : tâche détachée tauri::async_runtime::spawn (patron exact de sweep_stalled) : while let Some(task) = resume_rx.recv().await { service.execute_resume(task).await } (log best-effort sur erreur). - crates/app-tauri/src/commands.rs : - (4) Tap niveau 2 (PTY, chemin actif) dans launch_agent : sélection §21.10-4 via infrastructure::ratelimit::applies(&output.profile), RateLimitParser::new(pattern) construit une fois, déplacé dans le thread de pump ; dans la boucle, avant send_output, String::from_utf8_lossy + parser.detect(text, clock.now_millis()) ⇒ service.on_rate_limited(agent_id, host_node_id, conversation_id, limit.resets_at_ms). Alimente aussi state.resume_contexts (projet cloné + rows/cols) à chaque lancement. - (3) Tap niveau 1 (structuré, dormant mais câblé) dans agent_send : meta_for_session(&sid) résout (agent_id, node_id) ; sur ReplyEvent::RateLimited { resets_at_ms } ⇒ service.on_rate_limited(.., None, *resets_at_ms) puis on continue le drain (conversation_id = None, acceptable LS7). - (6) Commande cancel_resume(agent_id) -> Result<bool> déléguant à session_limit_service.cancel_resume. - crates/app-tauri/src/lib.rs : commands::cancel_resume enregistré dans generate_handler!. application (sanctionné par la carte) - crates/application/src/agent/lifecycle.rs : champ pub profile: Option<AgentProfile> exposé sur LaunchAgentOutput (résolu déjà en interne, zéro I/O) ; Some(profile.clone()) sur les 2 lancements effectifs (PTY + structuré), None sur les 3 réattaches (rebind/idempotent). - crates/application/src/terminal/registry.rs : StructuredSessions::meta_for_session(&SessionId) -> Option<(AgentId, NodeId)> (jumeau « inverse » de live_agents, lookup direct). Tests - crates/app-tauri/tests/session_limit_wiring.rs (nouveau) : cancel_resume no-op propre pour agent inconnu ; on_rate_limited arme une reprise annulable et publie AgentRateLimited→AgentResumeScheduled→(après cancel)AgentResumeCancelled sur le vrai bus via AppState::build. - crates/application/tests/structured_registry_d1.rs : test meta_for_session (résout agent+cellule, None si id inconnu/retiré). - Tests existants dto_agents.rs / dto_chat.rs mis à jour avec profile: None (nouveau champ du struct). ## Décisions sur les points durs - Profil pour la sélection N2 : exposé en Option<AgentProfile> sur LaunchAgentOutput (option « la plus propre » de la carte) plutôt que dupliquer la règle ; app-tauri appelle infrastructure::ratelimit::applies ⇒ règle anti-double-détection N1/N2 reste l'unique source infra. None sur réattache (best-effort : pas d'armement, le tour n'a pas de nouvelle session). - AgentResumer::resume sans project_id : registre ResumeContexts partagé (composition root ↔ commande launch_agent) ; alimenté là où Project/taille sont en main. Resume « à l'aveugle » (contexte absent) ⇒ Err(NotFound) propre ⇒ AgentResumed non publié, jamais de panique. - Injection RESUME_PROMPT : via InputMediator::enqueue (portail d'écriture unique, §20), PendingReply lâché (reprise ≠ délégation corrélée). - Horloge du tap N2 : infrastructure::SystemClock local au pump (l'AppState n'expose pas le clock). - Limitations notées (best-effort LS7) : fragmentation PTY (motif coupé entre 2 fragments) ⇒ raté best-effort par fragment ; le ré-abonnement du pump PTY n'est pas recâblé sur la reprise auto hors-commande (l'agent tourne, le front peut réattacher). ## Sortie compilation/tests (réelle) - cargo build --workspace : Finished dev profile ... in 18.04s ✅ (0 warning sur les crates touchées). - cargo test --workspace : 83 binaires test result: ok, 0 failed, 0 erreur. Dont : - tests/session_limit_wiring.rs : cancel_resume_is_a_clean_noop_for_unknown_agent ok, on_rate_limited_arms_a_cancellable_resume_over_the_real_bus ok. - application structured_meta_for_session_resolves_agent_and_node ok (12 passed). - infrastructure 221 passed, app-tauri (events/pty/orchestrator/dto…) verts. Conformité hexagonale respectée : DTO/wire inchangés côté domaine, regex/parse confinés infra (applies/RateLimitParser), service pur-ports, aucun nouveau port domaine ni adapter infra (câblage de l'existant uniquement).
Prompt: Tâche LS8-backend — filet humain niveau 3 « armement par heure saisie » (ARCHITECTURE §21.1). Branche feature/agent-session-limits. Cadrage Architect (verdict B) ci-dessous, à implémenter tel quel. CONTEXTE : niveaux 1/2 détectent→planifient une reprise auto annulable. Niveau 3 : agentRateLimitSuspected est émis sans heure fiable ; il manque la boucle d'action pour que l'utilisateur saisisse l'heure et arme la MÊME reprise (annulable). DOMAINE : RIEN à ajouter — domain::session_limit a déjà RateLimitSource::Human, plan_resume (clampe à now si heure passée ⇒ reprise immédiate), ResumePlan::Scheduled. 1) APPLICATION — SessionLimitService (crates/application, cherche le module session_limit/service) : - Factorise la branche ResumePlan::Scheduled actuelle de on_rate_limited en une méthode privée fn arm_scheduled(&self, agent_id, fire_at_ms, node_id, conversation_id) qui fait : publish AgentRateLimited{Some(t)} → disarm (dédoublonnage existant) → scheduler.arm(ScheduledTask::ResumeAgent{...}) → mémoriser le ScheduleId → publish AgentResumeScheduled{fire_at_ms}. on_rate_limited appelle cette privée pour son cas Scheduled (comportement identique, zéro régression). - Ajoute la méthode publique : rust /// (d) Filet humain (§21.1 niveau 3). L'utilisateur a saisi l'heure de reset /// pour un agent en limite SUSPECTÉE. Construit une SessionLimit source `Human`, /// calcule le plan et arme la reprise EXACTEMENT comme la branche auto : mêmes /// événements, même dédoublonnage, même annulabilité via cancel_resume. pub fn confirm_human_resume(&self, agent_id: AgentId, node_id: NodeId, conversation_id: Option<String>, resets_at_ms: i64) Corps : SessionLimit::new(Some(resets_at_ms), now, RateLimitSource::Human) → plan_resume → sur ResumePlan::Scheduled{fire_at_ms} appelle arm_scheduled(...). (Vérifie les noms/signatures exacts de SessionLimit::new, plan_resume, ResumePlan dans le domaine et aligne-toi dessus.) execute_resume et cancel_resume restent INCHANGÉS (l'armement humain s'annule/s'exécute par les mêmes voies : invariant = un seul mécanisme de reprise). 2) APP-TAURI — commande miroir de cancel_resume (crates/app-tauri/src/commands.rs) : rust #[tauri::command] pub async fn set_resume_at(agent_id: String, resets_at_ms: i64, state: State<'_, AppState>) -> Result<(), ErrorDto> Corps : parse_agent_id → résoudre côté backend (le front n'a que l'agent_id) : - node_id : via la registry des sessions vivantes (cherche un node_for_agent/équivalent sur TerminalSessions/StructuredSessions ; tu as déjà ajouté meta_for_session en LS7 — trouve/ajoute le lookup agent→node). Si pas de cellule vivante ⇒ ErrorDto NOT_FOUND/INVALID (la saisie n'a pas de cible). - conversation_id : best-effort via la session structurée de l'agent (None toléré). Puis state.session_limit_service.confirm_human_resume(id, node_id, conv_id, resets_at_ms). Enregistre la commande dans lib.rs à côté de cancel_resume. 3) ÉVÉNEMENTS : n'en crée AUCUN. confirm_human_resume réémet la paire existante AgentRateLimited{Some} + AgentResumeScheduled{fire_at_ms} (déjà relayées au front). Annulation/reprise via AgentResumeCancelled/AgentResumed inchangés. Compile (cargo build) et lance les tests des crates touchées. NE COMMIT PAS (Git tranche). Rends-moi via idea_reply : fichiers modifiés, signature exacte des méthodes domaine que tu as constatées (SessionLimit::new, plan_resume, ResumePlan), le lookup agent→node que tu as utilisé/ajouté, et le résultat de compilation/tests. QA écrira les tests ensuite — structure pour la testabilité.
Response: LS8-backend (filet humain niveau 3) implémenté tel que cadré — verdict B. Build OK, tous tests verts, NON commité. ## Signatures domaine constatées (crates/domain/src/session_limit.rs) — RIEN ajouté - RateLimitSource::{Structured, Pattern, Human} (enum Copy). - SessionLimit::new(resets_at_ms: Option<i64>, detected_at_ms: i64, source: RateLimitSource) -> Self (const, ordre des args = (Option heure, now, source)). - plan_resume(now_ms: i64, limit: &SessionLimit, conversation_id: Option<String>) -> ResumePlan. - ResumePlan::Scheduled { fire_at_ms: i64, conversation_id: Option<String> } | ResumePlan::HumanFallback. Le clamp anti-passé (fire_at_ms = resets_at_ms.max(now_ms)) est dans plan_resume ⇒ heure saisie déjà passée = reprise immédiate, gratis. ## Fichiers modifiés 1. crates/application/src/agent/session_limit.rs - Factorisé la branche ResumePlan::Scheduled de on_rate_limited en privée fn arm_scheduled(&self, agent_id, fire_at_ms, node_id, conversation_id, resets_at_ms: Option<i64>). on_rate_limited l'appelle pour son cas Scheduled → comportement identique (les 9 tests session_limit_service existants passent inchangés). - ⚠️ Écart assumé vs signature suggérée : j'ai ajouté un 5e param resets_at_ms: Option<i64> à arm_scheduled. Raison : l'événement AgentRateLimited d'origine publie l'heure de reset brute (l'Option d'entrée), PAS fire_at_ms (qui est clampé). Les deux diffèrent si le reset est passé. Pour garantir le « zéro régression » exigé, j'ai propagé l'heure de reset brute au lieu de republier Some(fire_at_ms). Les deux appelants passent Some(...). - Ajouté la publique pub fn confirm_human_resume(&self, agent_id: AgentId, node_id: NodeId, conversation_id: Option<String>, resets_at_ms: i64) : SessionLimit::new(Some(resets_at_ms), now, RateLimitSource::Human) → plan_resume → sur Scheduled appelle arm_scheduled(..., Some(resets_at_ms)). Cas HumanFallback traité en no-op défensif (inatteignable car resets_at_ms toujours Some). execute_resume et cancel_resume INCHANGÉS. 2. crates/app-tauri/src/commands.rs — ajout #[tauri::command] pub async fn set_resume_at(agent_id: String, resets_at_ms: i64, state) -> Result<(), ErrorDto>, miroir de cancel_resume. 3. crates/app-tauri/src/lib.rs — commands::set_resume_at enregistrée juste après commands::cancel_resume dans le generate_handler!. ## Lookup agent→node utilisé (existant, rien ajouté) La registry des sessions vivantes expose déjà node_for_agent. set_resume_at résout : - node_id = state.structured_sessions.node_for_agent(&id).or_else(|| state.terminal_sessions.node_for_agent(&id)) (structuré d'abord car il porte aussi la conv ; repli terminal/PTY). Aucune cellule vivante ⇒ ErrorDto::from(AppError::NotFound(...)). - conversation_id best-effort = state.structured_sessions.session_for_agent(&id).and_then(|s| s.conversation_id()) (via AgentSession::conversation_id() -> Option<String>, ports.rs:549). None toléré. Méthodes constatées dans crates/application/src/terminal/registry.rs : TerminalSessions::node_for_agent (l.175), StructuredSessions::node_for_agent (l.375), session_for_agent, meta_for_session. ## Événements : AUCUN créé. confirm_human_resume → arm_scheduled réémet la paire existante AgentRateLimited{Some(t)} + AgentResumeScheduled{fire_at_ms}. Annulation/reprise par les voies inchangées (AgentResumeCancelled/AgentResumed). ## Compilation / tests - cargo build -p application -p app-tauri : Finished, 0 erreur/0 warning. - cargo test -p domain -p application : tout vert (domain 39, session_limit_service 9, session_limit_t4 7, + le reste). - cargo test -p app-tauri : tout vert (dont wiring 43). ## Pour QA (testabilité) - confirm_human_resume testable 100 % sans I/O via les fakes existants (Clock/Scheduler/EventBus) déjà utilisés dans tests/session_limit_service.rs. Cas à couvrir : (a) heure future ⇒ AgentRateLimited{Some} puis AgentResumeScheduled{fire_at_ms=resets_at_ms} + ScheduleId mémorisé ; (b) heure passée ⇒ fire_at_ms == now (reprise immédiate) ; (c) dédoublonnage : un confirm_human_resume après un armement existant annule le précédent (1 seule entrée armée) ; (d) annulabilité : cancel_resume après confirm_human_resume publie AgentResumeCancelled ; (e) parité auto/humain : même séquence d'événements que on_rate_limited cas Scheduled. - set_resume_at : node_for_agent None ⇒ NOT_FOUND.
Prompt: Feature « Agent orchestrateur du projet », branche active feature/orchestrator-designation. Implémente le ticket T1 — Fondation domaine (pur, aucune I/O). Cadrage Architect ci-dessous, à respecter strictement. ## Modèle On ne persiste que la DÉVIATION au défaut : un champ projet orchestrator: Option<AgentId>. None = défaut « plus ancien agent » (= entries.first()). Some(id) = désignation explicite (radio). Ça rend l'état illégal « 2 orchestrateurs » non représentable et donne la rétro-compat gratuitement. ## À implémenter (domaine pur uniquement, T1) 1. VO OrchestratorDesignation (dans crates/domain/src/fileguard.rs ou un petit module dédié, à toi de voir le plus cohérent) : - none() -> Self (aucun agent désigné, humain seul) - of(agent: AgentId) -> Self - designated(&self) -> Option<AgentId> 2. Politique fileguard.rs — élargis les signatures : - is_orchestrator(who: ConversationParty, d: &OrchestratorDesignation) -> bool : User => true (humain permanent), Agent{id} => d.designated() == Some(id). (Perd le const, OK.) - may_write_directly(who, res, d: &OrchestratorDesignation) -> bool : si res.is_project_context() → is_orchestrator(who, d), sinon true. - Préserve le test single-writer existant en lui passant &OrchestratorDesignation::none() : l'agent reste refusé, l'humain reste autorisé. 3. AgentManifest (crates/domain/src/agent.rs) : - Champ orchestrator: Option<AgentId> avec #[serde(default, skip_serializing_if = "Option::is_none")]. - effective_orchestrator(&self) -> Option<AgentId> = self.orchestrator.or_else(|| self.entries.first().map(|e| e.agent_id)) (adapte au vrai nom du champ id de l'entrée). - orchestrator_designation(&self) -> OrchestratorDesignation (fold de l'effectif vers le VO). - designate(&mut self, id) -> Result<(), DomainError> : sémantique radio (écrase), valide que id appartient à entries. - on_agent_deleted(&mut self, removed: AgentId) : si orchestrator == Some(removed) → None. - Validation dans le constructeur (AgentManifest::new ou équivalent) : orchestrator == Some(id) ⇒ id doit être présent dans entries ; None toujours valide. - Invariant à documenter : les entrées du manifeste sont en ordre de création (entries.first() = plus ancien). Pas de timestamp à ajouter. 4. events.rs : nouveau DomainEvent::OrchestratorChanged { project_id, orchestrator: Option<AgentId> } (adapte aux champs/conventions des variants existants). ## Tests unitaires (dans les modules, T1) - single-writer préservé avec none() (agent refusé / humain autorisé) ; - agent désigné autorisé à écrire le contexte projet ; - défaut « plus ancien » quand orchestrator == None ; - succession lazy : on_agent_deleted du désigné → retombe sur plus ancien ; - designate écrase (radio) + rejette un agent absent ; - validation référentielle du constructeur. Respecte l'archi hexagonale (domaine sans I/O), SOLID, le style existant. Compile + teste le crate domaine (cargo test -p domain ou le vrai nom du package). Quand c'est vert, réponds via idea_reply avec : fichiers touchés, signatures finales exactes (pour que les tickets aval s'y accrochent), et la sortie réelle des tests. Si rouge, donne la sortie d'erreur réelle.
Response: ## T1 — Fondation domaine : VERT ✅ cargo test -p domain passe intégralement : lib 175 passed; 0 failed (dont 11 nouveaux tests), + toutes les suites d'intégration du crate (entities, serde_roundtrip, etc.) restent vertes. Aucune I/O introduite, domaine pur. ### Fichiers touchés (domaine pur uniquement) - crates/domain/src/fileguard.rs — VO OrchestratorDesignation + élargissement des signatures de politique + tests. - crates/domain/src/agent.rs — champ orchestrator sur AgentManifest + méthodes + tests (module orchestrator_tests). - crates/domain/src/events.rs — variant DomainEvent::OrchestratorChanged + test. - crates/domain/src/lib.rs — réexport de OrchestratorDesignation. ### Signatures finales exactes (points d'accroche pour les tickets aval) fileguard.rs (réexportées depuis domain::) : rust pub struct OrchestratorDesignation(/* private Option<AgentId> */); impl OrchestratorDesignation { pub const fn none() -> Self; pub const fn of(agent: AgentId) -> Self; pub const fn designated(&self) -> Option<AgentId>; } // dérive Debug, Clone, Copy, PartialEq, Eq pub fn is_orchestrator(who: ConversationParty, d: &OrchestratorDesignation) -> bool; pub fn may_write_directly( who: ConversationParty, res: &GuardedResource, d: &OrchestratorDesignation, ) -> bool; Sémantique : User => true (humain permanent), Agent{id} => d.designated() == Some(id). may_write_directly ⇒ is_orchestrator si res.is_project_context(), sinon true. Les deux perdent const (le match sur who n'est pas const-compatible ici). agent.rs — AgentManifest (nouveau champ pub orchestrator: Option<AgentId> avec #[serde(default, skip_serializing_if = "Option::is_none")]) : rust // constructeur historique inchangé (orchestrator = None, toujours valide) pub fn new(version: u32, entries: Vec<ManifestEntry>) -> Result<Self, DomainError>; // constructeur validant la désignation explicite (intégrité référentielle) pub fn with_orchestrator( version: u32, entries: Vec<ManifestEntry>, orchestrator: Option<AgentId>, ) -> Result<Self, DomainError>; pub fn effective_orchestrator(&self) -> Option<AgentId>; // designation || entries.first() pub fn orchestrator_designation(&self) -> OrchestratorDesignation; // fold de l'effectif vers le VO pub fn designate(&mut self, id: AgentId) -> Result<(), DomainError>; // radio, écrase, valide l'appartenance pub fn on_agent_deleted(&mut self, removed: AgentId); // Some(removed) -> None (succession lazy) Choix d'implémentation à noter : AgentManifest::new garde sa signature (orchestrator = None) ; la validation référentielle du constructeur demandée est portée par with_orchestrator (new y délègue avec None). Ça évite de casser tous les appelants AgentManifest::new(version, entries) existants. La validation : orchestrator == Some(id) ⇒ id ∈ entries, sinon DomainError::InconsistentManifest. Invariant d'ordre documenté sur le doccomment du struct : entries en ordre de création, entries.first() = plus ancien, pas de timestamp. events.rs : rust DomainEvent::OrchestratorChanged { project_id: ProjectId, orchestrator: Option<AgentId>, } ### Tests couverts (tous verts) - single-writer préservé avec none() (agent refusé / humain autorisé) ; - agent désigné autorisé à écrire le contexte projet (+ autre agent refusé, humain toujours OK) — testé côté fileguard ET via AgentManifest::orchestrator_designation() ; - défaut « plus ancien » quand orchestrator == None (+ manifeste vide ⇒ None) ; - succession lazy : on_agent_deleted du désigné → None → retombe sur plus ancien ; no-op si l'agent supprimé n'était pas le désigné ; - designate écrase (radio) + rejette un agent absent (et préserve la désignation valide précédente) ; - validation référentielle du constructeur (with_orchestrator) ; - OrchestratorChanged construit/compare. ### ⚠️ Impact aval à prévoir (hors scope T1, à câbler par les tickets suivants) La couche infrastructure ne compile plus tel quel — c'est attendu, le câblage est aval : 1. crates/infrastructure/src/fileguard/mod.rs:93 appelle encore may_write_directly(who, &res) (2 args). L'adaptateur RwFileGuard doit recevoir/threader une OrchestratorDesignation (probablement injectée depuis le manifeste courant) et passer 3 args. 2. Le nouveau champ orchestrator casse les littéraux de struct exhaustifs AgentManifest { version, entries } (≈ infra store/context.rs, application context_guard.rs/tests, app-tauri/state.rs, plusieurs tests). Fix mécanique : ajouter orchestrator: None ou ..Default::default(). Default est dérivé donc ..Default::default() marche. cargo test -p domain étant le périmètre demandé, le crate domaine est vert et autonome ; ces deux points sont la surface de câblage des tickets T2+.
Prompt: Suite de la feature orchestrateur, branche feature/orchestrator-designation. T1 (domaine) est vert. Implémente maintenant T2 → T5 (infra + application backend) pour rétablir un workspace qui compile et tester. Suis le cadrage Architect, notamment l'Alternative A retenue. ### T2 — Infra : guard = verrou pur + serde rétro-compatible (dépend T1) - Alternative A (RETENUE) : RwFileGuard::acquire_write (crates/infrastructure/src/fileguard/mod.rs) NE fait plus le check d'identité orchestrateur. Il redevient un verrou pur (sérialise les writers, comme un rwlock). Donc retire l'appel may_write_directly côté guard (la ligne ~93). L'autorisation single-writer remonte dans ProposeContext (T3). GuardError::Forbidden n'est plus émis par le guard — vérifie ce que ça implique pour le port/les tests du guard (déplace/retire le test « Forbidden » qui n'a plus lieu d'être à ce niveau, documente que le guard est désormais un lock pur). Si la signature du port FileGuard::acquire_write portait un paramètre lié à l'identité, garde-la cohérente. - Serde : corrige tous les littéraux exhaustifs AgentManifest { version, entries } cassés par le nouveau champ (ajoute orchestrator: None ou ..Default::default()). Test round-trip : un agents.json legacy SANS le champ orchestrator se désérialise → None → effective_orchestrator() = plus ancien. ### T3 — Application : autorisation propose (cœur MCP) (dépend T1, T2) Dans ProposeContext (crates/application/.../context_guard.rs), branche globale (target = None) : let manifest = contexts.load_manifest(project).await?; let d = manifest.orchestrator_designation(); if may_write_directly(requester, &GuardedResource::ProjectContext, &d) { let _lease = guard.acquire_write(requester, ProjectContext).await?; // sérialise fs.write(project_context_file, content) -> Written } else { file_proposal(...) -> Proposed { path } // inchangé } Conséquence : quand l'appelant idea_context_propose (sans target) EST l'orchestrateur désigné, l'écriture devient DIRECTE ; sinon proposition ; l'humain écrit toujours direct. Tests : agent désigné → write direct ; agent non-désigné → proposition ; humain → direct. ### T4 — Application : défaut + succession (dépend T1) - DeleteAgent::execute (lifecycle.rs) : après filtrage des entrées, appelle manifest.on_agent_deleted(removed) avant save_manifest ; émets DomainEvent::OrchestratorChanged si effective_orchestrator() a changé. - Défaut (Create scratch + template) : pas de logique à ajouter (modèle paresseux), mais ajoute les tests qui figent « 1er agent créé = orchestrateur effectif » et l'émission de OrchestratorChanged si l'effectif passe de None→1er. - Tests succession : désigné explicite supprimé → retombe sur plus ancien ; non-désigné supprimé → repointage paresseux. ### T5 — Application : SetOrchestrator + ListAgents output (dépend T1) - Nouveau use case SetOrchestrator { project, agent_id } : load_manifest → manifest.designate(agent_id) (radio, écrase) → save_manifest → publie OrchestratorChanged. NotFound/erreur domaine si l'agent n'existe pas. - Étends ListAgentsOutput avec orchestrator: Option<AgentId> (= effective_orchestrator()). - Tests (store mock) : écrasement radio, agent inconnu → erreur, output porte l'effectif. Respecte l'archi hexagonale, SOLID, le style existant, aucun nouveau port (compose FileGuard / AgentContextStore / EventBus existants). Compile et teste les crates infra + application (cargo test -p infrastructure -p application ou vrais noms). Quand vert, réponds via idea_reply : fichiers touchés, signatures publiques finales de SetOrchestrator et du champ ajouté à ListAgentsOutput (accroche pour T6), et la sortie réelle des tests. Si rouge, donne l'erreur réelle.
Prompt: Tâche ciblée sur la branche courante feature/orchestrator-designation. Contexte: - Git a décidé de finir le chantier courant orchestrator-designation sur cette branche, sans switch/stash. - Main ne code pas; tu es chargé de la correction backend Rust. - Tests ciblés verts: - cargo test -p infrastructure input --lib: 35 passed. - cargo test -p application --test orchestrator_service: 45 passed. - Frontend vert: - cd frontend && npx vitest run: 41 files, 384 tests passed. - cd frontend && npx tsc --noEmit: OK. Problème à corriger: cargo test --workspace échoue à la compilation sur crates/application/src/orchestrator/context_guard.rs. Sortie réelle: text error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> crates/application/src/orchestrator/context_guard.rs:449:17 | 449 | if !may_write_directly(who, &res) { | ^^^^^^^^^^^^^^^^^^----------- argument #3 of type `&OrchestratorDesignation` is missing error[E0560]: struct `ManifestEntry` has no field named `orchestrator` --> crates/application/src/orchestrator/context_guard.rs:616:21 | 616 | orchestrator: None, | ^^^^^^^^^^^^ `ManifestEntry` does not have this field error[E0063]: missing field `orchestrator` in initializer of `AgentManifest` --> crates/application/src/orchestrator/context_guard.rs:613:23 | 613 | manifest: AgentManifest { | ^^^^^^^^^^^^^ missing `orchestrator` Attendu: - Adapter context_guard.rs au nouveau modèle AgentManifest { version, entries, orchestrator } et à may_write_directly(resource, designation) sans contourner l'architecture. - Supprimer l'import inutilisé si nécessaire. - Garder le domaine propriétaire des règles de désignation orchestrateur. - Ne touche pas aux fichiers .ideai/* runtime. Validation minimale à exécuter après correction: 1. cargo test -p application --test orchestrator_service 2. cargo test --workspace si raisonnable. Réponds avec les fichiers modifiés et les commandes/test outputs réels. Si cette tâche arrive via IdeA, utilise impérativement idea_reply.
Response: Correction backend appliquée sur crates/application/src/orchestrator/context_guard.rs. Modifications: - ProposeContext charge maintenant AgentManifest, récupère manifest.orchestrator_designation(), puis appelle la règle domaine may_write_directly(requester, &GuardedResource::ProjectContext, &designation) avant toute écriture globale. - Le FileGuard reste un verrou de sérialisation: la décision orchestrateur/proposition reste dans le domaine via may_write_directly. - Le commentaire obsolète qui disait que le guard renvoyait Forbidden pour les non-orchestrateurs a été mis à jour. - Les tests locaux de context_guard.rs ont été adaptés au modèle AgentManifest { version, entries, orchestrator }. - Le fake TestGuard ne réimplémente plus l’autorisation; il reflète infrastructure::RwFileGuard comme verrou pur. Fichier modifié par moi: - crates/application/src/orchestrator/context_guard.rs Validations exécutées: 1. cargo fmt --all && cargo test -p application --test orchestrator_service - Résultat: OK - Sortie utile: 45 passed; 0 failed; 0 ignored - Warning existant: method writes is never used dans crates/application/tests/orchestrator_service.rs:1642. 2. cargo test --workspace - Résultat: compilation passée jusqu’à l’exécution des tests, puis échec dans app-tauri sur tests loopback Unix socket sous le sandbox courant. - Sortie utile: app-tauri lib: 39 passed; 8 failed. - Échecs: mcp_bridge::tests::end_to_end_over_real_loopback, state::bind_endpoint_d1_tests::rebind_after_corpse_socket_succeeds, et les tests state::mcp_e2e_loopback_tests::*. - Cause observée: PermissionDenied / Operation not permitted lors du bind ou de la pose de socket sous /run/user/1000/idea-mcp/*.sock, par exemple bind test listener: Os { code: 1, kind: PermissionDenied, message: "Operation not permitted" }. 3. cargo test -p application - Résultat: OK - Sortie utile: tous les tests application sont verts, dont orchestrator::context_guard. - Extraits: lib 41 passed; orchestrator_service 45 passed; suite application complète terminée avec succès. Note: je n’ai pas touché aux fichiers .ideai/* runtime. Le git status montre beaucoup de fichiers déjà modifiés dans le workspace, dont .ideai/*; je les ai laissés tels quels.

84 KiB Raw Blame History Unescape Escape

84 KiB

Raw Blame History