Release v1.2.0

.gitignore

@@ -18,6 +18,9 @@ src-tauri/gen/
 .playwright-mcp/
 *.local.png
 screenshots/
+# Console/network dumps captured while verifying a behaviour in the browser
+# (e.g. proving the artifact CSP blocks an external request). Throwaway by nature.
+*.log
 
 # === IDE / OS ===
 .DS_Store

CHANGELOG.md

@@ -9,6 +9,12 @@ that section and uses it as the GitHub release description, which the app displa
 as-is. The install instructions block (after the `<!-- gh-only -->` marker) is added
 by `release.yml` and stays **only** on the GitHub page — it does not appear in the app.
 
+## v1.2.0
+
+- New: the active goal (`/goal`) is now displayed — on Flight Deck cards and at the top of the conversation — so you always see what an agent is working toward.
+- New: artifacts published by Claude are collected per conversation — an "Artifacts" chip in the composer lists them, and each one shows up inline in the thread.
+- New: usage limits that apply to a single model (such as Fable's weekly allowance) now appear in the usage popover, next to the 5-hour and weekly limits.
+
 ## v1.1.2
 
 - Fixed: Claude usage now shows both the 5-hour and weekly limits whenever they exist, instead of only one at a time.

CLAUDE.md

@@ -128,6 +128,7 @@ Réimplémentation clean-room en Rust du client de l'extension VS Code officiell
 - **Remote control** : `control_request{subtype:"remote_control", enabled:bool, name?}` → `control_response{response:{session_url, connect_url}}` (doublement niché `response.response`). Bridge santé : `system/bridge_state{state:"disconnected"|"error"}` — **dégrade seulement**, "connected" ne vient QUE de la réponse au control_request. Spawn avec **`--replay-user-messages` inconditionnel** (sans lui le binaire n'émet aucune ligne `user` sur stdout) ; on estampille chaque message envoyé d'un uuid et on supprime l'écho de NOS propres tours (`assembler.sent_user_uuids`, one-shot — l'uuid est consommé quel que soit le contenu du tour, texte comme image-seule) ; tour distant (uuid inconnu) surfacé. **Distinguer live vs historique est OBLIGATOIRE** : `history.rs` n'émet pas de `turn_result` → splicer l'historique regrouperait tous les tours user en haut (régression).
 - **Prompts de sous-agents ré-émis en `user`** : un prompt que Claude envoie à un sous-agent (`Task`/`Agent`) arrive en live comme une ligne `user` avec un **uuid FRAIS** (donc pas dans `sent_user_uuids`) + **`parent_tool_use_id` = le tool_use qui l'a spawné** ; `isReplay`/`isSidechain`/`isMeta` sont ABSENTS sur le wire live (champs disque-only, comme `sourceToolUseID` — la leçon du skill-body). VÉRIFIÉ contre claude 2.1.203 (probe pilotant le binaire avec les flags de prod + spawn forcé d'un sous-agent). Sans garde, il FUIT en bulle user dans la conversation principale (« comme si je l'avais envoyé ») → `assembler.ingest_user` ne surface la bulle QUE si `parent_tool_use_id.is_none()`. Contrairement à `isMeta`/`sourceToolUseID`, `parent_tool_use_id` est un champ TOP-LEVEL qui survit au stream → discriminant fiable. Les blocs `tool_result` (résultats internes du sous-agent, même parent) restent traités. Miroir de `history.rs` (skip `isSidechain:true` sur disque) + du guard context-meter de `ingest_stream_event`. Test `subagent_prompt_with_parent_is_not_surfaced_as_user_message`. [fix mergé dev — commit `fc40a4f`]
 - **`reload_plugins`** (`control_request{subtype:"reload_plugins"}`) : hot-reload des plugins d'une session VIVANTE. **VÉRIFIÉ live (2.1.187)** : prend bien en compte un enable/disable écrit dans `~/.claude/settings.json` EN COURS de session (re-scanne AUSSI les SKILLS du plugin) — contredit l'ancien « prend effet au prochain (re)démarrage » : ce message rend le toggle live. Sa réponse de contrôle porte déjà la liste `commands` fraîche (même forme que `initialize` : `response.response.{commands,agents,plugins,mcpServers}`) + le CLI émet un `system/commands_changed` en push. ⚠️ Les skills fournis par un plugin y apparaissent en noms NUS (`brand-guidelines`), PAS `plugin:skill`.
+- **`/goal` (feature native Claude Code, v2.1.139+)** : objectif de session — Claude enchaîne les tours jusqu'à ce qu'un petit modèle valide la condition, puis auto-clear. Son état vit dans le **transcript** en lignes `attachment.type:"goal_status"` (`sentinel`+`met` distinguent set / unmet-check / achieved / clear ; un `/goal clear` écrit aussi un `<local-command-stdout>` `Goal cleared:` / `No goal set`). **DISK-ONLY — JAMAIS sur le stdout live** (seul l'echo `<command-name>/goal</command-name>` remonte live via `--replay-user-messages` ; PAS de voie control-channel, vérifié). Interception = scan FILTRÉ du transcript ENTIER, en avant (`history.rs::load_active_goal` → IPC `load_session_goal`) : pas un tail-scan (un goal posé tôt et jamais terminé reste actif en fin de fichier), mais un pré-filtre par sous-chaîne brute (`goal_status` / `local-command-stdout`) AVANT tout parse JSON — sinon une flotte de cartes Flight Deck paierait un parse complet de plusieurs Mo chacune. Rafraîchi au load/reload, par carte Flight Deck (`seedActiveGoalOnce`, survit au quit/relaunch) et aux fronts de tour (gaté sur `goalSeen` pour ne rien coûter aux convs sans goal). Le bruit `/goal` (echo commande + stdout `Goal set/cleared`/`No goal set`) est masqué du fil (`is_goal_command_noise`, live+reload) ; les `/goal` du composer partent en **envoi silencieux** (live == reload). DISPLAY-ONLY via `goalStore` (mémoire, keyé convId) : chip du composer + icône target Flight Deck, popover partagée `GoalPopover` (condition + dernière raison + clear ; garde de clear pilotée par le cycle de vie de la mutation). Cf. mémoire `goal-feature-wire`.
 
 ## Backend Codex (app-server) — 2ᵉ producteur
 
@@ -301,6 +302,17 @@ SemVer `MAJEUR.MINEUR.CORRECTIF`. En `0.y.z` : MINEUR pour toute nouveauté, COR
 - `repository_id` : `8c509e62-30cb-4f58-9074-086bac72528d`
 - `project_id` (Tosse Code) : `ef02be22-fe30-4463-9450-ec3b20746a35`
 
+
+## Artefacts (gestion + aperçu) — LIVRÉ
+
+Gestion des artefacts produits par l'outil **`Artifact`** de Claude (pages HTML/MD hébergées `claude.ai/code/artifact/<uuid>`, privées par défaut). Contrat wire : `tool_use{name:"Artifact"}` porte `file_path` (dir TEMP éphémère `/private/tmp/claude-<uid>/…/scratchpad/*.html`), `description`, `favicon` (emoji), `label` (= nom de version) ; le `tool_result` est du **texte** dont on parse l'URL canonique (`Published … at https://claude.ai/code/artifact/<uuid>`) ; republier le même `file_path` dans la même conversation garde la même URL et ajoute une version. Disponibilité dépendante de la version du binaire (absent en 2.1.178, présent depuis ~2.1.201).
+
+**Dérivation FRONT pure (zéro Rust/IPC/SQLite)** : `src/features/conversation/artifacts.ts` — `selectArtifacts`/`useArtifacts` scanne les tours de `conversationStore` (blocs `tool_use` name==="Artifact" joints à `toolResults[id]`), **main-thread only** (`parentToolUseId===null` → parité live/reload, miroir du skip_sidechain de `history.rs`), **groupé par `file_path`** (jamais par label — ils se répètent entre fichiers — ni par URL seule, connue seulement au tool_result), header **last-known-good** (un republish qui omet un champ ne blanchit pas l'en-tête), **exclut** les publications entièrement en échec, **strictement read-only** vers claude.ai (jamais de publish/`list` déclenché par l'UI = effet de bord réel sur le compte). Survit au reload gratuitement (tool_use+tool_result rejoués par `history.rs`), contrairement aux tâches de fond live-only.
+
+**Surfaces** : carte inline `ArtifactCard` à chaque publication (états pending/failed/degraded — un `is_error` affiche la raison, zéro-erreur-silencieuse) ; chip composer « Artefacts (N) » + popover portal groupé par version (`ArtifactsChip`, pattern `BackgroundTaskBadge`) ; **carte-lien `ArtifactRefCard`** (une URL d'artefact écrite par Claude dans sa prose → pilule cliquable, câblée dans `MentionLink` APRÈS le `useMemo` pour garder l'ordre des hooks stable). Segment `artifact` dédié dans `toolGroup.ts` (garde `field(input,"file_path")` → un `action:"list"`/url-update retombe en run normal ; peel hors du pli clean-output, comme un `plan`). Icône `artifact` (WF_PATHS) distincte du `globe` de Remote Control.
+
+**Aperçu in-app `ArtifactViewer`** (panneau latéral droit) : lit le fichier local via `commands.readFile` et rend l'**HTML dans un `<iframe srcDoc sandbox="allow-scripts allow-popups">`** (origine nulle → isolé de l'app), le **Markdown via `StreamMarkdown`** ; fallback « Open on claude.ai » si le fichier temp a disparu (post-reload, le fichier local étant éphémère). ⚠️ **Le rendu iframe est possible car la CSP de l'app est `null`** (`tauri.conf.json` `security.csp` = null) — fait technique réutilisable pour tout futur besoin de rendu de contenu web embarqué. Région **`artifactView` EN MÉMOIRE** dans `editorStore` (NON persistée — le fichier temp est éphémère) + `openArtifact`/`closeArtifact` ; prend la place du panneau latéral tant qu'active (exclusive avec Git ; ouvrir éditeur/terminal/Git la referme), câblée dans `MainArea` (`ConductorConversation.tsx`). Helper partagé `openArtifactView` (`artifactOpen.ts`) : fichier local → viewer, sinon navigateur. Détails wire/impl en mémoire locale (`artifact-tool-wire-contract`, `artifacts-panel-audit`).
+
 ## [GENERATED] Associated Project Contexts
 
 ---

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tosse-code",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "private": true,
   "type": "module",
   "scripts": {

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tosse-code"
-version = "1.1.2"
+version = "1.2.0"
 description = "Flight Deck — desktop app to pilot Claude Code"
 authors = ["Tosse"]
 edition = "2021"

src-tauri/src/ipc/commands.rs

@@ -13,7 +13,8 @@ use crate::supervisor::codex::{self, CodexServer};
 use crate::supervisor::control::{self, PermissionDecision, PermissionMode};
 use crate::supervisor::history::{self, DiskConversation, IndexedConversation, SearchHit};
 use crate::supervisor::model::{
-    ContextFill, ConversationItem, SlashCommand, WorkflowJournal, WorkflowPhase, WorkflowRun,
+    ContextFill, ConversationItem, GoalState, SlashCommand, WorkflowJournal, WorkflowPhase,
+    WorkflowRun,
 };
 use crate::supervisor::session::{self, InitialControls, SessionHandle};
 use crate::supervisor::transport::{ImageAttachment, SpawnConfig};
@@ -529,6 +530,24 @@ pub async fn load_session_context(session_id: String) -> Result<ContextFill, Str
         .map_err(|e| e.to_string())
 }
 
+/// Read a conversation's active `/goal` (Claude Code's native goal feature) from its on-disk
+/// transcript. The CLI writes goal state as `attachment` lines that are DISK-ONLY (never on the
+/// live stream), so the UI polls this at conversation load and on each turn edge to know whether a
+/// goal is active and show its condition. `None` when no goal is active.
+///
+/// Reads the transcript in FULL, forward (a goal set early and never terminated is still active
+/// at the end of the file, so no tail slice would do) — but a raw-substring pre-filter rejects
+/// every line that can't carry goal state before it reaches the JSON parser, which is what keeps
+/// a whole Flight Deck fleet seeding its goals affordable. Pure file IO, off the async runtime
+/// via `spawn_blocking`.
+#[tauri::command]
+#[specta::specta]
+pub async fn load_session_goal(session_id: String) -> Result<Option<GoalState>, String> {
+    tokio::task::spawn_blocking(move || crate::supervisor::history::load_active_goal(&session_id))
+        .await
+        .map_err(|e| e.to_string())
+}
+
 /// Rewind a conversation IN PLACE by truncating its on-disk transcript at `target_id`,
 /// dropping that message (USER target) or everything after its response (ASSISTANT
 /// target). Destructive by design ("resume from here"): the removed turns are

src-tauri/src/lib.rs

@@ -18,7 +18,8 @@ use ipc::commands::{
     git_commit_files, git_diff, git_fetch, git_log, git_pull, git_push, git_status,
     interrupt_session, list_disk_conversations, list_extensions, list_marketplaces,
     list_plugin_contents,
-    list_worktrees, load_persisted_state, load_session_context, load_session_history,
+    list_worktrees, load_persisted_state, load_session_context, load_session_goal,
+    load_session_history,
     load_subagent_transcript, load_workflow_journal, load_workflow_phases, load_workflow_run,
     mcp_authenticate, mcp_clear_auth, mcp_reconnect, mcp_status, mcp_toggle, open_in_terminal,
     account_claude_login_cancel, account_claude_login_code, account_claude_login_start,
@@ -88,6 +89,7 @@ fn ipc_builder() -> Builder<tauri::Wry> {
             fetch_slash_commands,
             load_session_history,
             load_session_context,
+            load_session_goal,
             rewind_conversation,
             fork_conversation,
             load_subagent_transcript,

src-tauri/src/supervisor/assembler.rs

@@ -912,7 +912,14 @@ impl Assembler {
             // the context-meter guard in `ingest_stream_event`. The `tool_result` blocks above
             // are still surfaced (a sub-agent's internal results carry the same parent and are
             // routed to its own card downstream).
-            if !was_ours && !text.trim().is_empty() && u.parent_tool_use_id.is_none() {
+            // `/goal` plumbing is represented by the dedicated goal UI now, so never surface it as
+            // a bubble: the command echo is already dropped as `was_ours`, but the CLI-generated
+            // `<local-command-stdout>` reply ("Goal set/cleared", "No goal set") carries a FRESH
+            // uuid — without this guard, clearing a goal from the chip would leave that stdout in
+            // the thread. Mirrors `history.rs` `push_user_text` on reload.
+            if !was_ours && !text.trim().is_empty() && u.parent_tool_use_id.is_none()
+                && !super::history::is_goal_command_noise(&text)
+            {
                 out.push(SessionEvent::Item(ConversationItem::UserMessage {
                     id: uuid,
                     text,

src-tauri/src/supervisor/codex/session.rs

@@ -2151,6 +2151,9 @@ fn rate_limits_to_plan_usage(snap: &RateLimitSnapshot) -> Option<crate::usage::P
     Some(crate::usage::PlanUsage {
         five_hour,
         seven_day,
+        // Codex has no per-model allowance: its snapshot carries exactly two windows
+        // (`primary`/`secondary`), so there is nothing scoped to report.
+        scoped: Vec::new(),
     })
 }