diff --git a/.gitignore b/.gitignore
index ac1ff01..2ccb252 100644
--- a/.gitignore
+++ b/.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
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 261fe78..b65319a 100644
--- a/CHANGELOG.md
+++ b/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.
diff --git a/CLAUDE.md b/CLAUDE.md
index 76fe05b..3ee98e1 100644
--- a/CLAUDE.md
+++ b/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
 
 ---
diff --git a/package.json b/package.json
index 01ca72a..edf38c2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "tosse-code",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 9165c3a..6293142 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -4713,7 +4713,7 @@ checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
 
 [[package]]
 name = "tosse-code"
-version = "1.1.2"
+version = "1.2.0"
 dependencies = [
  "base64 0.22.1",
  "libc",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index fdb9ba6..28137cf 100644
--- a/src-tauri/Cargo.toml
+++ b/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"
diff --git a/src-tauri/src/ipc/commands.rs b/src-tauri/src/ipc/commands.rs
index a75da6d..1d7a8cf 100644
--- a/src-tauri/src/ipc/commands.rs
+++ b/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
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 243b45e..62f8df1 100644
--- a/src-tauri/src/lib.rs
+++ b/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,
diff --git a/src-tauri/src/supervisor/assembler.rs b/src-tauri/src/supervisor/assembler.rs
index 5cf1e1a..8ed8294 100644
--- a/src-tauri/src/supervisor/assembler.rs
+++ b/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,
diff --git a/src-tauri/src/supervisor/codex/session.rs b/src-tauri/src/supervisor/codex/session.rs
index 6eb11a8..cc8de4a 100644
--- a/src-tauri/src/supervisor/codex/session.rs
+++ b/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(),
     })
 }
 
diff --git a/src-tauri/src/supervisor/history.rs b/src-tauri/src/supervisor/history.rs
index 17ec5b0..50191b0 100644
--- a/src-tauri/src/supervisor/history.rs
+++ b/src-tauri/src/supervisor/history.rs
@@ -24,7 +24,7 @@ use serde_json::{json, Value};
 use specta::Type;
 
 use super::assembler::{context_used_from_usage, normalize_blocks};
-use super::model::{ContextFill, ConversationItem};
+use super::model::{ContextFill, ConversationItem, GoalState};
 
 /// Claude's config dir: `$CLAUDE_CONFIG_DIR` if set, else `$HOME/.claude`. Shared
 /// with [`super::subagents`], which reads the sibling task-artifact directories.
@@ -161,6 +161,201 @@ fn load_context_fill_in(config_dir: &Path, session_id: &str) -> ContextFill {
     fill
 }
 
+/// Reconstruct a conversation's active `/goal` from its on-disk transcript. The CLI records
+/// goal state as `attachment` lines of `type:"goal_status"` (DISK-ONLY — never on the live
+/// stream), so this is the only way to know a goal is active. Lifecycle snapshots:
+/// - `{met:false, sentinel:true, condition}` → goal SET (now active).
+/// - `{met:false, condition, reason}` (no sentinel) → still active, unmet check (freshest reason).
+/// - `{met:true, condition, reason, …}` (no sentinel) → ACHIEVED → auto-cleared (inactive).
+/// - `{met:true, sentinel:true, condition}` → manually CLEARED (inactive).
+///
+/// This is a FORWARD scan of the WHOLE file (not a tail read): the last un-terminated goal wins,
+/// exactly what the CLI's own `restoreGoalFromTranscript` does — a goal set early and never
+/// terminated is still active thousands of lines later, so no suffix of the file is enough. The
+/// cost is kept off the JSON parser by a raw-substring pre-filter (see the loop). Returns `None`
+/// when no goal is active. An absent/unreadable transcript yields `None` (soft signal, the next
+/// turn-edge refetch corrects it).
+pub fn load_active_goal(session_id: &str) -> Option<GoalState> {
+    let dir = claude_config_dir()?;
+    load_active_goal_in(&dir, session_id)
+}
+
+fn load_active_goal_in(config_dir: &Path, session_id: &str) -> Option<GoalState> {
+    let path = find_transcript(config_dir, session_id)?;
+    let content = match std::fs::read_to_string(&path) {
+        Ok(content) => content,
+        Err(e) => {
+            if e.kind() != std::io::ErrorKind::NotFound {
+                eprintln!("[history] cannot read transcript for goal scan {}: {e}", path.display());
+            }
+            return None;
+        }
+    };
+    let mut active: Option<GoalState> = None;
+    for line in content.lines() {
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        // PERF — reject a line on RAW BYTES before ever handing it to serde. This scan is not
+        // rare: it runs once per Flight Deck card at mount (`seedActiveGoalOnce` fires for EVERY
+        // conversation in the fleet) and again on every turn edge of a goal-bearing conversation,
+        // on top of the full-file pass `load_context_fill` already makes — over transcripts that
+        // routinely weigh several MB. Parsing every line into a `Value` (allocating a whole tree
+        // per line, tool results and base64 images included) to then drop >99% of them is the
+        // dominant cost of the whole read.
+        // SAFE because only two line shapes can carry goal state, and each one names itself
+        // VERBATIM in the raw JSON text: a `goal_status` attachment spells `goal_status` in its
+        // `type` field, and the `/goal` stdout line spells `local-command-stdout` inside its
+        // content. Both markers are plain ASCII with no character a JSON writer escapes (no
+        // quote, backslash, control char or non-ASCII), so they cannot hide behind `\uXXXX` —
+        // the substring test is exact, not heuristic. It is also a strict SUPERSET filter: a
+        // line that merely mentions the marker still gets parsed and is rejected by the real
+        // checks below, so nothing changes but the work skipped.
+        if !line.contains("goal_status") && !line.contains("local-command-stdout") {
+            continue;
+        }
+        let Ok(entry) = serde_json::from_str::<Value>(line) else {
+            continue;
+        };
+        // Goals are session-scoped on the main thread; a sub-agent's own transcript must not
+        // drive the parent conversation's goal (mirrors the context-fill scan).
+        if entry.get("isSidechain").and_then(Value::as_bool) == Some(true) {
+            continue;
+        }
+        match entry.get("type").and_then(Value::as_str) {
+            Some("attachment") => {
+                let Some(att) = entry.get("attachment") else { continue };
+                if att.get("type").and_then(Value::as_str) != Some("goal_status") {
+                    continue;
+                }
+                let met = att.get("met").and_then(Value::as_bool).unwrap_or(false);
+                let sentinel = att.get("sentinel").and_then(Value::as_bool).unwrap_or(false);
+                match (sentinel, met) {
+                    // SET snapshot — a goal is now active. Reason arrives only after the first eval.
+                    (true, false) => {
+                        let condition = att
+                            .get("condition")
+                            .and_then(Value::as_str)
+                            .unwrap_or_default()
+                            .to_string();
+                        active = Some(GoalState { condition, reason: None });
+                    }
+                    // Terminal snapshots — manual clear (sentinel+met) or achieved (met). Goal gone.
+                    (true, true) | (false, true) => {
+                        active = None;
+                    }
+                    // Unmet check between turns — still active, carry the freshest evaluator reason.
+                    (false, false) => {
+                        if let Some(goal) = active.as_mut() {
+                            if let Some(reason) = att.get("reason").and_then(Value::as_str) {
+                                goal.reason = Some(reason.to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            // The `/goal` local command prints a stdout the CLI treats as authoritative when it
+            // announces the end of a goal ("Goal cleared: …", "Goal achieved…", "No goal set").
+            // Honour it so a stale SET sentinel with no goal_status terminal — e.g. the goal was
+            // cleared while our chip was showing it — never keeps the goal alive. Same shape
+            // table as [`is_goal_command_noise`], so what we HIDE and what we ACT ON can't drift.
+            Some("user") => {
+                if let Some(inner) = local_command_stdout(&entry) {
+                    if goal_stdout_head(&inner, &GOAL_STDOUT_TERMINAL) {
+                        active = None;
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    active
+}
+
+/// The inner text of a `user` line whose content is a single `<local-command-stdout>…</…>`
+/// (what a LOCAL slash command like `/goal` prints back). `None` for any other user line.
+fn local_command_stdout(entry: &Value) -> Option<String> {
+    let content = entry.get("message")?.get("content")?;
+    let text = match content {
+        Value::String(s) => s.clone(),
+        Value::Array(blocks) => blocks
+            .iter()
+            .filter_map(|b| {
+                (b.get("type").and_then(Value::as_str) == Some("text"))
+                    .then(|| b.get("text").and_then(Value::as_str))
+                    .flatten()
+            })
+            .collect::<Vec<_>>()
+            .join("\n"),
+        _ => return None,
+    };
+    let t = text.trim();
+    let inner = t.strip_prefix("<local-command-stdout>")?;
+    Some(inner.strip_suffix("</local-command-stdout>").unwrap_or(inner).to_string())
+}
+
+/// The `/goal` local-command stdout shapes that announce the goal is GONE. Authoritative for
+/// [`load_active_goal_in`]: seeing one drops the active goal even without a `goal_status` terminal.
+/// `Goal cleared: <condition>` and `No goal set` are the two the CLI's non-interactive `/goal clear`
+/// handler actually returns; `Goal achieved` is an Ink/TUI label kept as belt-and-braces — it can
+/// only ever clear a goal that the matching `goal_status{met:true}` line clears anyway.
+const GOAL_STDOUT_TERMINAL: [&str; 3] = ["Goal cleared", "Goal achieved", "No goal set"];
+
+/// The remaining `/goal` stdout shapes — they REPORT a goal rather than end it: the `Goal set: …`
+/// confirmation and the bare `/goal` status line, whose real shape is
+/// `Goal active: <condition> (<n> turns)` (optionally followed by a `\nLast check: …` line). Read
+/// verbatim out of the CLI's own non-interactive `/goal` handler. ⚠️ There is NO `Goal: …` stdout —
+/// that spelling is an Ink/TUI label only, so a `"Goal:"` head would hide nothing the CLI emits and
+/// could only ever swallow an UNRELATED command's output. Thread noise like the terminal ones, but
+/// they must stay OUT of [`GOAL_STDOUT_TERMINAL`]: a status query that dropped the goal would blank
+/// the chip on the very command that asks what the goal is.
+///
+/// Deliberately ABSENT: `Goal condition is limited to N characters (got M)`. It IS a `/goal` stdout,
+/// but it reports a set that FAILED — and since the `/goal` send itself is silent (no user bubble),
+/// hiding it too would leave the user with zero feedback that their goal never took.
+const GOAL_STDOUT_INFO: [&str; 2] = ["Goal set", "Goal active"];
+
+/// Does this `<local-command-stdout>` text OPEN on one of `heads`?
+///
+/// Deliberately an explicit table instead of the blanket `"Goal "` prefix this used to be: that
+/// broad test claimed EVERY local command whose output happens to start with the word "Goal"
+/// ("Goal oriented review complete", "Goal weights updated", …) and, since a match means the
+/// message is dropped from the thread, it would have made another command's output vanish with no
+/// trace — exactly the silent loss the zero-silent-error rule forbids. A head only matches when
+/// the text ENDS there or continues with punctuation/space, so "Goal settings…" can't pass as
+/// "Goal set" and "Goal activity log" can't pass as "Goal active". Shapes are read verbatim out of
+/// the CLI's non-interactive `/goal` handler (see also memory `goal-feature-wire`).
+fn goal_stdout_head(inner: &str, heads: &[&str]) -> bool {
+    let inner = inner.trim_start();
+    heads.iter().any(|head| match inner.strip_prefix(head) {
+        Some(rest) => {
+            let ends_here = |c: char| c.is_whitespace() || c.is_ascii_punctuation();
+            rest.is_empty() || rest.starts_with(ends_here)
+        }
+        None => false,
+    })
+}
+
+/// Is this user-message text pure `/goal` plumbing — the slash-command echo or its
+/// local-command stdout — that the dedicated goal UI (target icon + composer chip) now
+/// represents? We drop it from the thread so MANAGING a goal, above all clearing it from the
+/// chip, never leaves `/goal clear` / "No goal set" / "Goal set:" noise in the conversation.
+/// Matches the `<command-name>/goal</command-name>` invocation (any args) and the `/goal`
+/// `<local-command-stdout>` responses — the known shapes ONLY (set / cleared / achieved / bare
+/// status / "No goal set"), never any stdout that merely opens on the word "Goal".
+pub(crate) fn is_goal_command_noise(text: &str) -> bool {
+    let t = text.trim_start();
+    if t.starts_with("<command-name>/goal</command-name>") {
+        return true;
+    }
+    if let Some(rest) = t.strip_prefix("<local-command-stdout>") {
+        return goal_stdout_head(rest, &GOAL_STDOUT_TERMINAL)
+            || goal_stdout_head(rest, &GOAL_STDOUT_INFO);
+    }
+    false
+}
+
 fn parse_transcript(path: &Path) -> Vec<ConversationItem> {
     match std::fs::read_to_string(path) {
         // The main conversation transcript: skip sidechain (sub-agent) turns — the
@@ -300,6 +495,11 @@ fn push_user_text(uuid: &str, text: &str, items: &mut Vec<ConversationItem>) {
     if text.trim().is_empty() {
         return;
     }
+    // `/goal` plumbing (the command echo + its "Goal set/cleared" / "No goal set" stdout) is now
+    // shown by the dedicated goal UI — drop it so it never clutters the restored thread.
+    if is_goal_command_noise(text) {
+        return;
+    }
     items.push(ConversationItem::UserMessage {
         id: uuid.to_string(),
         text: text.to_string(),
@@ -1432,6 +1632,157 @@ mod tests {
         assert_eq!(fill.context_window, None);
     }
 
+    #[test]
+    fn active_goal_tracks_set_unmet_achieved_and_clear() {
+        let base = std::env::temp_dir().join(format!("tosse-goal-{}", std::process::id()));
+        std::fs::remove_dir_all(&base).ok();
+
+        // (1) A goal SET (sentinel + not met) then TWO unmet checks with different reasons → still
+        //     active, and the FRESHEST (last) reason wins (exercises the overwrite across turns).
+        let sid1 = "11111111-1111-1111-1111-111111111111";
+        write_transcript(&base, "-p", sid1, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"all tests pass"}}"#,
+            r#"{"type":"assistant","uuid":"a","message":{"model":"claude-opus-4-8"}}"#,
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"condition":"all tests pass","reason":"5 tests still failing"}}"#,
+            r#"{"type":"assistant","uuid":"b","message":{"model":"claude-opus-4-8"}}"#,
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"condition":"all tests pass","reason":"3 tests still failing"}}"#,
+        ]);
+        let g = load_active_goal_in(&base, sid1).expect("goal active");
+        assert_eq!(g.condition, "all tests pass");
+        assert_eq!(g.reason.as_deref(), Some("3 tests still failing")); // the LAST reason, not "5 tests"
+
+        // (2) Goal ACHIEVED (met, no sentinel) → cleared.
+        let sid2 = "22222222-2222-2222-2222-222222222222";
+        write_transcript(&base, "-p", sid2, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"all tests pass"}}"#,
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":true,"condition":"all tests pass","reason":"all green","iterations":2}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid2), None);
+
+        // (3) Goal manually CLEARED (sentinel + met) → cleared.
+        let sid3 = "33333333-3333-3333-3333-333333333333";
+        write_transcript(&base, "-p", sid3, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"ship it"}}"#,
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":true,"sentinel":true,"condition":"ship it"}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid3), None);
+
+        // (4) Re-setting after a clear → the NEW goal is active.
+        let sid4 = "44444444-4444-4444-4444-444444444444";
+        write_transcript(&base, "-p", sid4, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":true,"sentinel":true,"condition":"old goal"}}"#,
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"new goal"}}"#,
+        ]);
+        let g4 = load_active_goal_in(&base, sid4).expect("re-set goal active");
+        assert_eq!(g4.condition, "new goal");
+
+        // (5) No goal at all, and a sidechain goal_status must never drive the parent.
+        let sid5 = "55555555-5555-5555-5555-555555555555";
+        write_transcript(&base, "-p", sid5, &[
+            r#"{"type":"assistant","uuid":"a","message":{"model":"claude-opus-4-8"}}"#,
+            r#"{"type":"attachment","isSidechain":true,"attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"subagent goal"}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid5), None);
+
+        // (6) A `/goal clear` stdout clears a stale SET sentinel even with no goal_status terminal
+        //     (the CLI's own "Goal cleared:" / "No goal set" is authoritative).
+        let sid6 = "66666666-6666-6666-6666-666666666666";
+        write_transcript(&base, "-p", sid6, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"ship it"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>Goal cleared: ship it</local-command-stdout>"}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid6), None);
+
+        let sid7 = "77777777-7777-7777-7777-777777777777";
+        write_transcript(&base, "-p", sid7, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"stale"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>No goal set</local-command-stdout>"}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid7), None);
+
+        // (8) An "achieved" stdout is terminal too…
+        let sid8 = "88888888-8888-8888-8888-888888888881";
+        write_transcript(&base, "-p", sid8, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"ship it"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>Goal achieved: ship it</local-command-stdout>"}}"#,
+        ]);
+        assert_eq!(load_active_goal_in(&base, sid8), None);
+
+        // (9) …but ANOTHER command's stdout must never clear the goal, even when it opens on the
+        //     word "Goal" (the shape table is explicit precisely so this can't happen), and the
+        //     `Goal set:` confirmation of our own goal obviously doesn't end it either.
+        let sid9 = "99999999-9999-9999-9999-999999999999";
+        write_transcript(&base, "-p", sid9, &[
+            r#"{"type":"attachment","attachment":{"type":"goal_status","met":false,"sentinel":true,"condition":"ship it"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>Goal set: ship it</local-command-stdout>"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>Goal oriented review finished</local-command-stdout>"}}"#,
+            // And a bare `/goal` STATUS query reports the goal — asking what the goal is must
+            // never be what drops it (that is why "Goal active" lives in the INFO table only).
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>Goal active: ship it (3 turns)\nLast check: still red</local-command-stdout>"}}"#,
+        ]);
+        let g9 = load_active_goal_in(&base, sid9).expect("goal still active");
+        assert_eq!(g9.condition, "ship it");
+
+        std::fs::remove_dir_all(&base).ok();
+    }
+
+    #[test]
+    fn goal_command_noise_is_recognized_and_dropped_on_reload() {
+        // The `/goal` echo + its local stdout are recognized as noise — every known shape:
+        // set / cleared / achieved / bare status / "No goal set".
+        assert!(is_goal_command_noise("<command-name>/goal</command-name>\n  <command-args>clear</command-args>"));
+        assert!(is_goal_command_noise("<local-command-stdout>Goal set: all tests pass</local-command-stdout>"));
+        assert!(is_goal_command_noise("<local-command-stdout>Goal cleared: x</local-command-stdout>"));
+        assert!(is_goal_command_noise("<local-command-stdout>Goal achieved: x</local-command-stdout>"));
+        // The bare `/goal` status query, in the CLI's verbatim shape — multi-line when it carries
+        // the evaluator's last check. The old blanket `"Goal "` prefix hid this one; a `"Goal:"`
+        // head (the TUI label, never a stdout) would NOT, leaking it back into the thread.
+        assert!(is_goal_command_noise(
+            "<local-command-stdout>Goal active: all tests pass (3 turns)\nLast check: 2 suites red</local-command-stdout>"
+        ));
+        assert!(is_goal_command_noise("<local-command-stdout>No goal set</local-command-stdout>"));
+        // …but a real user message and another command's stdout are NOT.
+        assert!(!is_goal_command_noise("please set a goal"));
+        assert!(!is_goal_command_noise("<command-name>/compact</command-name>"));
+        assert!(!is_goal_command_noise("<local-command-stdout>Context compacted</local-command-stdout>"));
+        // Above all, an UNRELATED command whose stdout merely opens on the word "Goal" must stay
+        // in the thread — the old blanket `"Goal "` prefix silently swallowed it.
+        assert!(!is_goal_command_noise("<local-command-stdout>Goal-oriented refactor complete</local-command-stdout>"));
+        assert!(!is_goal_command_noise("<local-command-stdout>Goal oriented review finished</local-command-stdout>"));
+        // …and a head only counts when the sentence opener ENDS there ("Goal set" ≠ "Goal settings").
+        assert!(!is_goal_command_noise("<local-command-stdout>Goal settings updated</local-command-stdout>"));
+        assert!(!is_goal_command_noise("<local-command-stdout>Goal activity log written</local-command-stdout>"));
+        // `Goal: …` is NOT a `/goal` output (the status line is `Goal active: …`) — a project
+        // slash command whose result opens that way must stay in the thread.
+        assert!(!is_goal_command_noise("<local-command-stdout>Goal: 120% of quota</local-command-stdout>"));
+        // A `/goal` set that FAILED must stay visible: the send itself is silent, so hiding the
+        // error too would tell the user nothing at all (zero-silent-error).
+        assert!(!is_goal_command_noise(
+            "<local-command-stdout>Goal condition is limited to 500 characters (got 812)</local-command-stdout>"
+        ));
+
+        // On reload, the goal echo + stdout are dropped from the thread, real turns kept.
+        let base = std::env::temp_dir().join(format!("tosse-goalnoise-{}", std::process::id()));
+        std::fs::remove_dir_all(&base).ok();
+        let sid = "88888888-8888-8888-8888-888888888888";
+        write_transcript(&base, "-p", sid, &[
+            r#"{"type":"user","message":{"role":"user","content":"hello"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<command-name>/goal</command-name>\n<command-args>clear</command-args>"}}"#,
+            r#"{"type":"user","message":{"role":"user","content":"<local-command-stdout>No goal set</local-command-stdout>"}}"#,
+        ]);
+        let path = find_transcript(&base, sid).unwrap();
+        let (items, _) = parse_transcript_str(&std::fs::read_to_string(&path).unwrap(), true);
+        std::fs::remove_dir_all(&base).ok();
+        let users: Vec<_> = items
+            .iter()
+            .filter_map(|i| match i {
+                ConversationItem::UserMessage { text, .. } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(users, vec!["hello"]);
+    }
+
     #[test]
     fn repo_root_rolls_a_worktree_cwd_up_to_the_repo() {
         // An app worktree cwd rolls up to the repo root…
diff --git a/src-tauri/src/supervisor/model.rs b/src-tauri/src/supervisor/model.rs
index 9648065..1c55fd1 100644
--- a/src-tauri/src/supervisor/model.rs
+++ b/src-tauri/src/supervisor/model.rs
@@ -143,6 +143,22 @@ pub struct ContextFill {
     pub context_window: Option<u64>,
 }
 
+/// The active `/goal` of a conversation (Claude Code's native goal feature: Claude keeps
+/// working across turns until a small fast model confirms the condition holds). Reconstructed
+/// from the on-disk transcript — the CLI records goal state as `attachment` lines of
+/// `type:"goal_status"`, which are **DISK-ONLY** (never emitted on the live stream), so this is
+/// the only place to read it. `None` when no goal is active (never set, achieved, or cleared).
+/// Mirrors the CLI's own `restoreGoalFromTranscript`: walk the goal_status snapshots and keep the
+/// last un-terminated one.
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, Type)]
+pub struct GoalState {
+    /// The completion condition the user set (`/goal <condition>`).
+    pub condition: String,
+    /// The evaluator's most recent reason (why the condition is / isn't met yet). `None`
+    /// before the first post-turn evaluation.
+    pub reason: Option<String>,
+}
+
 /// Subscription rate-limit status, normalized from `rate_limit_event.rate_limit_info`.
 /// Carries only what the stream-json protocol exposes: the coarse `status`, the
 /// reset time, the window type, and whether overage is active. The precise usage
diff --git a/src-tauri/src/usage/mod.rs b/src-tauri/src/usage/mod.rs
index 05d237e..b8965c9 100644
--- a/src-tauri/src/usage/mod.rs
+++ b/src-tauri/src/usage/mod.rs
@@ -20,13 +20,23 @@
 //!   string**. We still tolerate a `rate_limits` wrapper (structural only) and pass
 //!   `resets_at` through as a string for the JS `Date` parser on the frontend.
 //! - **`limits` array & `is_active` (2026-07)**: the body ALSO carries a `limits` array
-//!   (`[{ kind, group, is_active, … }]`). The `is_active` flag is NOT "this limit exists":
-//!   it marks which SINGLE limit is currently *binding* and flips between `session` (5h)
-//!   and `weekly_all` (7d) over time (VERIFIED live: `session:false`/`weekly_all:true` on
-//!   2026-07-15, the exact reverse on 2026-07-20). Both the 5h and weekly caps coexist. So
-//!   we surface each window on the PRESENCE of its top-level object and IGNORE `is_active`
-//!   — gating on it would only ever show one window at a time. A limit Anthropic truly
-//!   retires simply drops its object → absent → hidden, needing no special case.
+//!   (`[{ kind, group, percent, scope, is_active, … }]`). The `is_active` flag is NOT "this
+//!   limit exists": it marks which SINGLE limit is currently *binding* and flips between
+//!   `session` (5h) and `weekly_all` (7d) over time (VERIFIED live: `session:false`/
+//!   `weekly_all:true` on 2026-07-15, the exact reverse on 2026-07-20). Both the 5h and
+//!   weekly caps coexist. So we surface each window on the PRESENCE of its object and IGNORE
+//!   `is_active` — gating on it would only ever show one window at a time. A limit Anthropic
+//!   truly retires simply drops its entry → absent → hidden, needing no special case.
+//! - **Model-scoped caps (2026-07, VERIFIED live)**: a third kind of cap exists — a weekly
+//!   allowance scoped to ONE model (today "Fable"). It has **no top-level key at all**: every
+//!   candidate (`seven_day_opus`, `seven_day_sonnet`, `seven_day_cowork`, `seven_day_omelette`,
+//!   `tangelo`, `nimbus_quill`, …) is `null`, and no `seven_day_fable` exists. It lives ONLY in
+//!   `limits[]` as `{"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,
+//!   "scope":{"model":{"display_name":"Fable"}}}` — so it is read from there, keyed off the
+//!   presence of a `scope`, and its name comes from `scope.model.display_name` (**data-driven,
+//!   never hard-coded**: a renamed or additional scoped model follows for free). Note its
+//!   percentage field is `percent` (an integer), not `utilization`, and its `resets_at` may be
+//!   `null` when the window has never started — we then show no reset rather than invent one.
 //!
 //! ## Policy (validated with the user)
 //! - **Token source**: `~/.claude/.credentials.json` FIRST *when its token is still valid*
@@ -62,14 +72,36 @@ const USAGE_URL: &str = "https://api.anthropic.com/api/oauth/usage";
 /// build step catches a stale value here.
 const USER_AGENT: &str = "claude-cli/2.1.186 (external, cli)";
 
-/// Real plan-usage snapshot: the two subscription windows, each with a fill %.
-/// A window is `None` when the endpoint did not report it. `Deserialize` so it can
-/// ride the Codex `session_codex_plan_usage` event (the event bus round-trips its
-/// payload) — the Codex backend reuses this exact shape for its rate-limit push.
+/// Real plan-usage snapshot: the two account-wide subscription windows, each with a fill %,
+/// plus any model-scoped caps. A window is `None` when the endpoint did not report it.
+/// `Deserialize` so it can ride the Codex `session_codex_plan_usage` event (the event bus
+/// round-trips its payload) — the Codex backend reuses this exact shape for its rate-limit push.
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
 pub struct PlanUsage {
     pub five_hour: Option<UsageWindow>,
     pub seven_day: Option<UsageWindow>,
+    /// Caps that apply to ONE model rather than the whole account (e.g. Fable's weekly
+    /// allowance), read from the `limits[]` array — the only place they appear. Empty when
+    /// the plan has none. `serde(default)` so an older/foreign payload (a Codex push, which
+    /// has no such concept) still deserializes.
+    #[serde(default)]
+    pub scoped: Vec<ScopedUsageWindow>,
+}
+
+/// A rate-limit window that applies to a NAMED subset of usage (today: a single model) rather
+/// than the account as a whole. Kept separate from the two flat windows because its label is
+/// data-driven — it comes from the payload, so a renamed or newly added scoped model shows up
+/// without a code change.
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ScopedUsageWindow {
+    /// What the cap is scoped to, as the endpoint names it (`scope.model.display_name`,
+    /// e.g. `"Fable"`). Displayed verbatim.
+    pub label: String,
+    /// Which family the cap belongs to (`"weekly"`, `"session"`, …), so the UI can suffix it
+    /// with the matching window ("7d" / "5h"). `None` when the payload omits it — the UI then
+    /// shows the bare label rather than guessing a duration.
+    pub group: Option<String>,
+    pub window: UsageWindow,
 }
 
 /// One rate-limit window's real fill: `used_percentage` (0–100) + optional reset as a
@@ -377,21 +409,73 @@ fn parse_usage(body: &str) -> Option<PlanUsage> {
         .unwrap_or(&v);
     let five_hour = parse_window(root.get("five_hour"));
     let seven_day = parse_window(root.get("seven_day"));
-    if five_hour.is_none() && seven_day.is_none() {
+    // `limits[]` sits at the ROOT even under the legacy wrapper, so look there too.
+    let scoped = parse_scoped_limits(root.get("limits").or_else(|| v.get("limits")));
+    if five_hour.is_none() && seven_day.is_none() && scoped.is_empty() {
         return None;
     }
     Some(PlanUsage {
         five_hour,
         seven_day,
+        scoped,
     })
 }
 
+/// Pull the model-scoped caps out of the `limits[]` array — the ONLY place they appear (their
+/// would-be top-level keys are all null; see the module doc's "Model-scoped caps").
+///
+/// An entry qualifies on the PRESENCE of a `scope` object naming something, never on
+/// `is_active` (that flag only marks which cap is currently binding). Entries whose `kind` is
+/// one of the two account-wide caps are skipped even if they ever gained a scope, since those
+/// are already rendered from their top-level windows — this is what keeps a cap from being
+/// listed twice. An entry with no usable name or no percentage is dropped rather than shown as
+/// an anonymous "0%" row that the user could not act on.
+fn parse_scoped_limits(v: Option<&Value>) -> Vec<ScopedUsageWindow> {
+    let Some(Value::Array(entries)) = v else {
+        return Vec::new();
+    };
+    entries
+        .iter()
+        .filter(|e| {
+            !matches!(
+                e.get("kind").and_then(Value::as_str),
+                Some("session") | Some("weekly_all")
+            )
+        })
+        .filter_map(|e| {
+            let label = scope_label(e.get("scope"))?;
+            Some(ScopedUsageWindow {
+                label,
+                group: e
+                    .get("group")
+                    .and_then(Value::as_str)
+                    .map(str::to_string),
+                window: parse_window(Some(e))?,
+            })
+        })
+        .collect()
+}
+
+/// Name a `scope` object: the model's display name, else the surface it applies to. `None`
+/// when the scope is absent/null or names nothing — an unnamed cap can't be labeled truthfully.
+fn scope_label(scope: Option<&Value>) -> Option<String> {
+    let scope = scope?;
+    scope
+        .pointer("/model/display_name")
+        .and_then(Value::as_str)
+        .or_else(|| scope.get("surface").and_then(Value::as_str))
+        .map(str::to_string)
+}
+
 /// One window's `{ utilization, resets_at }` → our `{ used_percentage, resets_at }`.
 /// On `/api/oauth/usage`, `utilization` is ALREADY a percentage 0–100 (verified against
 /// the live response, e.g. `29.0` = 29%), so we use it as-is (an explicit
-/// `used_percentage`, if ever present, is equivalent). `resets_at` is passed through as
-/// a raw string (ISO 8601, or epoch-seconds digits) for the frontend to parse. `None`
-/// when no percentage field is present (an unusable window). The UI clamps 0–100.
+/// `used_percentage`, if ever present, is equivalent). `percent` is the same figure under the
+/// name the `limits[]` entries use (an integer), so scoped caps parse through here too.
+/// `resets_at` is passed through as a raw string (ISO 8601, or epoch-seconds digits) for the
+/// frontend to parse — it is legitimately absent on a window that has never started, which
+/// only costs that row its reset text. `None` when no percentage field is present (an
+/// unusable window). The UI clamps 0–100.
 fn parse_window(v: Option<&Value>) -> Option<UsageWindow> {
     let v = v?;
     if v.is_null() {
@@ -400,6 +484,7 @@ fn parse_window(v: Option<&Value>) -> Option<UsageWindow> {
     let used_percentage = v
         .get("used_percentage")
         .or_else(|| v.get("utilization"))
+        .or_else(|| v.get("percent"))
         .and_then(Value::as_f64)?;
     let resets_at = v
         .get("resets_at")
@@ -506,9 +591,89 @@ mod tests {
             let u = parse_usage(&body).expect("both windows usable");
             assert_eq!(u.five_hour.expect("5h shown").used_percentage, 2.0);
             assert_eq!(u.seven_day.expect("7d shown").used_percentage, 3.0);
+            // The `weekly_scoped` entry here names nothing (no `scope`) and carries no
+            // percentage — it must be dropped, not surfaced as an anonymous 0% row.
+            assert!(u.scoped.is_empty(), "unnamed scoped cap must not be listed");
+        }
+    }
+
+    #[test]
+    fn parses_model_scoped_weekly_cap_from_limits_array() {
+        // Captured from the LIVE response (2026-07-22). The model-scoped cap has NO top-level
+        // key — every candidate is null — and appears ONLY in `limits[]`, with its percentage
+        // under `percent` and a null `resets_at`. Pins that real contract.
+        let body = r#"{
+            "five_hour":{"utilization":9.0,"resets_at":"2026-07-22T15:30:00.378696+00:00"},
+            "seven_day":{"utilization":13.0,"resets_at":"2026-07-27T10:00:00.378747+00:00"},
+            "seven_day_opus":null,"seven_day_sonnet":null,"seven_day_cowork":null,
+            "seven_day_omelette":null,"tangelo":null,"nimbus_quill":null,
+            "limits":[
+                {"kind":"session","group":"session","percent":9,"resets_at":"2026-07-22T15:30:00.378696+00:00","scope":null,"is_active":false},
+                {"kind":"weekly_all","group":"weekly","percent":13,"resets_at":"2026-07-27T10:00:00.378747+00:00","scope":null,"is_active":true},
+                {"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,
+                 "scope":{"model":{"id":null,"display_name":"Fable"},"surface":null},"is_active":false}
+            ]
+        }"#;
+        let u = parse_usage(body).expect("should parse");
+        assert_eq!(u.five_hour.expect("5h").used_percentage, 9.0);
+        assert_eq!(u.seven_day.expect("7d").used_percentage, 13.0);
+        // Exactly ONE scoped cap: the two account-wide entries are already rendered from
+        // their top-level windows and must not be duplicated out of `limits[]`.
+        assert_eq!(u.scoped.len(), 1, "only the model-scoped cap is taken from limits[]");
+        let s = &u.scoped[0];
+        assert_eq!(s.label, "Fable"); // read from scope.model.display_name, never hard-coded
+        assert_eq!(s.group.as_deref(), Some("weekly"));
+        assert_eq!(s.window.used_percentage, 0.0); // `percent`, not `utilization`
+        assert_eq!(s.window.resets_at, None); // never started → no reset invented
+    }
+
+    #[test]
+    fn scoped_cap_is_listed_even_when_not_the_binding_limit() {
+        // Same rule as the two flat windows: presence, not `is_active` (which marks only
+        // which single cap currently binds and flips over time).
+        for active in [true, false] {
+            let body = format!(
+                r#"{{"limits":[{{"kind":"weekly_scoped","group":"weekly","percent":42,
+                     "resets_at":"2026-07-27T10:00:00+00:00",
+                     "scope":{{"model":{{"display_name":"Fable"}}}},"is_active":{active}}}]}}"#
+            );
+            let u = parse_usage(&body).expect("a scoped cap alone is still usable usage");
+            assert!(u.five_hour.is_none() && u.seven_day.is_none());
+            assert_eq!(u.scoped.len(), 1);
+            assert_eq!(u.scoped[0].window.used_percentage, 42.0);
+            assert_eq!(
+                u.scoped[0].window.resets_at.as_deref(),
+                Some("2026-07-27T10:00:00+00:00")
+            );
         }
     }
 
+    #[test]
+    fn scoped_cap_falls_back_to_surface_and_drops_the_unusable() {
+        let body = r#"{
+            "five_hour":{"utilization":1.0},
+            "limits":[
+                {"kind":"weekly_scoped","group":"weekly","percent":5,"scope":{"surface":"Claude Code"}},
+                {"kind":"weekly_scoped","group":"weekly","scope":{"model":{"display_name":"NoPct"}}},
+                {"kind":"weekly_scoped","group":"weekly","percent":7,"scope":null}
+            ]
+        }"#;
+        let u = parse_usage(body).expect("should parse");
+        // Only the surface-named one survives: the second has no percentage, the third no name.
+        assert_eq!(u.scoped.len(), 1);
+        assert_eq!(u.scoped[0].label, "Claude Code");
+        assert_eq!(u.scoped[0].window.used_percentage, 5.0);
+    }
+
+    #[test]
+    fn a_malformed_limits_array_is_ignored_not_fatal() {
+        // A non-array (or absent) `limits` must not sink the two real windows.
+        let body = r#"{"five_hour":{"utilization":4.0},"seven_day":{"utilization":6.0},"limits":"nope"}"#;
+        let u = parse_usage(body).expect("windows still parse");
+        assert_eq!(u.five_hour.unwrap().used_percentage, 4.0);
+        assert!(u.scoped.is_empty());
+    }
+
     #[test]
     fn parse_credentials_reads_expiry_nested_and_flat() {
         let nested = r#"{"claudeAiOauth":{"accessToken":"a","expiresAt":1751000000000}}"#;
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index a90ad8e..bf4c002 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Flight Deck",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "identifier": "com.tosse.desktop",
   "build": {
     "beforeDevCommand": "pnpm dev",
diff --git a/src/features/conversation/ArtifactCard.tsx b/src/features/conversation/ArtifactCard.tsx
new file mode 100644
index 0000000..086eef6
--- /dev/null
+++ b/src/features/conversation/ArtifactCard.tsx
@@ -0,0 +1,104 @@
+// The inline card for ONE `Artifact` publish, rendered in the thread where Claude published
+// it (its own segment — never grouped into a run, never hidden by clean-output). Clicking it
+// routes through the shared `openArtifactView`: the in-app viewer when the local temp file is
+// still there, else the hosted page on claude.ai.
+//
+// Like WorkflowCard, it derives its link from the plain-text tool_result (the URL is only there,
+// not in the tool_use input). Until the result lands it shows a "Publishing…" pending state; if
+// the ack is ever reworded past the canonical URL shape it degrades to a non-clickable card
+// (no dead link) rather than guessing. The local file_path is only ever a RENDER source (it is an
+// ephemeral temp path that disappears); the durable, versioned copy is always the hosted URL.
+
+import type { JsonValue } from "../../ipc/client";
+import { field } from "../../agent/ask";
+import { resultText } from "../../agent/subagentMeta";
+import { useToolResult } from "../../store/conversationStore";
+import { Dot, Ico } from "../../ui/kit";
+import { artifactUrlFromResult } from "./artifacts";
+import { openArtifactView } from "./artifactOpen";
+import { basename } from "./toolMeta";
+
+export function ArtifactCard({
+  session,
+  toolUseId,
+  input,
+}: {
+  session: string;
+  toolUseId: string;
+  input: JsonValue;
+}) {
+  const result = useToolResult(session, toolUseId);
+  // NO backend guard on purpose. `Artifact` is a Claude-only tool today, but the card is
+  // backend-agnostic and DEGRADES instead of vanishing: the segment is only ever produced for a
+  // tool literally named `Artifact` carrying a `file_path` (see toolGroup.ts), and with no
+  // parseable URL the card simply renders non-clickable ("Unavailable") — never a dead link.
+  // An earlier `if (isCodex) return null` made the whole tool call DISAPPEAR from the thread,
+  // which is a silent drop: the user would see the model act with no trace of what it did.
+  const url = artifactUrlFromResult(result?.content);
+  const favicon = field(input, "favicon");
+  const label = field(input, "label")?.trim() || null;
+  const description = field(input, "description")?.trim() || null;
+  const filePath = field(input, "file_path") ?? "";
+  const base = basename(filePath).replace(/\.[^./]+$/, "");
+
+  // A failed/refused publish comes back is_error:true (with a human reason) and no URL. Surface
+  // it explicitly — NEVER let it read as the benign "reworded-ack" degrade (zero-silent-error).
+  const errored = !!result?.isError;
+  const reason = errored ? resultText(result?.content).trim() || "Publishing failed" : null;
+
+  // Headline = the most human descriptor available; sub = an "Artifact" eyebrow plus either the
+  // version label, the failure reason, or the publish status.
+  const headline = description || label || base || "Artifact";
+  const pending = !result;
+  const clickable = !!url && !errored;
+  const open = () =>
+    openArtifactView({
+      convId: session,
+      title: headline,
+      favicon: favicon ?? null,
+      url,
+      filePath: filePath || null,
+    });
+  const detail = errored
+    ? reason
+    : pending
+      ? "Publishing…"
+      : !url
+        ? "Unavailable"
+        : label && label !== headline
+          ? label
+          : null;
+
+  return (
+    <div
+      className="cv-art"
+      data-open={clickable || undefined}
+      data-state={errored ? "error" : undefined}
+      onClick={clickable ? open : undefined}
+      role={clickable ? "button" : undefined}
+      title={errored ? reason ?? undefined : clickable ? "Open artifact in Flight Deck" : undefined}
+    >
+      <span className="cv-art-tile" aria-hidden="true">
+        {favicon || "🎨"}
+      </span>
+      <span className="cv-art-body">
+        <span className="cv-art-title">{headline}</span>
+        <span className="cv-art-sub">
+          <span className="cv-art-kind">{errored ? "Artifact · failed" : "Artifact"}</span>
+          {detail ? <span className="cv-art-detail">{detail}</span> : null}
+        </span>
+      </span>
+      <span className="cv-art-go">
+        {errored ? (
+          <Ico name="alert" className="sm" />
+        ) : pending ? (
+          <Dot s="work" pulse />
+        ) : clickable ? (
+          <Ico name="external" className="sm" />
+        ) : (
+          <Dot s="off" />
+        )}
+      </span>
+    </div>
+  );
+}
diff --git a/src/features/conversation/ArtifactRefCard.tsx b/src/features/conversation/ArtifactRefCard.tsx
new file mode 100644
index 0000000..6a2235a
--- /dev/null
+++ b/src/features/conversation/ArtifactRefCard.tsx
@@ -0,0 +1,70 @@
+// A compact, pretty clickable card for an artifact LINK that Claude writes in its prose
+// (`[label](https://claude.ai/code/artifact/<uuid>)`) — rendered in place of a plain anchor by
+// StreamMarkdown's link renderer. When the artifact belongs to this conversation it is enriched
+// from the registry (favicon + title) and opens in the in-app viewer; otherwise it opens the
+// hosted page in the browser. Inline-block so it flows inside a paragraph.
+
+import type { KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, ReactNode } from "react";
+import { openUrl } from "@tauri-apps/plugin-opener";
+import { Ico } from "../../ui/kit";
+import { useArtifacts } from "./artifacts";
+import { openArtifactView } from "./artifactOpen";
+
+function childrenText(children: ReactNode): string {
+  if (typeof children === "string") return children;
+  if (typeof children === "number") return String(children);
+  if (Array.isArray(children)) return children.map(childrenText).join("");
+  return "";
+}
+
+export function ArtifactRefCard({
+  url,
+  convId,
+  children,
+}: {
+  url: string;
+  convId: string | null;
+  children?: ReactNode;
+}) {
+  // Enrich from the conversation's artifact registry when the link points at one of its own
+  // artifacts. An empty convId (off a FileMentionProvider) safely yields no matches.
+  const artifacts = useArtifacts(convId ?? "");
+  const match = artifacts.find((a) => a.url === url) ?? null;
+  const favicon = match?.favicon ?? null;
+  const label = childrenText(children).trim();
+  const title = match?.title || (label && label !== url ? label : "Artifact");
+  const filePath = match?.latestFilePath ?? null;
+
+  const activate = (e: ReactMouseEvent | ReactKeyboardEvent) => {
+    // Don't let the click bubble to the composer-focus / card-toggle handlers, and don't hijack a
+    // selection-ending click (the user copying the link text).
+    e.stopPropagation();
+    if (e.type === "click" && !window.getSelection()?.isCollapsed) return;
+    e.preventDefault();
+    if (convId && (filePath || url)) {
+      openArtifactView({ convId, title, favicon, url, filePath });
+    } else {
+      void openUrl(url);
+    }
+  };
+
+  return (
+    <span
+      className="cv-artref"
+      role="button"
+      tabIndex={0}
+      data-filelink=""
+      title={`Open artifact — ${title}`}
+      onClick={activate}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") activate(e);
+      }}
+    >
+      <span className="cv-artref-fav" aria-hidden="true">
+        {favicon || "🎨"}
+      </span>
+      <span className="cv-artref-t">{title}</span>
+      <Ico name="external" className="sm" />
+    </span>
+  );
+}
diff --git a/src/features/conversation/ArtifactViewer.tsx b/src/features/conversation/ArtifactViewer.tsx
new file mode 100644
index 0000000..05b8071
--- /dev/null
+++ b/src/features/conversation/ArtifactViewer.tsx
@@ -0,0 +1,203 @@
+// The side-region ARTIFACT VIEWER: reads an artifact's local file and renders it in place —
+// self-contained HTML in a sandboxed (null-origin) iframe under our own CSP, Markdown via the
+// thread renderer. The local file is an ephemeral temp path, so when it can't be rendered (gone,
+// too large, not text, unreadable) the viewer says WHICH of those happened and degrades to an
+// "Open on claude.ai" button (the durable hosted copy). READ-ONLY: it never writes anything, and
+// the iframe's scripts can reach neither the app nor the network.
+
+import { useEffect, useMemo, useState } from "react";
+import { openUrl } from "@tauri-apps/plugin-opener";
+import { commands } from "../../ipc/client";
+import { Ico } from "../../ui/kit";
+import type { ArtifactView } from "../editor/editorStore";
+import { withArtifactCsp } from "./artifactCsp";
+import { StreamMarkdown } from "./StreamMarkdown";
+
+/**
+ * Why the file can't be shown. These stay DISTINCT outcomes on purpose: they used to collapse
+ * into one vague "isn't available", which told the user nothing and (for a genuine read failure)
+ * swallowed the reason entirely. Each one gets its own honest message — zero silent error.
+ */
+type LoadFailure =
+  /** The artifact carries no local path at all — there is nothing to read. */
+  | { status: "nopath" }
+  /** `read_file` failed (file swept from /tmp, permissions, I/O). `reason` is surfaced verbatim. */
+  | { status: "unreadable"; reason: string }
+  /** Over `fs::MAX_FILE_BYTES` — the backend returns EMPTY content, so there is nothing to render. */
+  | { status: "tooLarge"; size: number }
+  /** A NUL byte was found → not text; `content` is empty and it can never render as HTML/Markdown. */
+  | { status: "binary" };
+
+type Load = { status: "loading" } | { status: "ready"; content: string } | LoadFailure;
+
+/** Human-readable byte size, for the "too large" message only. */
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/** What the user is told for each failure: what happened, and why when we know it. */
+function failureMessage(f: LoadFailure): { headline: string; detail: string | null } {
+  switch (f.status) {
+    case "nopath":
+      return {
+        headline: "The local copy of this artifact is gone.",
+        detail: "No local file was recorded for it (its temp file is ephemeral and doesn’t survive a reload).",
+      };
+    case "tooLarge":
+      return {
+        headline: "This artifact is too large to preview here.",
+        detail: `${formatBytes(f.size)} — over the app’s 16 MiB read limit.`,
+      };
+    case "binary":
+      return {
+        headline: "This artifact isn’t previewable text.",
+        detail: "Its file contains binary data, so it can’t be rendered as HTML or Markdown.",
+      };
+    case "unreadable":
+      return { headline: "This artifact’s local file couldn’t be read.", detail: f.reason };
+  }
+}
+
+/** The failure panel: the reason, plus the hosted copy as a way out whenever we know its URL. */
+function ArtifactUnavailable({
+  failure,
+  favicon,
+  url,
+}: {
+  failure: LoadFailure;
+  favicon: string | null;
+  url: string | null;
+}) {
+  const { headline, detail } = failureMessage(failure);
+  return (
+    <div className="cv-artview-msg">
+      <span className="cv-artview-fav cv-artview-msgfav" aria-hidden="true">
+        {favicon || "🎨"}
+      </span>
+      <p>{headline}</p>
+      {detail ? <p style={{ opacity: 0.75 }}>{detail}</p> : null}
+      {url ? (
+        <button type="button" className="cv-artview-open" onClick={() => void openUrl(url)}>
+          <Ico name="external" className="sm" /> Open on claude.ai
+        </button>
+      ) : (
+        <p style={{ opacity: 0.75 }}>No hosted link is known for it either.</p>
+      )}
+    </div>
+  );
+}
+
+export function ArtifactViewer({ view, onClose }: { view: ArtifactView; onClose: () => void }) {
+  const [load, setLoad] = useState<Load>({ status: "loading" });
+  const url = view.url;
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoad({ status: "loading" });
+    const path = view.filePath;
+    if (!path) {
+      setLoad({ status: "nopath" });
+      return;
+    }
+    commands
+      .readFile(path)
+      .then((res) => {
+        if (cancelled) return;
+        if (res.status !== "ok") {
+          // A failed read is a REAL failure (temp file swept, permissions, I/O): log it and show
+          // the underlying reason instead of a generic message that hides what went wrong.
+          console.error("ArtifactViewer: readFile failed for", path, "-", res.error);
+          setLoad({ status: "unreadable", reason: res.error });
+          return;
+        }
+        const f = res.data;
+        // `too_large` and `binary` both come back with EMPTY content — rendering that would show a
+        // blank frame and look like a bug, so each is reported as what it is.
+        if (f.too_large) setLoad({ status: "tooLarge", size: f.size });
+        else if (f.binary) setLoad({ status: "binary" });
+        else setLoad({ status: "ready", content: f.content });
+      })
+      .catch((e: unknown) => {
+        // The generated bindings RETHROW genuine `Error`s (only string command errors become error
+        // Results). Without this branch a transport failure would leave the viewer stuck on
+        // "Loading…" forever, with nothing in the console to explain it.
+        if (cancelled) return;
+        const reason = e instanceof Error ? e.message : String(e);
+        console.error("ArtifactViewer: readFile threw for", path, "-", reason);
+        setLoad({ status: "unreadable", reason });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [view.filePath]);
+
+  // Splice the CSP in ONCE per loaded document, not on every render: the artifact's HTML can be
+  // megabytes and this component re-renders on any layout change (a splitter drag re-renders
+  // MainArea), so doing it inline would re-scan + re-copy that string on every animation frame.
+  const frameHtml = useMemo(
+    () => (load.status === "ready" && view.kind === "html" ? withArtifactCsp(load.content) : null),
+    [load, view.kind],
+  );
+
+  return (
+    <div className="cv-artview">
+      <div className="cv-artview-h">
+        <span className="cv-artview-fav" aria-hidden="true">
+          {view.favicon || "🎨"}
+        </span>
+        <span className="cv-artview-title" title={view.title}>
+          {view.title}
+        </span>
+        {url ? (
+          <button
+            type="button"
+            className="cv-artview-btn"
+            title="Open on claude.ai"
+            aria-label="Open on claude.ai"
+            onClick={() => void openUrl(url)}
+          >
+            <Ico name="external" className="sm" />
+          </button>
+        ) : null}
+        <button type="button" className="cv-artview-btn" title="Close" aria-label="Close artifact viewer" onClick={onClose}>
+          <Ico name="x" className="sm" />
+        </button>
+      </div>
+      <div className="cv-artview-body">
+        {load.status === "loading" ? (
+          <div className="cv-artview-msg">Loading…</div>
+        ) : load.status === "ready" ? (
+          view.kind === "md" ? (
+            <div className="cv-artview-md">
+              <StreamMarkdown text={load.content} />
+            </div>
+          ) : (
+            <iframe
+              className="cv-artview-frame"
+              // Sandboxed to a NULL origin (NO allow-same-origin): the artifact's own scripts run
+              // but cannot reach the app / its storage. srcDoc renders the self-contained HTML.
+              //
+              // `allow-popups` is a DELIBERATE choice, not an oversight: an artifact may
+              // legitimately link out (a source, a doc), and a popup opened from a sandboxed frame
+              // INHERITS the sandbox — so the escape hatch it grants is a new null-origin window,
+              // not a privileged one.
+              //
+              // The sandbox alone gives isolation but NOT network restriction, and the app's own
+              // Tauri CSP is `null` — while on claude.ai the very same page runs behind a strict
+              // CSP blocking every external host. `withArtifactCsp` re-creates that guarantee
+              // inside the document, so an in-app preview is never more capable than the hosted
+              // page. See artifactCsp.ts.
+              sandbox="allow-scripts allow-popups"
+              srcDoc={frameHtml ?? ""}
+              title={view.title}
+            />
+          )
+        ) : (
+          <ArtifactUnavailable failure={load} favicon={view.favicon} url={url} />
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/features/conversation/ArtifactsChip.tsx b/src/features/conversation/ArtifactsChip.tsx
new file mode 100644
index 0000000..e04ff8d
--- /dev/null
+++ b/src/features/conversation/ArtifactsChip.tsx
@@ -0,0 +1,222 @@
+// The composer's "Artifacts (N)" chip: the always-reachable, per-conversation index of every
+// artifact Claude published in this conversation, grouped by artifact with its version history.
+// Click the chip → a portal popover (fixed-positioned under it, opening upward from the composer)
+// listing each artifact newest-first; click a row → open the hosted page on claude.ai.
+//
+// Rendered ONLY when the conversation has ≥1 artifact (Codex conversations never do — the
+// Artifact tool is Claude-only). READ-ONLY toward claude.ai — it only surfaces what was already
+// published; it never issues a publish/list call. The portal escapes the composer's overflow the
+// same way <BackgroundTaskBadge> does.
+
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { Dot, Ico } from "../../ui/kit";
+import { useArtifacts, type Artifact } from "./artifacts";
+import { openArtifactView } from "./artifactOpen";
+
+/** Fixed placement of the portaled popover, anchored to the chip. */
+interface ArtifactPopPos {
+  left: number;
+  top?: number;
+  bottom?: number;
+  maxHeight: number;
+}
+
+/** Popover width (kept in sync with `.cv-artpop { max-width }` in conductor-conversation.css) —
+ *  used to clamp the popover inside the viewport before it has been measured. */
+const POP_W = 320;
+
+/**
+ * Pure: where to put the popover given the chip's live rect. Extracted so the placement can be
+ * RE-RUN cheaply from a resize/scroll listener (see the effect below) instead of being frozen at
+ * click time — a frozen `position:fixed` popover visibly detaches from its chip as soon as the
+ * window resizes or an ancestor scrolls.
+ */
+function artifactPopPlacement(r: DOMRect): ArtifactPopPos {
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const left = Math.min(Math.max(8, r.left), vw - POP_W - 8);
+  const belowSpace = vh - r.bottom - 12;
+  const aboveSpace = r.top - 12;
+  // The chip lives in the composer near the bottom, so there is usually more room ABOVE:
+  // open upward unless below genuinely has more space.
+  if (belowSpace > aboveSpace && belowSpace >= 220) {
+    return { left, top: r.bottom + 6, maxHeight: belowSpace };
+  }
+  return { left, bottom: vh - r.top + 6, maxHeight: aboveSpace };
+}
+
+/** One artifact in the popover: its favicon + title + description + version count, opening the
+ *  artifact in the in-app viewer; its versions expand inline (informational — the wire exposes one
+ *  canonical URL, not a per-version link, so we never fabricate one). */
+function ArtifactRow({ art, session, onOpened }: { art: Artifact; session: string; onOpened: () => void }) {
+  const [showVersions, setShowVersions] = useState(false);
+  const url = art.url;
+  const vcount = art.versions.length;
+  const open = () => {
+    openArtifactView({
+      convId: session,
+      title: art.title,
+      favicon: art.favicon,
+      url,
+      filePath: art.latestFilePath,
+    });
+    onOpened();
+  };
+  return (
+    <div className="cv-artpop-item">
+      <div className="cv-artpop-head">
+        <button
+          type="button"
+          className="cv-artpop-open"
+          disabled={!url}
+          onClick={open}
+          title={url ? "Open in Flight Deck" : "Not published yet"}
+        >
+          <span className="cv-artpop-fav" aria-hidden="true">
+            {art.favicon || "🎨"}
+          </span>
+          <span className="cv-artpop-main">
+            <span className="cv-artpop-title">{art.title}</span>
+            {art.description ? <span className="cv-artpop-desc">{art.description}</span> : null}
+          </span>
+          {url ? <Ico name="external" className="sm" /> : <Dot s="off" />}
+        </button>
+        {vcount > 1 ? (
+          <button
+            type="button"
+            className="cv-artpop-vbtn"
+            onClick={() => setShowVersions((v) => !v)}
+            aria-expanded={showVersions}
+            title={showVersions ? "Hide versions" : "Show versions"}
+          >
+            <span className="wf-mono">v{vcount}</span>
+            <Ico name="chev" className="sm" />
+          </button>
+        ) : (
+          <span className="cv-artpop-v1 wf-mono">v1</span>
+        )}
+      </div>
+      {vcount > 1 && showVersions ? (
+        <div className="cv-artpop-versions">
+          {art.versions
+            .slice()
+            .reverse()
+            .map((v, i) => (
+              <div key={v.toolUseId} className="cv-artpop-vrow">
+                <span className="cv-artpop-vn wf-mono">v{vcount - i}</span>
+                <span className="cv-artpop-vlabel">{v.label ?? "—"}</span>
+              </div>
+            ))}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+// ⚠️ Do NOT migrate this popover to the shared <Menu portal> component, tempting as the overlap
+// looks: `Menu` closes on ANY click inside its popover (`onClick={() => setOpen(false)}` on the
+// popover root), which would make the per-artifact "vN" version-expand button close the popover
+// instead of expanding it. This one owns its own portal + placement precisely to keep clicks
+// inside it non-dismissing; only a row click (which navigates away) closes it.
+export function ArtifactsChip({ session }: { session: string }) {
+  const artifacts = useArtifacts(session);
+  const [open, setOpen] = useState(false);
+  const [pos, setPos] = useState<ArtifactPopPos | null>(null);
+  const btnRef = useRef<HTMLButtonElement>(null);
+
+  // Close on Escape while open. This popover owns Escape while open, so stopPropagation keeps an
+  // outer window-level modal (the Flight Deck reply modal) from also closing on the same keypress.
+  useEffect(() => {
+    if (!open) return;
+    function onKey(e: KeyboardEvent) {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        setOpen(false);
+      }
+    }
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [open]);
+
+  // Place the popover while open, and KEEP IT GLUED to the chip: the placement is `position:fixed`
+  // in a portal, so anything that moves the chip in viewport space (a window resize, an ancestor
+  // scrolling) leaves a stale popover floating away from its trigger. Same treatment as the shared
+  // <Menu portal>: measure on open, then re-measure on resize and on scroll in the CAPTURE phase
+  // (scroll doesn't bubble — a capture listener on `window` is the only way to see an inner
+  // scroller move). Layout effect so the first placement lands BEFORE paint (no flash at 0,0), and
+  // measuring is a single `getBoundingClientRect` + arithmetic, so the scroll path stays cheap.
+  useLayoutEffect(() => {
+    if (!open) {
+      setPos(null);
+      return;
+    }
+    const measure = () => {
+      const r = btnRef.current?.getBoundingClientRect();
+      if (r) setPos(artifactPopPlacement(r));
+    };
+    measure();
+    window.addEventListener("resize", measure);
+    window.addEventListener("scroll", measure, true);
+    return () => {
+      window.removeEventListener("resize", measure);
+      window.removeEventListener("scroll", measure, true);
+    };
+  }, [open]);
+
+  const n = artifacts.length;
+  if (n === 0) return null;
+
+  return (
+    <>
+      <button
+        ref={btnRef}
+        type="button"
+        className="wf-chip"
+        data-open={open || undefined}
+        onClick={() => setOpen((o) => !o)}
+        title={`${n} artifact${n === 1 ? "" : "s"} published in this conversation`}
+        aria-label="Artifacts"
+      >
+        <Ico name="artifact" className="sm" />
+        <span className="wf-mono">{n}</span>
+      </button>
+
+      {open && pos
+        ? createPortal(
+            <div className="cv-artpop-backdrop" onClick={() => setOpen(false)}>
+              <div
+                className="cv-artpop"
+                style={{
+                  position: "fixed",
+                  left: pos.left,
+                  top: pos.top,
+                  bottom: pos.bottom,
+                  maxHeight: pos.maxHeight,
+                }}
+                onClick={(e) => e.stopPropagation()}
+              >
+                <div className="cv-artpop-h">
+                  <Ico name="artifact" className="sm" />
+                  Artifacts
+                  <span className="cv-artpop-count wf-mono">{n}</span>
+                </div>
+                {artifacts
+                  .slice()
+                  .reverse()
+                  .map((a) => (
+                    <ArtifactRow
+                      key={a.url ?? a.latestFilePath}
+                      art={a}
+                      session={session}
+                      onOpened={() => setOpen(false)}
+                    />
+                  ))}
+              </div>
+            </div>,
+            document.body,
+          )
+        : null}
+    </>
+  );
+}
diff --git a/src/features/conversation/ConductorComposer.tsx b/src/features/conversation/ConductorComposer.tsx
index 5206181..852561b 100644
--- a/src/features/conversation/ConductorComposer.tsx
+++ b/src/features/conversation/ConductorComposer.tsx
@@ -50,6 +50,9 @@ import { useBackendUsage } from "./backendUsage";
 import { useUltraBlast } from "../../store/ultraBlast";
 import { EffortGauge, clampEffort, effortLevelsForModel, type EffortLevel } from "./EffortGauge";
 import { RemoteControlChip } from "./RemoteControlChip";
+import { ArtifactsChip } from "./ArtifactsChip";
+import { GoalChip } from "./GoalChip";
+import { isGoalCommand, markGoalSeen } from "../../store/goalStore";
 import {
   SlashCommandMenu,
   filterSlashCommands,
@@ -539,11 +542,22 @@ export const ConductorComposer = forwardRef<
     // message above." Holding it app-side until the turn ends would defeat that
     // mid-turn injection — the agent must see it in-flight, not only at the end.
     // Sending also (re)starts the stream lazily if the session is off/ended.
-    useConversationsStore.getState().noteFirstMessage(session, t);
+    // A `/goal` command (set / clear / status) is plumbing for the goal chip, not conversational
+    // content: send it SILENTLY (no optimistic bubble / title / summary), matching the reloaded
+    // thread which drops it as noise. `markGoalSeen` arms the turn-edge refetch so a freshly set
+    // goal appears without every goalless conversation paying a per-turn transcript read.
+    const goalCmd = isGoalCommand(t);
+    if (goalCmd) markGoalSeen(session);
+    // Same invariant for the optimistic PLACEHOLDER name — hence computed BEFORE this call: a
+    // fresh conversation whose first message is `/goal <condition>` must not end up named after
+    // that command in the sidebar and on its Flight Deck card. Goal plumbing is invisible
+    // everywhere else, so it must not name the conversation either; the conversation stays
+    // auto-title-eligible and gets named by the first REAL message instead.
+    if (!goalCmd) useConversationsStore.getState().noteFirstMessage(session, t);
     // The worktree toggle only applies to the very first spawn of a conversation.
     // `queued`: busy at send time → the CLI will inject this mid-turn, so the
     // bubble shows a "pending" badge until the turn ends.
-    send.mutate({ text: t, images, worktree: useWorktree && isFresh, queued: busy });
+    send.mutate({ text: t, images, worktree: useWorktree && isFresh, queued: busy, silent: goalCmd });
     // `/reload-skills` makes the CLI re-scan on-disk skills; mirror that in the
     // `/` menu by re-fetching this cwd's catalogue (a fresh spawn reads disk
     // afresh), overwriting the once-per-session cache. Fire-and-forget.
@@ -986,6 +1000,10 @@ export const ConductorComposer = forwardRef<
           </>
         )}
         <span style={{ marginLeft: "auto" }} />
+        {/* Artifacts index — every artifact Claude published in THIS conversation, with its
+            versions. Renders only when there is ≥1 (Codex conversations never yield any).
+            Read-only toward claude.ai (surfaces the transcript; never republishes). */}
+        <ArtifactsChip session={session} />
         {/* Extensions panel — what this conversation's Claude sees (MCP + live
             status, plugins, skills, sub-agents), like /mcp. Scans the session's
             current cwd so a worktree shows its own config. */}
@@ -1033,6 +1051,9 @@ export const ConductorComposer = forwardRef<
             `remoteControl/enable` (→ a device-pairing code). The chip adapts its active menu
             to the backend. */}
         <RemoteControlChip session={session} backend={backend} worktreeOnSpawn={useWorktree && isFresh} />
+        {/* Active `/goal` — a target button; click opens a popover with the condition + a clear
+            button. Renders nothing when no goal is active. Claude only (Codex has no `/goal`). */}
+        {!isCodex ? <GoalChip convId={session} /> : null}
         {/* Worktree checkbox — only before the session spawns (first message).
             Explicit empty/checked box so the on/off state is unambiguous. */}
         {isFresh ? (
diff --git a/src/features/conversation/ConductorConversation.tsx b/src/features/conversation/ConductorConversation.tsx
index 58d514a..17e1408 100644
--- a/src/features/conversation/ConductorConversation.tsx
+++ b/src/features/conversation/ConductorConversation.tsx
@@ -15,6 +15,7 @@ import { effectiveCwd } from "../git/worktree";
 import { Splitter } from "../editor/Splitter";
 import { clamp, useEditorLayout, useEditorStore } from "../editor/editorStore";
 import { SidePanel } from "./SidePanel";
+import { ArtifactViewer } from "./ArtifactViewer";
 import { ConversationPane } from "./ConversationPane";
 import { type ComposerHandle } from "./ConductorComposer";
 import { ConductorSidebar } from "./ConductorSidebar";
@@ -110,12 +111,16 @@ function MainArea({
 }) {
   const { open, terminalOpen, gitOpen, orientation, editorFraction } = useEditorLayout();
   const setEditorFraction = useEditorStore((s) => s.setEditorFraction);
+  const artifactView = useEditorStore((s) => s.artifactView);
+  const closeArtifact = useEditorStore((s) => s.closeArtifact);
   const liveState = useSessionState(conv.id);
   const cwd = effectiveCwd(conv, liveState);
   const areaRef = useRef<HTMLDivElement>(null);
   const sideBySide = orientation === "row";
-  // The editor/terminal side region shows when either is open.
-  const sideOpen = open || terminalOpen;
+  // The artifact viewer takes over the side region (for THIS conversation) while set; the side
+  // region otherwise shows when the editor or terminal is open.
+  const showArtifact = !!artifactView && artifactView.convId === conv.id;
+  const sideOpen = open || terminalOpen || showArtifact;
 
   // Git mode takes over the whole area with its own 2x2 workspace (conversation
   // minimized top-left, diff top-right, history + files strip at the bottom),
@@ -189,7 +194,11 @@ function MainArea({
               display: "flex",
             }}
           >
-            <SidePanel convId={conv.id} cwd={cwd} sideBySide={sideBySide} />
+            {showArtifact && artifactView ? (
+              <ArtifactViewer view={artifactView} onClose={closeArtifact} />
+            ) : (
+              <SidePanel convId={conv.id} cwd={cwd} sideBySide={sideBySide} />
+            )}
           </div>
         </>
       ) : null}
diff --git a/src/features/conversation/ConductorThread.tsx b/src/features/conversation/ConductorThread.tsx
index 6296ba4..5ac97f9 100644
--- a/src/features/conversation/ConductorThread.tsx
+++ b/src/features/conversation/ConductorThread.tsx
@@ -68,6 +68,7 @@ import { ErrorBlock, NoticeBlock } from "./noticeView";
 import { useShallow } from "zustand/react/shallow";
 import { LiveSubThread } from "./LiveSubThread";
 import { WorkflowCard } from "./WorkflowCard";
+import { ArtifactCard } from "./ArtifactCard";
 import { resolveTranscriptSource } from "./transcriptSource";
 import type { StickToBottom } from "./useStickToBottom";
 import styles from "./ConductorThread.module.css";
@@ -599,6 +600,16 @@ function renderSegments(
           input={seg.step.input}
         />
       );
+    if (seg.kind === "artifact")
+      // An `Artifact` publish renders as its own inline card, opening the hosted claude.ai page.
+      return (
+        <ArtifactCard
+          key={seg.key}
+          session={session}
+          toolUseId={seg.step.id}
+          input={seg.step.input}
+        />
+      );
     // A `run` of regular tools. The trailing run of the live turn renders EXPANDED so its
     // steps appear live (spinner → result), then collapses to its header on settle. Past
     // / non-trailing runs render collapsed. `active` gates the spinner so a resultless
@@ -627,7 +638,9 @@ const LIVE_WINDOW = 3;
  *  renders in clear between them, preserving chronology. The common (no-plan) case is byte-for-byte
  *  unchanged and keeps the round's single foldKey, so its remembered open/collapsed state stands. */
 function renderFoldedWork(session: string, folded: Segment[], roundKey: string): ReactNode {
-  if (!folded.some((s) => s.kind === "plan")) {
+  // A `plan` OR an `artifact` is a decision/deliverable that must never hide inside the fold,
+  // even when buried mid-round: split the fold at each so it renders in clear between work runs.
+  if (!folded.some((s) => s.kind === "plan" || s.kind === "artifact")) {
     return (
       <ClaudeWorkBlock count={countWorkSteps(folded)} foldConv={session} foldKey={roundKey}>
         {renderSegments(session, folded, false, -1)}
@@ -654,7 +667,7 @@ function renderFoldedWork(session: string, folded: Segment[], roundKey: string):
     chunk = [];
   };
   for (const seg of folded) {
-    if (seg.kind === "plan") {
+    if (seg.kind === "plan" || seg.kind === "artifact") {
       flush();
       out.push(...renderSegments(session, [seg], false, -1));
     } else {
diff --git a/src/features/conversation/FileMention.tsx b/src/features/conversation/FileMention.tsx
index 1501fde..5b2b30d 100644
--- a/src/features/conversation/FileMention.tsx
+++ b/src/features/conversation/FileMention.tsx
@@ -32,6 +32,8 @@ import {
   type FileMention,
 } from "./fileMentions";
 import { cachedStatus, ensureMentionChecked, subscribeMention } from "./mentionCache";
+import { ArtifactRefCard } from "./ArtifactRefCard";
+import { isArtifactUrl } from "./artifactOpen";
 import { useMarkdownDemo } from "./markdownMode";
 import { looksLikeFile, looksLikePath, segmentPath, type PathParts } from "./pathSegments";
 
@@ -311,6 +313,16 @@ export function MentionLink({
     () => routeMarkdownLink(href ?? "", { cwd: ctx?.cwd ?? "", inert: ctx?.hostInert ?? true }),
     [href, ctx?.cwd, ctx?.hostInert],
   );
+  // A hosted-artifact URL renders as a compact artifact card (opens the in-app viewer / browser),
+  // not a plain anchor — regardless of host, so it's recognisable everywhere Claude links one.
+  // Checked AFTER the hook above so hook order stays stable if a streaming href flips.
+  if (isArtifactUrl(href)) {
+    return (
+      <ArtifactRefCard url={href!} convId={ctx?.convId ?? null}>
+        {children}
+      </ArtifactRefCard>
+    );
+  }
   if (route.kind === "external") {
     return (
       <a href={href} target="_blank" rel="noopener noreferrer">
diff --git a/src/features/conversation/GoalChip.tsx b/src/features/conversation/GoalChip.tsx
new file mode 100644
index 0000000..16faf55
--- /dev/null
+++ b/src/features/conversation/GoalChip.tsx
@@ -0,0 +1,31 @@
+// The conversation composer's active-`/goal` button: a small target chip that, on click, opens a
+// popover with the full goal (Claude Code's native goal feature — Claude keeps working across turns
+// until a completion condition holds). Goals are often long, so the condition lives in the popover
+// (where it can wrap), NOT inline on the chip. Renders nothing when no goal is active. Goal state is
+// read from the transcript (disk-only — never on the live stream); see `goalStore`. The popover body
+// is shared verbatim with the Flight Deck card (see GoalPopover).
+
+import { ChipBtn, Menu } from "../../ui/kit";
+import { useActiveGoal } from "../../store/goalStore";
+import { GoalPopover } from "./GoalPopover";
+
+export function GoalChip({ convId }: { convId: string }) {
+  const goal = useActiveGoal(convId);
+  if (!goal) return null;
+  return (
+    <Menu
+      up
+      align="right"
+      trigger={
+        <ChipBtn
+          icon="target"
+          className="cv-goal-chip"
+          aria-label="Active goal — open to view"
+          title="Active goal"
+        />
+      }
+    >
+      <GoalPopover convId={convId} goal={goal} />
+    </Menu>
+  );
+}
diff --git a/src/features/conversation/GoalPopover.tsx b/src/features/conversation/GoalPopover.tsx
new file mode 100644
index 0000000..9f499d7
--- /dev/null
+++ b/src/features/conversation/GoalPopover.tsx
@@ -0,0 +1,38 @@
+// The shared body of the active-`/goal` popover — the ONE content rendered both by the composer's
+// GoalChip (conversation view) and the Flight Deck card's CardGoal, so the two surfaces show the
+// goal identically and can never drift. Header + full condition (wraps) + the evaluator's latest
+// reason + a clear button. Each surface wraps this in its own `Menu` (in-flow vs portaled).
+//
+// Clearing sends the native `/goal clear` SILENTLY (no user bubble — see `useClearGoal`), drops the
+// chip optimistically, and guards against a stale refetch flipping it back on (`beginGoalClearing`).
+
+import { Ico } from "../../ui/kit";
+import { useClearGoal } from "../../ipc/useCommands";
+import { beginGoalClearing, useGoalStore } from "../../store/goalStore";
+import type { GoalState } from "../../ipc/client";
+
+export function GoalPopover({ convId, goal }: { convId: string; goal: GoalState }) {
+  const clearGoal = useClearGoal(convId);
+  return (
+    <div className="cv-goal-pop">
+      <div className="wf-pop-h">Active goal</div>
+      <div className="cv-goal-pop-cond">{goal.condition}</div>
+      {goal.reason ? <div className="cv-goal-pop-reason">{goal.reason}</div> : null}
+      <button
+        type="button"
+        className="wf-pop-act"
+        onClick={() => {
+          // Optimistic + guarded: arm the clear guard (freezes the null while `/goal clear` is in
+          // flight, however long a cold `--resume` spawn takes), drop the chip now, then fire the
+          // silent clear. `useClearGoal` settles the guard on success and rolls back on failure.
+          beginGoalClearing(convId);
+          useGoalStore.getState().set(convId, null);
+          clearGoal.mutate();
+        }}
+      >
+        <Ico name="x" className="sm" />
+        Clear goal
+      </button>
+    </div>
+  );
+}
diff --git a/src/features/conversation/SubAgentTranscript.tsx b/src/features/conversation/SubAgentTranscript.tsx
index bb216cf..72389ee 100644
--- a/src/features/conversation/SubAgentTranscript.tsx
+++ b/src/features/conversation/SubAgentTranscript.tsx
@@ -44,7 +44,7 @@ function renderSegments(segments: Segment[], results: Map<string, JoinedResult>)
     // (no live card to drill into). These `.step` segments (vs the run branch's `.steps`) MUST
     // be handled here — otherwise they fall through to the run branch and crash. A sub-agent
     // proposing a plan is a non-case in practice, but the union requires the branch.
-    if (seg.kind === "agent" || seg.kind === "workflow" || seg.kind === "plan")
+    if (seg.kind === "agent" || seg.kind === "workflow" || seg.kind === "plan" || seg.kind === "artifact")
       return <StaticToolStep key={seg.key} step={seg.step} result={results.get(seg.step.id)} />;
     // A model-invoked slash-command: the same dedicated command chip as the live thread.
     if (seg.kind === "skill") return <SkillChip key={seg.key} input={seg.step.input} />;
diff --git a/src/features/conversation/artifactCsp.test.ts b/src/features/conversation/artifactCsp.test.ts
new file mode 100644
index 0000000..12e7abc
--- /dev/null
+++ b/src/features/conversation/artifactCsp.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+import { ARTIFACT_CSP, withArtifactCsp } from "./artifactCsp";
+
+/** Matches the injected element (attribute order/casing is fixed by the module). */
+const META_RE = /<meta http-equiv="Content-Security-Policy" content="[^"]+">/;
+
+/** Index of the injected meta, or -1. */
+const metaAt = (s: string) => s.search(META_RE);
+
+/** How many times the meta was injected (must always be exactly one). */
+const metaCount = (s: string) => s.split('http-equiv="Content-Security-Policy"').length - 1;
+
+describe("ARTIFACT_CSP", () => {
+  it("denies everything by default and re-allows only inline / data / blob", () => {
+    expect(ARTIFACT_CSP).toContain("default-src 'none'");
+    expect(ARTIFACT_CSP).toContain("script-src 'unsafe-inline'");
+    expect(ARTIFACT_CSP).toContain("style-src 'unsafe-inline'");
+    expect(ARTIFACT_CSP).toContain("img-src data: blob:");
+    expect(ARTIFACT_CSP).toContain("worker-src blob:");
+  });
+
+  it("blocks every network channel: no connections, no forms, no base rewrite", () => {
+    expect(ARTIFACT_CSP).toContain("connect-src 'none'");
+    expect(ARTIFACT_CSP).toContain("form-action 'none'");
+    expect(ARTIFACT_CSP).toContain("base-uri 'none'");
+  });
+
+  it("names no external origin at all (the guarantee we copy from claude.ai)", () => {
+    // A host or a network-capable scheme anywhere in the policy would silently re-open the door.
+    expect(ARTIFACT_CSP).not.toMatch(/https?:|wss?:|\*|\.com|\.ai\b/);
+  });
+
+  it("stays under the 1024-byte charset sniffing window", () => {
+    // The meta is spliced BEFORE a document's own <meta charset>; past 1024 bytes the browser
+    // would stop looking for it and guess the encoding.
+    expect(ARTIFACT_CSP.length).toBeLessThan(700);
+  });
+});
+
+describe("withArtifactCsp placement", () => {
+  it("inserts right after the doctype, AHEAD of the document's own head", () => {
+    const src = "<!doctype html><html><head><title>a</title></head><body>x</body></html>";
+    const out = withArtifactCsp(src);
+    expect(out.startsWith("<!doctype html>")).toBe(true);
+    expect(metaAt(out)).toBe("<!doctype html>".length);
+    // Ahead of <head> itself, i.e. ahead of ANY token the parser could fetch from.
+    expect(metaAt(out)).toBeLessThan(out.indexOf("<head>"));
+    expect(metaCount(out)).toBe(1);
+    expect(out.replace(META_RE, "")).toBe(src); // the artifact source is otherwise untouched
+  });
+
+  it("lands before a subresource the parser reaches BEFORE the explicit <head>", () => {
+    // A meta CSP only governs resources requested after it is parsed. Here the parser opens an
+    // IMPLIED head, fetches the script, then discards the explicit `<head>` token as a parse error
+    // — so anchoring on `<head>` would put the policy behind the very request it must block.
+    const out = withArtifactCsp(
+      '<!doctype html><script src="https://attacker.example/evil.js"></script><html><head></head></html>',
+    );
+    expect(metaAt(out)).toBeLessThan(out.indexOf("<script"));
+    expect(metaCount(out)).toBe(1);
+  });
+
+  it("ignores a <head that is not markup: inside a JS template literal", () => {
+    // The Artifact tool tells the model to omit doctype/html/head, so a file is usually a FRAGMENT
+    // — commonly one with an "export as HTML" button holding a whole document in a string. A
+    // textual match there would emit the meta as inert characters (⇒ NO policy at all) and corrupt
+    // the artifact's own code.
+    const src = "<h1>Report</h1><script>const doc = `<!doctype html><html><head><meta charset=\"utf-8\">`;</script>";
+    const out = withArtifactCsp(src);
+    expect(metaAt(out)).toBe(0);
+    expect(out.replace(META_RE, "")).toBe(src); // artifact source byte-identical, code intact
+    expect(metaCount(out)).toBe(1);
+  });
+
+  it("ignores a <head that is not markup: inside an HTML comment", () => {
+    const src = "<!-- old layout: <head><title>x</title></head> --><p>body</p>";
+    const out = withArtifactCsp(src);
+    expect(metaAt(out)).toBe(0);
+    expect(out.replace(META_RE, "")).toBe(src);
+  });
+
+  it("still injects ahead of everything on uppercase markup", () => {
+    const upper = withArtifactCsp("<!DOCTYPE HTML><HTML><HEAD><TITLE>a</TITLE></HEAD></HTML>");
+    expect(upper.startsWith("<!DOCTYPE HTML>")).toBe(true);
+    expect(metaAt(upper)).toBe("<!DOCTYPE HTML>".length);
+    expect(upper).toContain("<HTML><HEAD><TITLE>a</TITLE></HEAD></HTML>");
+  });
+
+  it("keeps the doctype first when a licence comment precedes it", () => {
+    // A leading comment run is still "first" to the parser, so the doctype after it is honoured —
+    // splicing at index 0 would push it out of first position ⇒ quirks mode.
+    const out = withArtifactCsp("<!-- (c) me -->\n<!doctype html><html><body>x</body></html>");
+    expect(metaAt(out)).toBe("<!-- (c) me -->\n<!doctype html>".length);
+    expect(out.startsWith("<!-- (c) me -->\n<!doctype html>")).toBe(true);
+  });
+
+  it("inserts after a leading doctype when there is no html tag", () => {
+    const out = withArtifactCsp("<!doctype html>\n<p>bare</p>");
+    // THE regression this guards: the doctype must still be the very first thing in the
+    // document, else the browser drops into quirks mode and the artifact's layout shifts.
+    expect(out.startsWith("<!doctype html>")).toBe(true);
+    expect(metaAt(out)).toBe("<!doctype html>".length);
+    expect(out).toContain("<p>bare</p>");
+  });
+
+  it("tolerates whitespace before the doctype", () => {
+    const out = withArtifactCsp("\n  <!doctype html>\n<p>x</p>");
+    expect(out.indexOf("<!doctype html>")).toBeLessThan(metaAt(out));
+    expect(metaAt(out)).toBe("\n  <!doctype html>".length);
+  });
+
+  it("prepends on a bare fragment (nothing to displace)", () => {
+    const out = withArtifactCsp("<p>fragment</p>");
+    expect(metaAt(out)).toBe(0);
+    expect(out.endsWith("<p>fragment</p>")).toBe(true);
+  });
+
+  it("prepends on an empty document", () => {
+    expect(metaAt(withArtifactCsp(""))).toBe(0);
+  });
+
+  it("leaves a document's own CSP meta in place (policies intersect, they don't override)", () => {
+    const out = withArtifactCsp(
+      '<!doctype html><html><head><meta http-equiv="Content-Security-Policy" content="default-src *"></head></html>',
+    );
+    expect(metaCount(out)).toBe(2);
+    // Ours comes first, so it is applied whatever the document declares afterwards.
+    expect(out.indexOf(ARTIFACT_CSP)).toBeLessThan(out.indexOf("default-src *"));
+  });
+});
diff --git a/src/features/conversation/artifactCsp.ts b/src/features/conversation/artifactCsp.ts
new file mode 100644
index 0000000..5900a4b
--- /dev/null
+++ b/src/features/conversation/artifactCsp.ts
@@ -0,0 +1,113 @@
+// The Content-Security-Policy we inject into an artifact's HTML before rendering it in the
+// side-region preview iframe.
+//
+// WHY THIS EXISTS: on claude.ai an artifact page is served behind a STRICT CSP that blocks every
+// external host — no CDN script, no remote font, no image from another origin, no fetch / XHR /
+// WebSocket. That policy is a large part of why opening an artifact is safe at all. In-app we
+// have NEITHER half of that guarantee for free:
+//   - the app's own Tauri CSP is `null` (`tauri.conf.json` `security.csp`), so nothing is
+//     restricted at the webview level;
+//   - the iframe's `sandbox` (no `allow-same-origin`) only gives the document a NULL ORIGIN. That
+//     isolates the artifact from the app and its storage, but a null origin can still open
+//     sockets, fetch remote URLs and load remote subresources.
+// Without this policy, previewing an artifact inside Flight Deck would be strictly MORE
+// permissive than opening the exact same page on claude.ai — an artifact could quietly phone
+// home (or exfiltrate its own contents) from within our window. So we re-create the guarantee
+// locally, in the document itself, since we cannot set response headers on a `srcDoc` document.
+
+/**
+ * The policy. `default-src 'none'` denies everything, then each directive re-allows exactly what a
+ * SELF-CONTAINED artifact legitimately needs: inline code/style and `data:`/`blob:` payloads it
+ * carries or builds itself. No directive ever names a host or scheme that can reach the network,
+ * so every external origin is refused by construction — adding one is the one edit that would
+ * break the guarantee.
+ */
+export const ARTIFACT_CSP = [
+  // Deny by default. Anything not re-allowed below (external scripts/styles/frames/objects,
+  // `<object>`/`<embed>`, nested browsing contexts, manifests…) is blocked.
+  "default-src 'none'",
+  // Artifacts are single self-contained documents: an inline `<script>` is the norm, and some
+  // embed a template/bundler shim that needs `eval`. `blob:` covers scripts a page builds for
+  // itself at runtime. No host source is listed ⇒ no external script can ever load.
+  "script-src 'unsafe-inline' 'unsafe-eval' blob:",
+  // Inline `<style>` blocks AND `style=""` attributes (both are covered by 'unsafe-inline').
+  "style-src 'unsafe-inline'",
+  // Embedded assets only: an artifact inlines its images/fonts/media as data URIs (or generates
+  // them as blobs, e.g. a canvas export). A remote URL is refused.
+  "img-src data: blob:",
+  "font-src data: blob:",
+  "media-src data: blob:",
+  // Workers are legitimate (an artifact may offload work), but only from its own blob.
+  "worker-src blob:",
+  // The whole point: NO network. Blocks fetch/XHR/WebSocket/EventSource/sendBeacon outright —
+  // this is what makes an in-app preview no more capable than the hosted page.
+  "connect-src 'none'",
+  // A form POST is an exfiltration channel CSP treats separately from `connect-src`.
+  "form-action 'none'",
+  // `<base href>` would silently re-point every relative URL in the document; deny it so the
+  // directives above can't be routed around.
+  "base-uri 'none'",
+].join("; ");
+
+/** The element we splice in. Kept short: it sits before any `<meta charset>` the document
+ *  declares, and the charset sniffing window is the first 1024 bytes — this is ~350. */
+const CSP_META = `<meta http-equiv="Content-Security-Policy" content="${ARTIFACT_CSP}">`;
+
+// Anchored: only a doctype that is ALREADY first counts. A leading run of whitespace or comments
+// (a licence header) is still "first" to the parser, so it is skipped too — the insertion point
+// lands right AFTER the doctype, never before it (see the quirks-mode warning below).
+// ⚠️ Every piece is UNAMBIGUOUS on purpose: ONE whitespace char per iteration (not `\s+` nested in
+// a `*`) and a comment body that can only end at its FIRST `-->` (not a lazy `[\s\S]*?`). Both
+// "obvious" spellings nest a quantifier inside a quantifier, so a crafted artifact — a long run of
+// comments with no doctype after them — would backtrack exponentially on every single render.
+const LEADING_DOCTYPE_RE = /^(?:\s|<!--(?:[^-]|-(?!->))*-->)*<!doctype\b[^>]*>/i;
+
+function spliceAt(html: string, index: number, insert: string): string {
+  return html.slice(0, index) + insert + html.slice(index);
+}
+
+/**
+ * Return `html` with the artifact CSP meta injected ahead of every token but the doctype.
+ *
+ * ⚠️ WE NEVER SEARCH THE STRING FOR `<head>` OR `<html>` — do not "improve" this by preferring the
+ * document's own head. Two independent reasons, both VERIFIED in a `srcDoc` iframe carrying the
+ * viewer's exact `sandbox`:
+ *
+ *  1. A regex cannot tell real markup from a `<head` that merely OCCURS in the text — and an
+ *     artifact file is very often a FRAGMENT (the Artifact tool tells the model to omit
+ *     doctype/html/head; the skeleton is added at publish time). A common fragment shape is an
+ *     "export as HTML" button holding a whole document in a JS template literal, whose `<head` wins
+ *     the race. Splicing there emits the meta as inert characters: the document then parses with
+ *     ZERO policy elements and issues its network requests with no violation logged — silently,
+ *     exactly the capability this module exists to remove — while the artifact's own code is
+ *     corrupted (inside a double-quoted JS string our `content="` closes the literal ⇒ SyntaxError).
+ *
+ *  2. Even on REAL markup, a tag's position in the SOURCE is not where the parser's head BEGINS. In
+ *     `<!doctype html><script src=…></script><html><head>…` the script is reached in "before html":
+ *     the parser opens an implied `<html>` then an implied `<head>`, FETCHES the script, and only
+ *     then discards the explicit `<head>` token as a parse error. A meta spliced after that ignored
+ *     token lands BEHIND the request it was meant to block — and a meta CSP only governs resources
+ *     requested after it is parsed, so the remote script loads unrestricted while the rest of the
+ *     page is policed, which makes the hole look like the policy is working.
+ *
+ * The earliest position is always legal, so that is simply where it goes: a `<meta>` ahead of
+ * `<html>` is adopted by the parser's IMPLIED head (it becomes head's first child), and a later
+ * `<html lang=…>` start tag merges its attributes onto the element already open — nothing is
+ * displaced, nothing is lost, no wrapper of our own is needed.
+ *
+ * ⚠️ Equally, do not "simplify" this to a bare prepend: a doctype that is not first is IGNORED and
+ * the artifact silently drops into QUIRKS MODE (box model, line height, table sizing shift under
+ * the user, with no error anywhere). Right after a leading doctype is the one position that
+ * satisfies both constraints. A `srcDoc` document is standards-mode regardless, but the invariant
+ * costs one anchored regex and survives any reuse of this helper outside the iframe.
+ *
+ * Pure and O(1)-ish: no DOM, no I/O, ONE anchored probe — never a scan of a possibly multi-MB
+ * document, and it runs on every artifact render.
+ *
+ * NOTE: a document that ships its OWN CSP meta does not weaken ours — multiple policies all
+ * apply, and a resource must satisfy every one of them.
+ */
+export function withArtifactCsp(html: string): string {
+  const doctype = LEADING_DOCTYPE_RE.exec(html);
+  return spliceAt(html, doctype ? doctype[0].length : 0, CSP_META);
+}
diff --git a/src/features/conversation/artifactOpen.test.ts b/src/features/conversation/artifactOpen.test.ts
new file mode 100644
index 0000000..1690adb
--- /dev/null
+++ b/src/features/conversation/artifactOpen.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { artifactKind, isArtifactUrl } from "./artifactOpen";
+
+describe("isArtifactUrl", () => {
+  it("matches a canonical hosted-artifact URL", () => {
+    expect(isArtifactUrl("https://claude.ai/code/artifact/acecfb35-f63b-49c3-b835-d0c856695a94")).toBe(true);
+  });
+
+  it("rejects other claude.ai URLs and non-artifact links", () => {
+    expect(isArtifactUrl("https://claude.ai/code/artifacts")).toBe(false); // the gallery, not one artifact
+    expect(isArtifactUrl("https://claude.ai/code/session_01ABC")).toBe(false);
+    expect(isArtifactUrl("https://example.com/x")).toBe(false);
+    expect(isArtifactUrl("/abs/path.html")).toBe(false);
+    expect(isArtifactUrl(undefined)).toBe(false);
+    expect(isArtifactUrl(null)).toBe(false);
+  });
+
+  it("is anchored — must START with the artifact URL, not merely contain it", () => {
+    expect(isArtifactUrl("see https://claude.ai/code/artifact/abc")).toBe(false);
+  });
+});
+
+describe("artifactKind", () => {
+  it("md for .md/.markdown, html otherwise", () => {
+    expect(artifactKind("/tmp/x.md")).toBe("md");
+    expect(artifactKind("/tmp/x.MARKDOWN")).toBe("md");
+    expect(artifactKind("/tmp/x.html")).toBe("html");
+    expect(artifactKind("/tmp/x")).toBe("html");
+    expect(artifactKind(null)).toBe("html");
+  });
+});
diff --git a/src/features/conversation/artifactOpen.ts b/src/features/conversation/artifactOpen.ts
new file mode 100644
index 0000000..a39b274
--- /dev/null
+++ b/src/features/conversation/artifactOpen.ts
@@ -0,0 +1,69 @@
+// Shared "open this artifact" action, used by every artifact surface (the inline card, the
+// composer chip rows, and the prose link card). It routes to the IN-APP viewer when a local
+// file is available to render, and falls back to opening the hosted claude.ai page in the
+// browser otherwise (e.g. a link to an artifact from another conversation, or after a reload
+// once the ephemeral temp file is gone and we only have the URL).
+
+import { openUrl } from "@tauri-apps/plugin-opener";
+import { useEditorStore } from "../editor/editorStore";
+import { ARTIFACT_URL_RE } from "./artifacts";
+
+/**
+ * {@link ARTIFACT_URL_RE} anchored at the start, compiled ONCE at module load.
+ *
+ * ⚠️ HOT PATH: `isArtifactUrl` runs for EVERY markdown link StreamMarkdown renders in a thread
+ * (see MentionLink), so building a fresh `RegExp` per call would allocate + recompile a pattern
+ * on a render path that can fire hundreds of times per streamed turn. Hoisted, not inlined.
+ *
+ * ⚠️ Deliberate asymmetry: this anchored form is case-INSENSITIVE while `ARTIFACT_URL_RE` (which
+ * parses the publish tool_result) is case-SENSITIVE. They read from opposite sides of the trust
+ * boundary: the tool_result is text the CLI itself emits in one exact canonical shape, so the
+ * parse stays strict (a lookalike in surrounding prose must not be mistaken for the ack's URL);
+ * an href, on the other hand, is prose the model (or the user) typed, where scheme/host casing
+ * legitimately drifts (`HTTPS://Claude.ai/…` is the SAME resource per RFC 3986). A false negative
+ * here silently downgrades a real artifact link to a plain anchor, so recognition is tolerant.
+ * The tolerance is safe downstream: a case-drifted URL simply fails the exact `a.url === url`
+ * lookup in ArtifactRefCard and degrades to opening the hosted page in the browser.
+ *
+ * No `g` flag — a shared `/g/` regex carries `lastIndex` between `.test()` calls and would
+ * alternate true/false on the same input. Keep it stateless.
+ */
+const ARTIFACT_URL_ANCHORED_RE = new RegExp(`^${ARTIFACT_URL_RE.source}`, "i");
+
+/** True when `href` is a canonical hosted-artifact URL (anchored at the start). */
+export function isArtifactUrl(href: string | undefined | null): boolean {
+  return !!href && ARTIFACT_URL_ANCHORED_RE.test(href);
+}
+
+/** An artifact renders as Markdown when its file is `.md`/`.markdown`, else as HTML. */
+export function artifactKind(filePath: string | null): "html" | "md" {
+  return filePath && /\.(md|markdown)$/i.test(filePath) ? "md" : "html";
+}
+
+export interface ArtifactOpenMeta {
+  convId: string;
+  title: string;
+  favicon: string | null;
+  url: string | null;
+  /** Local temp file to render in the viewer, or null. */
+  filePath: string | null;
+}
+
+/**
+ * Open an artifact: render it in the side-region viewer when we have a local file, else open the
+ * hosted page in the browser. When neither is available it is a no-op (nothing to show).
+ */
+export function openArtifactView(meta: ArtifactOpenMeta): void {
+  if (meta.filePath) {
+    useEditorStore.getState().openArtifact({
+      convId: meta.convId,
+      title: meta.title,
+      favicon: meta.favicon,
+      url: meta.url,
+      filePath: meta.filePath,
+      kind: artifactKind(meta.filePath),
+    });
+  } else if (meta.url) {
+    void openUrl(meta.url);
+  }
+}
diff --git a/src/features/conversation/artifacts.test.ts b/src/features/conversation/artifacts.test.ts
new file mode 100644
index 0000000..871f2cb
--- /dev/null
+++ b/src/features/conversation/artifacts.test.ts
@@ -0,0 +1,277 @@
+import { describe, expect, it } from "vitest";
+import type { JsonValue, NormalizedBlock } from "../../ipc/client";
+import type { SessionEntry } from "../../store/types";
+import {
+  artifactUrlFromResult,
+  clearAllArtifactsCache,
+  clearArtifactsCache,
+  memoizedArtifacts,
+  selectArtifacts,
+} from "./artifacts";
+
+const URL_A = "https://claude.ai/code/artifact/acecfb35-f63b-49c3-b835-d0c856695a94";
+const URL_B = "https://claude.ai/code/artifact/cfabdbd7-3294-4092-9927-80c6e795f0d2";
+
+// Verbatim shapes captured from real transcripts (long form 2.1.204+, short form 2.1.201/2).
+const LONG = (path: string, url: string) =>
+  `Published ${path} at ${url}\n\nTo update: republish the same file path in this conversation (keeps this URL), or pass the URL as \`url\` from any other conversation — a conversation that didn't publish this artifact otherwise mints a new URL. Artifacts are private unless shared from the page's share menu.`;
+const SHORT = (path: string, url: string) => `Published ${path} at ${url}`;
+
+function tuse(id: string, input: Record<string, unknown>, name = "Artifact"): NormalizedBlock {
+  return { type: "tool_use", id, name, input } as unknown as NormalizedBlock;
+}
+
+/** Build a minimal SessionEntry with just the fields selectArtifacts reads. `errored` lists the
+ *  tool_use ids whose result should carry is_error:true. */
+function entryOf(
+  turns: Array<{ id: string; role?: "assistant" | "user"; parent?: string | null; blocks: NormalizedBlock[] }>,
+  results: Record<string, JsonValue> = {},
+  errored: string[] = [],
+): SessionEntry {
+  const turnMap: Record<string, unknown> = {};
+  const timeline: Array<{ kind: "turn"; id: string }> = [];
+  for (const t of turns) {
+    turnMap[t.id] = {
+      id: t.id,
+      role: t.role ?? "assistant",
+      status: "final",
+      streamingText: "",
+      streamingThinking: "",
+      blocks: t.blocks,
+      parentToolUseId: t.parent ?? null,
+      hasThinking: false,
+    };
+    timeline.push({ kind: "turn", id: t.id });
+  }
+  const errSet = new Set(errored);
+  const toolResults: Record<string, unknown> = {};
+  for (const [id, content] of Object.entries(results)) {
+    toolResults[id] = { toolUseId: id, content, isError: errSet.has(id), parentToolUseId: null };
+  }
+  return { timeline, turns: turnMap, toolResults } as unknown as SessionEntry;
+}
+
+describe("artifactUrlFromResult", () => {
+  it("parses the URL from the long publish ack", () => {
+    expect(artifactUrlFromResult(LONG("/tmp/x.html", URL_A))).toBe(URL_A);
+  });
+  it("parses the URL from the short publish ack", () => {
+    expect(artifactUrlFromResult(SHORT("/tmp/x.html", URL_A))).toBe(URL_A);
+  });
+  it("handles the array content shape ({text})", () => {
+    expect(artifactUrlFromResult([{ type: "text", text: SHORT("/tmp/x.html", URL_B) }] as unknown as JsonValue)).toBe(URL_B);
+  });
+  it("returns null on empty / missing / non-canonical text (degrade, no dead link)", () => {
+    expect(artifactUrlFromResult(undefined)).toBeNull();
+    expect(artifactUrlFromResult("")).toBeNull();
+    expect(artifactUrlFromResult("something else entirely")).toBeNull();
+  });
+});
+
+describe("selectArtifacts", () => {
+  it("returns [] for an empty/undefined entry", () => {
+    expect(selectArtifacts(undefined)).toEqual([]);
+    expect(selectArtifacts(entryOf([]))).toEqual([]);
+  });
+
+  it("maps one publish → one artifact with url/title/favicon/description", () => {
+    const e = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/audit.html", description: "Audit", favicon: "🛫", label: "audit-v1" })] }],
+      { u1: SHORT("/tmp/audit.html", URL_A) },
+    );
+    const arts = selectArtifacts(e);
+    expect(arts).toHaveLength(1);
+    expect(arts[0]).toMatchObject({ url: URL_A, favicon: "🛫", description: "Audit", title: "audit-v1", latestFilePath: "/tmp/audit.html" });
+    expect(arts[0].versions).toHaveLength(1);
+  });
+
+  it("groups republishes of the same file_path into ONE artifact with N versions (same URL)", () => {
+    const e = entryOf(
+      [
+        { id: "t1", blocks: [tuse("u1", { file_path: "/tmp/f.html", label: "v1", favicon: "🍽️" })] },
+        { id: "t2", blocks: [tuse("u2", { file_path: "/tmp/f.html", label: "v2", favicon: "🥗", description: "newer" })] },
+      ],
+      { u1: SHORT("/tmp/f.html", URL_A), u2: SHORT("/tmp/f.html", URL_A) },
+    );
+    const arts = selectArtifacts(e);
+    expect(arts).toHaveLength(1);
+    expect(arts[0].versions).toHaveLength(2);
+    expect(arts[0].url).toBe(URL_A);
+    // Header reflects the NEWEST version.
+    expect(arts[0]).toMatchObject({ favicon: "🥗", description: "newer", title: "v2" });
+    expect(arts[0].versions[0].label).toBe("v1"); // oldest-first
+    expect(arts[0].versions[1].label).toBe("v2");
+  });
+
+  it("keeps distinct file_paths as distinct artifacts, oldest-first", () => {
+    const e = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/a.html" }), tuse("u2", { file_path: "/tmp/b.html" })] }],
+      { u1: SHORT("/tmp/a.html", URL_A), u2: SHORT("/tmp/b.html", URL_B) },
+    );
+    const arts = selectArtifacts(e);
+    expect(arts.map((a) => a.url)).toEqual([URL_A, URL_B]);
+  });
+
+  it("does NOT merge by label (labels repeat across different files)", () => {
+    const e = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/a.html", label: "samedi" }), tuse("u2", { file_path: "/tmp/b.html", label: "samedi" })] }],
+      { u1: SHORT("/tmp/a.html", URL_A), u2: SHORT("/tmp/b.html", URL_B) },
+    );
+    expect(selectArtifacts(e)).toHaveLength(2);
+  });
+
+  it("excludes sub-agent (parentToolUseId != null) publishes — matches reload's skip_sidechain", () => {
+    const e = entryOf(
+      [{ id: "t1", parent: "parent-tool", blocks: [tuse("u1", { file_path: "/tmp/sub.html" })] }],
+      { u1: SHORT("/tmp/sub.html", URL_A) },
+    );
+    expect(selectArtifacts(e)).toEqual([]);
+  });
+
+  it("skips tool_uses with no file_path (action:list / bare url-update)", () => {
+    const e = entryOf([{ id: "t1", blocks: [tuse("u1", { limit: 25 })] }]);
+    expect(selectArtifacts(e)).toEqual([]);
+  });
+
+  it("ignores non-Artifact tool_uses", () => {
+    const e = entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html" }, "Write")] }]);
+    expect(selectArtifacts(e)).toEqual([]);
+  });
+
+  it("surfaces a pending publish (no result yet) with url null", () => {
+    const e = entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html", label: "wip" })] }]);
+    const arts = selectArtifacts(e);
+    expect(arts).toHaveLength(1);
+    expect(arts[0].url).toBeNull();
+    expect(arts[0].title).toBe("wip");
+  });
+
+  it("falls back to the file basename (no extension) when there is no label", () => {
+    const e = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/scratch/my-report.html" })] }],
+      { u1: SHORT("/tmp/scratch/my-report.html", URL_A) },
+    );
+    expect(selectArtifacts(e)[0].title).toBe("my-report");
+  });
+
+  it("keeps LAST-KNOWN-GOOD header (title/favicon/description) when a republish omits fields", () => {
+    const e = entryOf(
+      [
+        { id: "t1", blocks: [tuse("u1", { file_path: "/tmp/f.html", label: "v1", favicon: "🍽️", description: "first" })] },
+        // v2 omits favicon/description/label entirely.
+        { id: "t2", blocks: [tuse("u2", { file_path: "/tmp/f.html" })] },
+      ],
+      { u1: SHORT("/tmp/f.html", URL_A), u2: SHORT("/tmp/f.html", URL_A) },
+    );
+    const a = selectArtifacts(e)[0];
+    // Header keeps the last-known-good values — not blanked by the field-less republish.
+    expect(a.favicon).toBe("🍽️");
+    expect(a.description).toBe("first");
+    expect(a.title).toBe("v1");
+    expect(a.versions).toHaveLength(2);
+  });
+
+  it("drops an artifact whose every publish terminally FAILED (is_error, no URL)", () => {
+    const e = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/f.html", label: "boom" })] }],
+      { u1: "Publishing failed: external resource blocked" },
+      ["u1"], // errored
+    );
+    expect(selectArtifacts(e)).toEqual([]);
+  });
+
+  it("keeps a still-PENDING publish (no result yet — not an error)", () => {
+    const e = entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/f.html", label: "wip" })] }]);
+    const arts = selectArtifacts(e);
+    expect(arts).toHaveLength(1);
+    expect(arts[0].url).toBeNull();
+  });
+
+  it("keeps an artifact when an EARLIER publish succeeded and a later one failed (URL survives)", () => {
+    const e = entryOf(
+      [
+        { id: "t1", blocks: [tuse("u1", { file_path: "/tmp/f.html", label: "v1" })] },
+        { id: "t2", blocks: [tuse("u2", { file_path: "/tmp/f.html", label: "v2" })] },
+      ],
+      { u1: SHORT("/tmp/f.html", URL_A), u2: "Publishing failed" },
+      ["u2"],
+    );
+    const arts = selectArtifacts(e);
+    expect(arts).toHaveLength(1);
+    expect(arts[0].url).toBe(URL_A);
+    expect(arts[0].versions[1].isError).toBe(true);
+  });
+});
+
+describe("memoizedArtifacts — ref stability", () => {
+  it("returns the SAME array ref while timeline & toolResults are unchanged", () => {
+    const e = entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html" })] }], { u1: SHORT("/tmp/x.html", URL_A) });
+    const a = memoizedArtifacts("s-stable", e);
+    const b = memoizedArtifacts("s-stable", e);
+    expect(a).toBe(b);
+  });
+
+  it("keeps the ref across a recompute whose derived list is unchanged (unrelated result landed)", () => {
+    const blocks = [tuse("u1", { file_path: "/tmp/x.html" })];
+    const e1 = entryOf([{ id: "t1", blocks }], { u1: SHORT("/tmp/x.html", URL_A) });
+    const a = memoizedArtifacts("s-content", e1);
+    // A new entry (fresh timeline/toolResults refs) but the SAME artifacts content.
+    const e2 = entryOf([{ id: "t1", blocks }], { u1: SHORT("/tmp/x.html", URL_A), other: SHORT("/tmp/y.html", URL_B) });
+    const b = memoizedArtifacts("s-content", e2);
+    expect(b).toBe(a); // signature unchanged → previous ref kept
+  });
+
+  it("produces a NEW ref when an artifact is added", () => {
+    const e1 = entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html" })] }], { u1: SHORT("/tmp/x.html", URL_A) });
+    const a = memoizedArtifacts("s-added", e1);
+    const e2 = entryOf(
+      [{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html" }), tuse("u2", { file_path: "/tmp/z.html" })] }],
+      { u1: SHORT("/tmp/x.html", URL_A), u2: SHORT("/tmp/z.html", URL_B) },
+    );
+    const b = memoizedArtifacts("s-added", e2);
+    expect(b).not.toBe(a);
+    expect(b).toHaveLength(2);
+  });
+});
+
+describe("artifacts cache lifecycle", () => {
+  const oneArtifact = () =>
+    entryOf([{ id: "t1", blocks: [tuse("u1", { file_path: "/tmp/x.html", label: "keep" })] }], {
+      u1: SHORT("/tmp/x.html", URL_A),
+    });
+
+  it("clearArtifactsCache drops the memo — the SAME entry recomputes into a fresh array", () => {
+    const e = oneArtifact();
+    const a = memoizedArtifacts("s-clear", e);
+    expect(memoizedArtifacts("s-clear", e)).toBe(a); // memo hit (same timeline/toolResults refs)
+    clearArtifactsCache("s-clear");
+    const b = memoizedArtifacts("s-clear", e);
+    // Recomputed, not the pinned array: nothing of the removed conversation is retained.
+    expect(b).not.toBe(a);
+    expect(b).toEqual(a); // …but the derivation itself is unchanged
+  });
+
+  it("clearArtifactsCache only drops the session asked for", () => {
+    const e1 = oneArtifact();
+    const e2 = oneArtifact();
+    const a = memoizedArtifacts("s-keep-a", e1);
+    const b = memoizedArtifacts("s-keep-b", e2);
+    clearArtifactsCache("s-keep-a");
+    expect(memoizedArtifacts("s-keep-a", e1)).not.toBe(a);
+    expect(memoizedArtifacts("s-keep-b", e2)).toBe(b); // untouched neighbour keeps its memo
+  });
+
+  it("clearAllArtifactsCache drops every session (wipe-all)", () => {
+    const e1 = oneArtifact();
+    const e2 = oneArtifact();
+    const a = memoizedArtifacts("s-wipe-a", e1);
+    const b = memoizedArtifacts("s-wipe-b", e2);
+    clearAllArtifactsCache();
+    expect(memoizedArtifacts("s-wipe-a", e1)).not.toBe(a);
+    expect(memoizedArtifacts("s-wipe-b", e2)).not.toBe(b);
+  });
+
+  it("clearing an unknown session is a harmless no-op", () => {
+    expect(() => clearArtifactsCache("never-cached")).not.toThrow();
+  });
+});
diff --git a/src/features/conversation/artifacts.ts b/src/features/conversation/artifacts.ts
new file mode 100644
index 0000000..6c699da
--- /dev/null
+++ b/src/features/conversation/artifacts.ts
@@ -0,0 +1,225 @@
+// Front-derived registry of the artifacts Claude published in a conversation via the
+// `Artifact` tool (a hosted HTML/MD page at claude.ai/code/artifact/<uuid>).
+//
+// Everything is DERIVED from the message stream already in `conversationStore` — the
+// `Artifact` tool_use inputs (file_path / description / favicon / label) joined to their
+// plain-text tool_result (which carries the published URL). NO Rust/IPC/persistence: the
+// tool_use + tool_result are replayed from the transcript by history.rs, so a resumed
+// conversation surfaces the same artifacts as a live one — for free.
+//
+// READ-ONLY toward claude.ai: this only reads what was already published; it never issues
+// an `Artifact` publish/list call (that would be a real side-effect on the user's account).
+
+import type { JsonValue } from "../../ipc/client";
+import type { SessionEntry } from "../../store/types";
+import { useConversationStore } from "../../store/conversationStore";
+import { field } from "../../agent/ask";
+import { resultText } from "../../agent/subagentMeta";
+import { basename } from "./toolMeta";
+
+/** The canonical hosted-artifact URL shape. The publish tool_result is free text that
+ *  ALWAYS begins "Published <abs_path> at https://claude.ai/code/artifact/<uuid>"; we anchor
+ *  on this shape rather than parsing the surrounding human prose (which drifts across CLI
+ *  versions — short vs long "To update:" forms). */
+export const ARTIFACT_URL_RE = /https:\/\/claude\.ai\/code\/artifact\/[A-Za-z0-9-]+/;
+
+/** Pull the published URL out of an `Artifact` tool_result. Null while the publish is still
+ *  in flight (no result yet) or if the ack is ever reworded past the canonical URL shape —
+ *  callers degrade to a label-only, non-clickable state rather than a dead link. Mirrors the
+ *  defensive `runIdFromResult` parse. */
+export function artifactUrlFromResult(content: JsonValue | undefined): string | null {
+  const text = resultText(content);
+  if (!text) return null;
+  const m = text.match(ARTIFACT_URL_RE);
+  return m ? m[0] : null;
+}
+
+/** One publish of an artifact (one `Artifact` tool_use). Re-publishing the same file_path in
+ *  the same conversation keeps the same URL and appends one of these — a version. */
+export interface ArtifactVersion {
+  /** The author-chosen `label` for this publish, or null (often omitted on the first publish).
+   *  NOT unique — the same label can appear on different files — so it is never a grouping key. */
+  label: string | null;
+  /** The tool_use id that produced this version — the join key to its tool_result. */
+  toolUseId: string;
+  filePath: string;
+  description: string | null;
+  favicon: string | null;
+  /** True when THIS publish's tool_result came back `is_error` (a failed/refused publish).
+   *  False while still in flight (no result yet) or on success. */
+  isError: boolean;
+}
+
+/** An artifact grouped across its versions for one conversation. */
+export interface Artifact {
+  /** Hosted URL (claude.ai/code/artifact/<uuid>). Null only in the brief window between a
+   *  publish tool_use and its tool_result landing. */
+  url: string | null;
+  /** Emoji favicon — of the most recent version that set it (last-known-good, so a republish
+   *  that omits the favicon keeps the prior one), or null. */
+  favicon: string | null;
+  /** Gallery subtitle — of the most recent version that set it (last-known-good), or null. */
+  description: string | null;
+  /** Display title: the most recent non-empty label (last-known-good, consistent with
+   *  favicon/description), else the file's basename (the wire carries no HTML <title>). */
+  title: string;
+  /** The file_path every version of this artifact was published from — INVARIANT, since it IS
+   *  the grouping key (a different path is a different artifact). Kept under the historical
+   *  `latest…` name for its readers. An EPHEMERAL temp scratchpad path: it may already be gone,
+   *  so it is only ever a best-effort render source, never the artifact's identity (the hosted
+   *  URL is). */
+  latestFilePath: string;
+  /** Every publish, oldest-first. */
+  versions: ArtifactVersion[];
+}
+
+const EMPTY_ARTIFACTS: Artifact[] = [];
+
+function stripExt(name: string): string {
+  return name.replace(/\.[^./]+$/, "");
+}
+
+function artifactTitle(latestLabel: string | null, latestFilePath: string): string {
+  if (latestLabel && latestLabel.trim()) return latestLabel.trim();
+  const base = basename(latestFilePath);
+  const stem = base ? stripExt(base) : "";
+  return stem || "Artifact";
+}
+
+/**
+ * Pure: walk a session's timeline and group every `Artifact` publish into one {@link Artifact}
+ * per file_path, oldest→newest.
+ *
+ * Design choices, grounded in the verified wire contract:
+ *  - MAIN-THREAD ONLY (`parentToolUseId === null`): a sub-agent's Artifact tool_use is replayed
+ *    live but SKIPPED on reload (history.rs skip_sidechain), so scoping to the main thread keeps
+ *    the list identical live and after a resume.
+ *  - GROUP BY file_path (not URL, not label): same conversation + same file_path deterministically
+ *    maps to the same URL, but the URL is only known once the tool_result lands — file_path is
+ *    known at tool_use time, so it is the stable provisional key that never splits a republish
+ *    into two items. Labels repeat across different files, so they are never a key.
+ *  - Tool_uses with no file_path (an `action:"list"` or a bare cross-conversation url-update) are
+ *    skipped — they don't describe a local publish. (The inline card path mirrors this guard in
+ *    `groupBlocks`.)
+ *  - An artifact whose EVERY publish terminally FAILED (all versions `is_error`, no URL) is dropped
+ *    from this list: it is not an openable artifact, so it must not inflate the "Artifacts (N)" chip
+ *    nor sit there mislabelled as "not published yet". The failure is still surfaced in the thread
+ *    by <ArtifactCard> (which reads `is_error` and shows the reason). A still-pending publish (no
+ *    result yet → not `is_error`) is kept.
+ */
+export function selectArtifacts(entry: SessionEntry | undefined): Artifact[] {
+  if (!entry) return EMPTY_ARTIFACTS;
+  const byFile = new Map<string, Artifact>();
+  const order: string[] = [];
+  for (const t of entry.timeline) {
+    if (t.kind !== "turn") continue;
+    const turn = entry.turns[t.id];
+    if (!turn || turn.role !== "assistant" || turn.parentToolUseId !== null) continue;
+    for (const b of turn.blocks) {
+      if (b.type !== "tool_use" || b.name !== "Artifact") continue;
+      const filePath = field(b.input, "file_path");
+      if (!filePath) continue;
+      const label = field(b.input, "label") ?? null;
+      const description = field(b.input, "description") ?? null;
+      const favicon = field(b.input, "favicon") ?? null;
+      const result = entry.toolResults[b.id];
+      const url = artifactUrlFromResult(result?.content);
+      const isError = !!result?.isError;
+      let art = byFile.get(filePath);
+      if (!art) {
+        art = { url: null, favicon: null, description: null, title: "", latestFilePath: filePath, versions: [] };
+        byFile.set(filePath, art);
+        order.push(filePath);
+      }
+      art.versions.push({ label, toolUseId: b.id, filePath, description, favicon, isError });
+      // Header fields = LAST-KNOWN-GOOD (timeline order = oldest→newest): keep the last non-null we
+      // see, so a republish that omits a field doesn't blank the header. Any version's URL is the
+      // artifact's URL (stable across republishes). `latestFilePath` is NOT refreshed here: it is
+      // the grouping key, so every version of this artifact carries the very same path — writing it
+      // per version would only re-assign the identical value and imply, wrongly, that it can drift.
+      if (favicon) art.favicon = favicon;
+      if (description) art.description = description;
+      if (url) art.url = url;
+    }
+  }
+  if (order.length === 0) return EMPTY_ARTIFACTS;
+  const out = order
+    .map((fp) => byFile.get(fp)!)
+    // Drop artifacts whose every publish terminally failed (no URL + all versions errored). A
+    // pending version (no result yet) is NOT errored, so a still-publishing artifact survives.
+    .filter((a) => a.url || !a.versions.every((v) => v.isError));
+  if (out.length === 0) return EMPTY_ARTIFACTS;
+  return out.map((a) => {
+    // Title = last-known-good label (consistent with favicon/description), else basename.
+    let lastLabel: string | null = null;
+    for (const v of a.versions) if (v.label && v.label.trim()) lastLabel = v.label;
+    a.title = artifactTitle(lastLabel, a.latestFilePath);
+    return a;
+  });
+}
+
+/** A cheap content signature — lets {@link memoizedArtifacts} return the SAME array reference
+ *  when the derived list is unchanged, so a tool_result for an unrelated tool (frequent) never
+ *  re-renders the chip. */
+function artifactsSig(list: Artifact[]): string {
+  return list.map((a) => `${a.url ?? a.latestFilePath}#${a.versions.length}#${a.favicon ?? ""}#${a.title}`).join("|");
+}
+
+const cache = new Map<
+  string,
+  {
+    timeline: SessionEntry["timeline"];
+    toolResults: SessionEntry["toolResults"];
+    sig: string;
+    result: Artifact[];
+  }
+>();
+
+/**
+ * `selectArtifacts` memoised per session on the `timeline` AND `toolResults` references. Both
+ * matter: a new publish appears as a tool_use (timeline advances when the turn settles) and its
+ * URL arrives as a tool_result (toolResults changes) — keying on both catches the artifact the
+ * moment its URL is known, WITHOUT recomputing on every streamed token (which replaces `turns`
+ * but neither `timeline` nor `toolResults`). Ref-stable across unrelated recomputes via the
+ * content signature. Pure (module-singleton cache) so the invariant is unit-testable.
+ */
+export function memoizedArtifacts(session: string, entry: SessionEntry | undefined): Artifact[] {
+  if (!entry) return EMPTY_ARTIFACTS;
+  const cached = cache.get(session);
+  if (cached && cached.timeline === entry.timeline && cached.toolResults === entry.toolResults) {
+    return cached.result;
+  }
+  const result = selectArtifacts(entry);
+  const sig = artifactsSig(result);
+  if (cached && cached.sig === sig) {
+    // Content unchanged (e.g. an unrelated tool_result landed) → keep the previous array so
+    // subscribers don't re-render; just refresh the reference keys for the fast path.
+    cache.set(session, { timeline: entry.timeline, toolResults: entry.toolResults, sig, result: cached.result });
+    return cached.result;
+  }
+  cache.set(session, { timeline: entry.timeline, toolResults: entry.toolResults, sig, result });
+  return result;
+}
+
+/**
+ * Forget one conversation's memoised artifact list. MUST be called on every conversation-removal
+ * path (see conversationsStore, alongside `useGoalStore.clear`): the cache entry pins the whole
+ * `timeline` AND `toolResults` of a conversation that no longer exists — and tool results carry
+ * full tool output (base64 images among them), so a session's worth of memory would be held for
+ * the rest of the run. It is also a correctness guard: a stale entry keyed by a reused id would
+ * hand back another conversation's artifacts.
+ */
+export function clearArtifactsCache(convId: string): void {
+  cache.delete(convId);
+}
+
+/** Forget EVERY conversation's memoised artifact list (wipe-all). */
+export function clearAllArtifactsCache(): void {
+  cache.clear();
+}
+
+/** The artifacts published in a conversation, oldest-first. Empty when none (Codex conversations
+ *  never yield any — the Artifact tool is Claude-only). Ref-stable while unchanged. */
+export function useArtifacts(session: string): Artifact[] {
+  return useConversationStore((s) => memoizedArtifacts(session, s.sessions[session]));
+}
diff --git a/src/features/conversation/toolGroup.test.ts b/src/features/conversation/toolGroup.test.ts
index 9afbbaf..6ee64ff 100644
--- a/src/features/conversation/toolGroup.test.ts
+++ b/src/features/conversation/toolGroup.test.ts
@@ -216,6 +216,26 @@ describe("groupBlocks — ExitPlanMode (proposed plan)", () => {
   });
 });
 
+describe("groupBlocks — Artifact (publish only)", () => {
+  it("emits an `artifact` segment for a real publish (has file_path), breaking the run", () => {
+    const segs = groupBlocks([
+      tool("a", "Read"),
+      tool("art", "Artifact", { file_path: "/tmp/x.html", favicon: "🎨" }),
+      tool("b", "Read"),
+    ]);
+    expect(segs.map((s) => s.kind)).toEqual(["run", "artifact", "run"]);
+    const a = segs[1];
+    if (a.kind === "artifact") expect(a.step.id).toBe("art");
+  });
+
+  it("does NOT treat a file_path-less Artifact (action:list / bare url-update) as an artifact — it falls through to the run, mirroring selectArtifacts", () => {
+    const list = groupBlocks([tool("l", "Artifact", { action: "list", limit: 25 })]);
+    expect(list.map((s) => s.kind)).toEqual(["run"]);
+    const urlUpdate = groupBlocks([tool("u", "Artifact", { url: "https://claude.ai/code/artifact/abc" })]);
+    expect(urlUpdate.map((s) => s.kind)).toEqual(["run"]);
+  });
+});
+
 describe("groupBlocks — in-band markers (mid-turn separator)", () => {
   it("emits a `marker` segment that breaks the run without being a step", () => {
     const segs = groupBlocks([tool("a", "Read"), mkMarker("cc"), tool("b", "Read")]);
diff --git a/src/features/conversation/toolGroup.ts b/src/features/conversation/toolGroup.ts
index def57ec..fa1c891 100644
--- a/src/features/conversation/toolGroup.ts
+++ b/src/features/conversation/toolGroup.ts
@@ -91,6 +91,11 @@ export type Segment =
   // segment that breaks the surrounding run; it is a DECISION artifact, never intermediate
   // work, so it is also peeled out of the clean-output work fold (see splitFinalMessage).
   | { kind: "plan"; key: string; step: ToolStep }
+  // An `Artifact` publish (a hosted claude.ai/code page) renders as its OWN inline card, like a
+  // sub-agent: dedicated segment that breaks the run, never grouped into a step row. It is a
+  // DELIVERABLE, never intermediate work, so it is also peeled out of the clean-output work fold
+  // (see splitFinalMessage) and shown in clear even when buried mid-round (see renderFoldedWork).
+  | { kind: "artifact"; key: string; step: ToolStep }
   // An in-band marker (control-change bar / message injected mid-work) shown inline in the
   // flow. NOT work: it doesn't count as a step and never breaks the clean-output work fold —
   // it just renders at its chronological place (see coalesceCleanRounds / interleaveMarkers).
@@ -180,6 +185,19 @@ export function groupBlocks(
         out.push({ kind: "plan", key: `p-${i}`, step: { id: b.id, name: b.name, input: b.input } });
         return;
       }
+      // An Artifact PUBLISH is its own inline card (a deliverable link) — breaks the run so the
+      // published page stands out instead of hiding in a "Ran N steps" step row (and its .html
+      // file_path never renders as an editor-opening chip pointing at a disposable temp file).
+      // Only a real publish qualifies: the `Artifact` tool also does `action:"list"` (enumerate
+      // the user's artifacts) and bare cross-conversation `url`-updates, which carry NO file_path
+      // and are NOT a local deliverable — those fall through to the normal run/step path so their
+      // result is shown like any other tool. This MUST mirror `selectArtifacts` (the chip's
+      // derivation, which skips file_path-less calls) or the two surfaces disagree.
+      if (b.name === "Artifact" && field(b.input, "file_path")) {
+        run = null;
+        out.push({ kind: "artifact", key: `art-${i}`, step: { id: b.id, name: b.name, input: b.input } });
+        return;
+      }
       if (!run) {
         run = [];
         out.push({ kind: "run", key: `run-${i}`, steps: run });
@@ -238,7 +256,10 @@ export function splitFinalMessage(segments: Segment[]): {
     i > 0 &&
     (segments[i - 1].kind === "text" ||
       segments[i - 1].kind === "marker" ||
-      segments[i - 1].kind === "plan")
+      segments[i - 1].kind === "plan" ||
+      // A trailing `artifact` is peeled too: a just-published artifact is a deliverable, not
+      // intermediate work — it stays in clear under clean output (like a plan).
+      segments[i - 1].kind === "artifact")
   )
     i--;
   return { work: segments.slice(0, i), final: segments.slice(i) };
@@ -258,6 +279,10 @@ export type WorkAtom =
   // but never counts as a step nor holds the live window open (its ack settles instantly).
   | { kind: "skill"; key: string; step: ToolStep }
   | { kind: "plan"; key: string; step: ToolStep }
+  // An artifact card: a non-step atom (like a skill chip) — folds with surrounding work but never
+  // counts as a step nor holds the live window open (its publish settles quickly). It is pulled
+  // back into clear by renderFoldedWork so a published artifact is never hidden.
+  | { kind: "artifact"; key: string; step: ToolStep }
   | { kind: "thinking"; key: string; text: string }
   | { kind: "text"; key: string; text: string }
   // An in-band marker: a non-step atom (like text/thinking) — it folds with the surrounding
@@ -278,6 +303,8 @@ export function flattenWork(segs: Segment[]): WorkAtom[] {
       out.push({ kind: "skill", key: seg.key, step: seg.step });
     } else if (seg.kind === "plan") {
       out.push({ kind: "plan", key: seg.key, step: seg.step });
+    } else if (seg.kind === "artifact") {
+      out.push({ kind: "artifact", key: seg.key, step: seg.step });
     } else if (seg.kind === "thinking") {
       out.push({ kind: "thinking", key: seg.key, text: seg.text });
     } else if (seg.kind === "marker") {
@@ -310,6 +337,7 @@ export function atomsToSegments(atoms: WorkAtom[], keyPrefix: string): Segment[]
     else if (a.kind === "workflow") out.push({ kind: "workflow", key: a.key, step: a.step });
     else if (a.kind === "skill") out.push({ kind: "skill", key: a.key, step: a.step });
     else if (a.kind === "plan") out.push({ kind: "plan", key: a.key, step: a.step });
+    else if (a.kind === "artifact") out.push({ kind: "artifact", key: a.key, step: a.step });
     else if (a.kind === "thinking") out.push({ kind: "thinking", key: a.key, text: a.text });
     else if (a.kind === "marker")
       out.push({ kind: "marker", key: a.key, markerKind: a.markerKind, id: a.id });
diff --git a/src/features/editor/editorStore.ts b/src/features/editor/editorStore.ts
index efe1bae..cae5334 100644
--- a/src/features/editor/editorStore.ts
+++ b/src/features/editor/editorStore.ts
@@ -121,6 +121,26 @@ export interface FileClipboard {
   mode: "copy" | "cut";
 }
 
+/**
+ * The artifact currently open in the side-region VIEWER (a rendered preview of a Claude
+ * `Artifact` — HTML in a sandboxed iframe, Markdown via the thread renderer). In-memory /
+ * transient (NOT persisted): it points at an EPHEMERAL temp file, so it must not outlive the
+ * session. Takes over the side region while set, mutually exclusive with Git, and cleared by ANY
+ * side-region toggle (editor / terminal / Git) in EITHER direction — see `clearArtifact` for why
+ * "only when opening" made a toggle press do nothing visible.
+ */
+export interface ArtifactView {
+  /** The conversation this artifact belongs to (the viewer only shows on its own conv). */
+  convId: string;
+  title: string;
+  favicon: string | null;
+  /** Hosted claude.ai URL — the durable copy, for "open in browser" and the missing-file fallback. */
+  url: string | null;
+  /** Local temp file to render, or null (→ the viewer shows the open-in-browser fallback). */
+  filePath: string | null;
+  kind: "html" | "md";
+}
+
 interface EditorState {
   // ---- Global layout (persisted) ----
   // The "side region" (right of, or below, the conversation) holds the editor
@@ -155,6 +175,17 @@ interface EditorState {
   /** The file tree is hidden (focus-on-files mode); the editor still shows. */
   treeCollapsed: boolean;
 
+  // ---- Artifact viewer (in-memory, transient) ----
+  /** The artifact open in the side-region viewer, or null. Cleared by every side-region toggle
+   *  (`toggleOpen`/`setOpen`, `toggleTerminal`/`setTerminalOpen`, `toggleGit`/`setGitOpen`),
+   *  whichever way they flip. */
+  artifactView: ArtifactView | null;
+  /** Open an artifact in the side-region viewer (closes Git FIRST — see the ordering trap in the
+   *  implementation — then takes over the side region). */
+  openArtifact: (view: ArtifactView) => void;
+  /** Close the artifact viewer (the side region falls back to editor/terminal if open). */
+  closeArtifact: () => void;
+
   // ---- Per conversation ----
   byConv: Record<string, ConvEditor>;
 
@@ -642,31 +673,63 @@ export const useEditorStore = create<EditorState>()((set, get) => {
     }
   }
 
+  // ANY side-region toggle (editor / terminal / git) clears the transient artifact viewer, in
+  // BOTH directions — closing included. MainArea computes the region's visibility as
+  // `open || terminalOpen || showArtifact`, so the viewer holds the side region open on its own:
+  // a toggle that only cleared it when OPENING made ⌘B (editor) flip `open` to false while the
+  // viewer stayed on screen — the press produced NO visible change and a second one was needed.
+  // Clearing unconditionally keeps the rule "one press = one visible effect".
+  const clearArtifact = () => {
+    if (get().artifactView) set({ artifactView: null });
+  };
+
   return {
     ...layout,
     byConv: {},
     clipboard: null,
+    artifactView: null,
+
+    openArtifact: (view) => {
+      // ⚠️ ORDER MATTERS — close Git BEFORE setting the view, never after. `setGitOpen` clears the
+      // artifact view UNCONDITIONALLY (see clearArtifact), so the old "set, then close Git"
+      // ordering would immediately wipe the artifact we were just asked to open. Do not swap
+      // these two lines back.
+      if (get().gitOpen) get().setGitOpen(false); // viewer and Git are mutually exclusive
+      set({ artifactView: view });
+    },
+    closeArtifact: () => set({ artifactView: null }),
 
     // Git is a mutually-exclusive mode: opening it hides the editor/terminal
     // region, and opening the editor or terminal closes Git — so a lit toggle
     // never contradicts what's actually shown. Editor + terminal still coexist.
+    // Every one of these also drops the artifact viewer (both directions — see clearArtifact).
     toggleOpen: () => {
       const open = !get().open;
+      clearArtifact();
+      withLayout(open ? { open: true, gitOpen: false } : { open: false });
+    },
+    setOpen: (open) => {
+      clearArtifact();
       withLayout(open ? { open: true, gitOpen: false } : { open: false });
     },
-    setOpen: (open) => withLayout(open ? { open: true, gitOpen: false } : { open: false }),
     toggleTerminal: () => {
       const terminalOpen = !get().terminalOpen;
+      clearArtifact();
+      withLayout(terminalOpen ? { terminalOpen: true, gitOpen: false } : { terminalOpen: false });
+    },
+    setTerminalOpen: (terminalOpen) => {
+      clearArtifact();
       withLayout(terminalOpen ? { terminalOpen: true, gitOpen: false } : { terminalOpen: false });
     },
-    setTerminalOpen: (terminalOpen) =>
-      withLayout(terminalOpen ? { terminalOpen: true, gitOpen: false } : { terminalOpen: false }),
     toggleGit: () => {
       const gitOpen = !get().gitOpen;
+      clearArtifact();
+      withLayout(gitOpen ? { gitOpen: true, open: false, terminalOpen: false } : { gitOpen: false });
+    },
+    setGitOpen: (gitOpen) => {
+      clearArtifact();
       withLayout(gitOpen ? { gitOpen: true, open: false, terminalOpen: false } : { gitOpen: false });
     },
-    setGitOpen: (gitOpen) =>
-      withLayout(gitOpen ? { gitOpen: true, open: false, terminalOpen: false } : { gitOpen: false }),
     setOrientation: (orientation) => withLayout({ orientation }),
     setGitOrientation: (gitOrientation) => withLayout({ gitOrientation }),
     setEditorFraction: (f) => withLayout({ editorFraction: clamp(f, 0.15, 0.85) }),
diff --git a/src/features/flightdeck/CardGoal.tsx b/src/features/flightdeck/CardGoal.tsx
new file mode 100644
index 0000000..0ad2f53
--- /dev/null
+++ b/src/features/flightdeck/CardGoal.tsx
@@ -0,0 +1,47 @@
+// The Flight Deck card's active-`/goal` control: a small clickable target glyph, shown ONLY while a
+// conversation has an active goal (Claude Code's native goal feature). Clicking it opens the SAME
+// goal popover as the conversation composer (condition + latest reason + clear) — shared verbatim
+// via GoalPopover. The popover is PORTALED so it escapes the swimlane's `overflow` clip, exactly
+// like the card's other clickable openers (CardEffort, CardContext). Renders nothing when no goal
+// is active, keeping idle cards clean.
+//
+// It also SEEDS the goal from the transcript on mount (once per run): goal state is disk-only and
+// survives quit/relaunch, but this store is in-memory, so a card whose conversation was never
+// opened this run would otherwise show no goal until opened. `seedActiveGoalOnce` reads it lazily.
+
+import { useEffect } from "react";
+import { useShallow } from "zustand/react/shallow";
+import { Ico, Menu } from "../../ui/kit";
+import { seedActiveGoalOnce, useActiveGoal } from "../../store/goalStore";
+import { useConversationsStore } from "../../store/conversationsStore";
+import { GoalPopover } from "../conversation/GoalPopover";
+
+export function CardGoal({ convId }: { convId: string }) {
+  const goal = useActiveGoal(convId);
+  const { sessionId, isCodex } = useConversationsStore(
+    useShallow((s) => {
+      const c = s.conversations.find((cv) => cv.id === convId);
+      return { sessionId: c?.sessionId ?? null, isCodex: c?.kind === "codex" };
+    }),
+  );
+
+  // Seed from disk once per run (Claude only — Codex has no `/goal`). Survives quit/relaunch.
+  useEffect(() => {
+    if (!isCodex) seedActiveGoalOnce(convId, sessionId);
+  }, [convId, sessionId, isCodex]);
+
+  if (!goal) return null;
+  return (
+    <Menu
+      portal
+      align="right"
+      trigger={
+        <button type="button" className="ag-goal" aria-label="Active goal — open to view" title="Active goal">
+          <Ico name="target" className="sm" />
+        </button>
+      }
+    >
+      <GoalPopover convId={convId} goal={goal} />
+    </Menu>
+  );
+}
diff --git a/src/features/flightdeck/StreamCard.tsx b/src/features/flightdeck/StreamCard.tsx
index 143cafa..fc417c0 100644
--- a/src/features/flightdeck/StreamCard.tsx
+++ b/src/features/flightdeck/StreamCard.tsx
@@ -18,6 +18,7 @@ import { LastMessagePeek } from "./LastMessagePeek";
 import { TodoPeek } from "./TodoPeek";
 import { CardEffort } from "./CardEffort";
 import { CardContext } from "./CardContext";
+import { CardGoal } from "./CardGoal";
 import { useFlightdeckModal } from "./flightdeckModalStore";
 
 /** Relative "last activity" stamp — "14 min ago" / "2 h ago". `now` comes from
@@ -136,6 +137,9 @@ export function StreamCard({
       <StateBlock convId={conv.id} status={status} />
 
       <div className="ag-card-foot">
+        {/* Active `/goal` — a clickable target opening the SAME goal popover as the composer
+            (condition + reason + clear). Renders nothing when no goal is active. */}
+        <CardGoal convId={conv.id} />
         {/* Context meter — clickable, opening the same context/usage popover as the
             composer's ContextRing (renders nothing until usage is reported). */}
         <CardContext convId={conv.id} />
diff --git a/src/ipc/bindings.ts b/src/ipc/bindings.ts
index 8260f3f..c72bf3b 100644
--- a/src/ipc/bindings.ts
+++ b/src/ipc/bindings.ts
@@ -410,6 +410,26 @@ async loadSessionContext(sessionId: string) : Promise<Result<ContextFill, string
     else return { status: "error", error: e  as any };
 }
 },
+/**
+ * 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`.
+ */
+async loadSessionGoal(sessionId: string) : Promise<Result<GoalState | null, string>> {
+    try {
+    return { status: "ok", data: await TAURI_INVOKE("load_session_goal", { sessionId }) };
+} catch (e) {
+    if(e instanceof Error) throw e;
+    else return { status: "error", error: e  as any };
+}
+},
 /**
  * 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
@@ -2167,6 +2187,25 @@ unborn: boolean;
  * Changed entries (staged + unstaged + untracked), in git's order.
  */
 files: GitFileEntry[] }
+/**
+ * The active `/goal` of a conversation (Claude Code's native goal feature: Claude keeps
+ * working across turns until a small fast model confirms the condition holds). Reconstructed
+ * from the on-disk transcript — the CLI records goal state as `attachment` lines of
+ * `type:"goal_status"`, which are **DISK-ONLY** (never emitted on the live stream), so this is
+ * the only place to read it. `None` when no goal is active (never set, achieved, or cleared).
+ * Mirrors the CLI's own `restoreGoalFromTranscript`: walk the goal_status snapshots and keep the
+ * last un-terminated one.
+ */
+export type GoalState = { 
+/**
+ * The completion condition the user set (`/goal <condition>`).
+ */
+condition: string; 
+/**
+ * The evaluator's most recent reason (why the condition is / isn't met yet). `None`
+ * before the first post-turn evaluation.
+ */
+reason: string | null }
 /**
  * An image joined to a user turn: base64 bytes + their MIME type. Sent inside the
  * message `content` array as an `image` block (spec §3.10) — verified accepted by
@@ -2351,12 +2390,19 @@ export type PersistedState = { repos: RepoRecord[]; conversations: ConversationR
  */
 active_id: string | null }
 /**
- * Real plan-usage snapshot: the two subscription windows, each with a fill %.
- * A window is `None` when the endpoint did not report it. `Deserialize` so it can
- * ride the Codex `session_codex_plan_usage` event (the event bus round-trips its
- * payload) — the Codex backend reuses this exact shape for its rate-limit push.
+ * Real plan-usage snapshot: the two account-wide subscription windows, each with a fill %,
+ * plus any model-scoped caps. A window is `None` when the endpoint did not report it.
+ * `Deserialize` so it can ride the Codex `session_codex_plan_usage` event (the event bus
+ * round-trips its payload) — the Codex backend reuses this exact shape for its rate-limit push.
  */
-export type PlanUsage = { five_hour: UsageWindow | null; seven_day: UsageWindow | null }
+export type PlanUsage = { five_hour: UsageWindow | null; seven_day: UsageWindow | null; 
+/**
+ * Caps that apply to ONE model rather than the whole account (e.g. Fable's weekly
+ * allowance), read from the `limits[]` array — the only place they appear. Empty when
+ * the plan has none. `serde(default)` so an older/foreign payload (a Codex push, which
+ * has no such concept) still deserializes.
+ */
+scoped?: ScopedUsageWindow[] }
 /**
  * Everything ONE plugin provides — for the per-plugin explorer (click a plugin →
  * browse its skills / sub-agents / MCP servers, like Claude.ai's Customize panel).
@@ -2475,6 +2521,24 @@ removed_prompt: string | null;
  * a no-op (the conversation already ended there), and the file is left untouched.
  */
 removed_lines: number }
+/**
+ * A rate-limit window that applies to a NAMED subset of usage (today: a single model) rather
+ * than the account as a whole. Kept separate from the two flat windows because its label is
+ * data-driven — it comes from the payload, so a renamed or newly added scoped model shows up
+ * without a code change.
+ */
+export type ScopedUsageWindow = { 
+/**
+ * What the cap is scoped to, as the endpoint names it (`scope.model.display_name`,
+ * e.g. `"Fable"`). Displayed verbatim.
+ */
+label: string; 
+/**
+ * Which family the cap belongs to (`"weekly"`, `"session"`, …), so the UI can suffix it
+ * with the matching window ("7d" / "5h"). `None` when the payload omits it — the UI then
+ * shows the bare label rather than guessing a duration.
+ */
+group: string | null; window: UsageWindow }
 /**
  * A search result: which conversation matched, its relevance score, and a short
  * snippet around the first body hit (empty when only title/excerpt matched).
diff --git a/src/ipc/client.ts b/src/ipc/client.ts
index ebb7485..ded0eeb 100644
--- a/src/ipc/client.ts
+++ b/src/ipc/client.ts
@@ -32,6 +32,7 @@ export type {
   GitDiff,
   GitFileEntry,
   GitStatus,
+  GoalState,
   ImageContent,
   JsonValue,
   MarketplaceInfo,
diff --git a/src/ipc/mock/mockBindings.ts b/src/ipc/mock/mockBindings.ts
index 48be050..6223ff5 100644
--- a/src/ipc/mock/mockBindings.ts
+++ b/src/ipc/mock/mockBindings.ts
@@ -10,6 +10,7 @@ import type {
   ContextFill,
   ConversationItem,
   ConversationRecord,
+  GoalState,
   DiskConversation,
   ClaudeAccountStatus,
   CodexAccountStatus,
@@ -613,6 +614,11 @@ export const mockCommands = {
     return ok({ context_tokens: null, context_window: null });
   },
 
+  async loadSessionGoal(_sessionId: string): Promise<Result<GoalState | null, string>> {
+    // No transcript in the browser mock; goal-active scenarios seed the goal store directly.
+    return ok(null);
+  },
+
   async rewindConversation(
     _sessionId: string,
     _targetId: string,
@@ -679,6 +685,11 @@ export const mockCommands = {
       data: {
         five_hour: { used_percentage: 42, resets_at: iso(2 * 3600) },
         seven_day: { used_percentage: 67, resets_at: iso(3 * 86400) },
+        // A model-scoped weekly cap, as the live endpoint reports it: named after the
+        // model and — when the window has never started — with no reset at all.
+        scoped: [
+          { label: "Fable", group: "weekly", window: { used_percentage: 0, resets_at: null } },
+        ],
       },
     };
   },
diff --git a/src/ipc/useCommands.ts b/src/ipc/useCommands.ts
index ae8aab8..0ec6e31 100644
--- a/src/ipc/useCommands.ts
+++ b/src/ipc/useCommands.ts
@@ -17,6 +17,12 @@ import { worktreesKey } from "./useWorktrees";
 import { useRemoteControlStore } from "../store/remoteControl";
 import { triggerLastMessageSummary } from "../store/lastMessageSummary";
 import { buildCodexControls } from "../features/conversation/codexControls";
+import {
+  endGoalClearing,
+  refreshActiveGoal,
+  scheduleGoalRefresh,
+  settleGoalClearing,
+} from "../store/goalStore";
 
 // These hooks are keyed by a conversation's STABLE id, not its live session
 // handle. Reads (the message store) key by the stable id; commands target the
@@ -47,22 +53,34 @@ export function useSendMessage(convId: string) {
       worktree,
       queued,
       images,
+      silent,
     }: {
       text: string;
       worktree?: boolean;
       queued?: boolean;
       images?: UserTurnImage[];
+      // `silent`: send WITHOUT the optimistic bubble / title / summary — for `/goal` commands,
+      // whose plumbing is represented by the goal chip, not a thread turn (keeps live == reload,
+      // since the Rust normalizer also drops the goal echo + stdout on both paths).
+      silent?: boolean;
     }) => {
       // The core does not echo user turns, so append optimistically (keyed by the
       // stable id) before sending — instant even while the session spawns.
-      addUserTurn(convId, text, queued, images);
-      // Sending the next message consumes any pending reminder: the user has moved
-      // on from the previous result. `addUserTurn` clears the LIVE turnSeen; clear
-      // the PERSISTED reminder too so it doesn't re-surface on the next restart.
-      useConversationsStore.getState().setReminder(convId, null);
-      // Sending IS activity: float the conversation to the top now and persist
-      // the new timestamp so the recency order survives a restart.
-      useConversationsStore.getState().noteActivity(convId, { persist: true });
+      if (!silent) {
+        addUserTurn(convId, text, queued, images);
+        // Sending the next message consumes any pending reminder: the user has moved on from
+        // the previous result. `addUserTurn` clears the LIVE turnSeen, so the PERSISTED reminder
+        // must be cleared under the SAME condition — a silent send does neither. Otherwise a
+        // `/goal` would swallow an unread attention reminder (persisted side cleared) while the
+        // live side still says "unread": the two halves would disagree and the reminder would
+        // vanish without the user ever seeing the result it pointed at.
+        useConversationsStore.getState().setReminder(convId, null);
+        // Sending IS activity: float the conversation to the top now and persist the new
+        // timestamp so the recency order survives a restart. Also skipped when silent: a `/goal`
+        // is plumbing, not work on this conversation, so it must not reshuffle the fleet's
+        // recency order (and must not persist a write for it either).
+        useConversationsStore.getState().noteActivity(convId, { persist: true });
+      }
       // Lazy spawn: a conversation has no live process until its first message
       // (or its first message after being stopped/ended).
       const handle = await ensureConversationSession(convId, { worktree });
@@ -75,17 +93,35 @@ export function useSendMessage(convId: string) {
       const conv = useConversationsStore.getState().conversations.find((c) => c.id === convId);
       const codexControls = conv?.kind === "codex" ? buildCodexControls(conv) : null;
       const res = await unwrap(commands.sendMessage(handle, text, wireImages, codexControls));
-      // On each of the first few messages of a still-untitled conversation, ask the
-      // binary to (re)generate a smart title from the accumulated intent (capped, then
-      // frozen; no-op once renamed / over the cap / no live session). Like the VS Code
-      // extension, but tracking the evolving topic. The title arrives via
-      // SessionTitleEvent and replaces the optimistic placeholder name.
-      useConversationsStore.getState().triggerAutoTitle(convId, text);
-      // Also (re)generate the Flight Deck's few-word summary of THIS message (the
-      // "last ask"). Instant truncation now, replaced by a ≤6-word Haiku summary that
-      // arrives via SessionSummaryEvent. Regenerated on every send (unlike the title,
-      // which settles). `handle` is the live session we just sent through.
-      triggerLastMessageSummary(convId, handle, text);
+      // A silent `/goal` command is not conversational content, so it must not drive the title or
+      // the Flight Deck "last ask" peek either — otherwise goal plumbing would leak into those.
+      if (!silent) {
+        // On each of the first few messages of a still-untitled conversation, ask the
+        // binary to (re)generate a smart title from the accumulated intent (capped, then
+        // frozen; no-op once renamed / over the cap / no live session). Like the VS Code
+        // extension, but tracking the evolving topic. The title arrives via
+        // SessionTitleEvent and replaces the optimistic placeholder name.
+        useConversationsStore.getState().triggerAutoTitle(convId, text);
+        // Also (re)generate the Flight Deck's few-word summary of THIS message (the
+        // "last ask"). Instant truncation now, replaced by a ≤6-word Haiku summary that
+        // arrives via SessionSummaryEvent. Regenerated on every send (unlike the title,
+        // which settles). `handle` is the live session we just sent through.
+        triggerLastMessageSummary(convId, handle, text);
+      } else {
+        // The send was a silent `/goal` and it was ACCEPTED. Nothing else will tell the user it
+        // took: no bubble, no stdout, and — `/goal` being a LOCAL command — possibly no model turn
+        // at all, so the busy edge that normally refetches the goal may never fire. Refresh from
+        // the transcript now, on a short bounded ladder because the `goal_status` write lands
+        // asynchronously (and this conversation may not have a session id until `system/init`).
+        // The session id is resolved lazily HERE because `goalStore` must not import
+        // `conversationsStore` (which imports it — circular).
+        scheduleGoalRefresh(
+          convId,
+          () =>
+            useConversationsStore.getState().conversations.find((c) => c.id === convId)?.sessionId ??
+            null,
+        );
+      }
       if (worktree) {
         // The first spawn just created a worktree — refresh the repo's list so
         // the indicator/manager show it.
@@ -180,6 +216,41 @@ export function useCodexCompact(convId: string) {
   });
 }
 
+/** Clear a conversation's active `/goal` (Claude Code's native goal feature). Sends the native
+ *  `/goal clear` local command to the session but WITHOUT an optimistic user turn — the goal is
+ *  represented by the dedicated goal UI, so clearing it must not drop `/goal clear` into the thread
+ *  (the Rust normalizer also drops the wire echo + its "No goal set" stdout). The caller arms the
+ *  clear guard (`beginGoalClearing`) and hides the chip optimistically; this hook settles the guard
+ *  once the send is accepted, and on FAILURE rolls the chip back to the still-active goal — never
+ *  leaving it wrongly hidden over a live goal. Resumes a stopped session if needed, since the goal
+ *  lives in the CLI session and only `/goal clear` actually clears it. */
+export function useClearGoal(convId: string) {
+  const addErrorTurn = useConversationStore((s) => s.addErrorTurn);
+  const sessionId = () =>
+    useConversationsStore.getState().conversations.find((c) => c.id === convId)?.sessionId ?? null;
+  return useMutation({
+    mutationFn: async () => {
+      const handle = await ensureConversationSession(convId);
+      // No `addUserTurn`: silent send (Claude → no per-turn codex controls).
+      return unwrap(commands.sendMessage(handle, "/goal clear", [], null));
+    },
+    onSuccess: () => {
+      // The send was accepted: switch to the post-send grace window, then refetch so a confirmed
+      // "no goal" read settles the guard (the optimistic null was correct).
+      settleGoalClearing(convId);
+      void refreshActiveGoal(convId, sessionId());
+    },
+    onError: (err) => {
+      // The clear never reached the CLI (e.g. spawn/resume failed): release the guard and refetch
+      // the TRUE state, restoring the still-active goal — the optimistic null was wrong.
+      endGoalClearing(convId);
+      void refreshActiveGoal(convId, sessionId());
+      const message = err instanceof Error ? err.message : String(err);
+      addErrorTurn(convId, `Couldn't clear the goal: ${message}`);
+    },
+  });
+}
+
 export function useStop(convId: string) {
   const addErrorTurn = useConversationStore((s) => s.addErrorTurn);
   return useMutation({
diff --git a/src/ipc/useGlobalSessionEvents.ts b/src/ipc/useGlobalSessionEvents.ts
index 85e0547..b0182ff 100644
--- a/src/ipc/useGlobalSessionEvents.ts
+++ b/src/ipc/useGlobalSessionEvents.ts
@@ -36,6 +36,7 @@ import {
 } from "../store/backgroundTasksStore";
 import { useWorkflowLiveStore } from "../store/workflowLive";
 import { useConversationsStore, repoName } from "../store/conversationsStore";
+import { hasSeenGoal, refreshActiveGoal } from "../store/goalStore";
 import { useDisplay } from "../store/display";
 import { agentStatusForEntry } from "../agent/useAgentStatus";
 import { useCommandsStore } from "../store/commandsStore";
@@ -333,6 +334,16 @@ export function useGlobalSessionEvents(): void {
         ) {
           syncReminderFromLive(session);
         }
+        // A `/goal` is achieved/cleared/re-evaluated at turn boundaries, and its state lives ONLY in
+        // the transcript (never on the live stream) — so re-read it on a busy edge. Gated on
+        // `hasSeenGoal`: ONLY conversations that have (or recently had) a goal pay this transcript
+        // read; a conversation that never used `/goal` reads nothing per turn (perf). A freshly set
+        // goal is armed via `markGoalSeen` on the composer send. Claude only.
+        if (prev.busy !== payload.state.busy && hasSeenGoal(session)) {
+          const conv = useConversationsStore.getState().conversations.find((c) => c.id === session);
+          if (conv && conv.kind !== "codex")
+            void refreshActiveGoal(session, payload.state.session_id ?? conv.sessionId);
+        }
       }
       // The session reports its current cwd via system/init (re-sent per turn).
       // When it changes — e.g. a conversation spawned straight into a worktree —
diff --git a/src/store/codexPlanUsage.test.ts b/src/store/codexPlanUsage.test.ts
index 9de5b02..8ecb943 100644
--- a/src/store/codexPlanUsage.test.ts
+++ b/src/store/codexPlanUsage.test.ts
@@ -26,6 +26,15 @@ describe("codexPlanUsage store", () => {
     expect(s.usage?.seven_day?.used_percentage).toBe(20);
   });
 
+  it("keeps model-scoped caps across a push that omits them", () => {
+    // Same sparse rule as the windows: an empty/absent `scoped` is "nothing new to say",
+    // not "the caps are gone" — otherwise a later push would blank a listed cap.
+    const fable = { label: "Fable", group: "weekly", window: win(5) };
+    useCodexPlanUsageStore.getState().set({ five_hour: win(10), seven_day: null, scoped: [fable] });
+    useCodexPlanUsageStore.getState().set({ five_hour: win(12), seven_day: null, scoped: [] });
+    expect(useCodexPlanUsageStore.getState().usage?.scoped).toEqual([fable]);
+  });
+
   it("clear() forgets the snapshot", () => {
     useCodexPlanUsageStore.getState().set({ five_hour: win(10), seven_day: null });
     useCodexPlanUsageStore.getState().clear();
diff --git a/src/store/codexPlanUsage.ts b/src/store/codexPlanUsage.ts
index ce07cee..1b41b43 100644
--- a/src/store/codexPlanUsage.ts
+++ b/src/store/codexPlanUsage.ts
@@ -37,6 +37,10 @@ export const useCodexPlanUsageStore = create<CodexPlanUsageStore>((set) => ({
       usage: {
         five_hour: incoming.five_hour ?? s.usage?.five_hour ?? null,
         seven_day: incoming.seven_day ?? s.usage?.seven_day ?? null,
+        // Codex reports no model-scoped caps today (the core always sends an empty list),
+        // so an empty push keeps whatever was there rather than blanking it — same sparse
+        // rule as the windows above.
+        scoped: incoming.scoped?.length ? incoming.scoped : (s.usage?.scoped ?? []),
       },
       updatedAt: Date.now(),
     })),
diff --git a/src/store/conversationsStore.test.ts b/src/store/conversationsStore.test.ts
index 540dba3..ceaabb2 100644
--- a/src/store/conversationsStore.test.ts
+++ b/src/store/conversationsStore.test.ts
@@ -18,6 +18,7 @@ vi.mock("../ipc/client", () => {
       loadSessionHistory: vi.fn(() => ok([])),
       codexLoadHistory: vi.fn(() => ok([])),
       loadSessionContext: vi.fn(() => ok({ context_tokens: 0 })),
+      loadSessionGoal: vi.fn(() => ok(null)),
       deleteConversation: vi.fn(() => ok()),
       stopSession: vi.fn(() => ok()),
     },
diff --git a/src/store/conversationsStore.ts b/src/store/conversationsStore.ts
index 4ceade0..156cbdb 100644
--- a/src/store/conversationsStore.ts
+++ b/src/store/conversationsStore.ts
@@ -27,6 +27,7 @@ import { useConversationStore } from "./conversationStore";
 import { useBackgroundTasksStore } from "./backgroundTasksStore";
 import { useWorkflowLiveStore } from "./workflowLive";
 import { useRemoteControlStore } from "./remoteControl";
+import { refreshActiveGoal, useGoalStore } from "./goalStore";
 import { useCodexPlanUsageStore } from "./codexPlanUsage";
 import { useLastMessageSummaryStore } from "./lastMessageSummary";
 // The Codex default model — seeds a Codex conversation so its persisted `model` is
@@ -41,6 +42,10 @@ import {
   clearComposerAttachments,
   clearAllComposerAttachments,
 } from "../features/conversation/composerAttachments";
+import {
+  clearArtifactsCache,
+  clearAllArtifactsCache,
+} from "../features/conversation/artifacts";
 import {
   clearCodexControls,
   clearAllCodexControls,
@@ -443,6 +448,9 @@ export const useConversationsStore = create<ConversationsState>()((set, get) =>
       clearPlanAnnotations(c.id);
       useGitViewStore.getState().clear(c.id);
       useRemoteControlStore.getState().clear(c.id);
+      useGoalStore.getState().clear(c.id);
+      // Drop the derived artifacts memo: it pins this conversation's timeline + tool results.
+      clearArtifactsCache(c.id);
       useLastMessageSummaryStore.getState().clear(c.id);
       autoTitlePending.delete(c.id);
       titleContext.delete(c.id);
@@ -522,6 +530,11 @@ export const useConversationsStore = create<ConversationsState>()((set, get) =>
     // Drop the bridge state too — the session was just stopped, so a lingering
     // "connected" chip would be a stale, misleading indicator.
     useRemoteControlStore.getState().clear(id);
+    // Drop its active-goal too — the conversation is gone.
+    useGoalStore.getState().clear(id);
+    // Drop the derived artifacts memo, which pins the (now dropped) timeline + tool results —
+    // otherwise the heaviest part of a deleted conversation outlives it for the whole run.
+    clearArtifactsCache(id);
     // Drop its Flight Deck last-message summary — the card is gone.
     useLastMessageSummaryStore.getState().clear(id);
     syncToCore("deleteConversation", () => commands.deleteConversation(id));
@@ -1235,6 +1248,11 @@ export async function loadConversationHistory(convId: string): Promise<void> {
   historyLoaded.add(convId); // mark before awaiting to avoid a double-load race
   const conv = useConversationsStore.getState().conversations.find((c) => c.id === convId);
   if (!conv || !conv.sessionId) return;
+  // Seed the active `/goal` (Claude only) from the transcript — INDEPENDENT of the history load
+  // below, so it shows even when the RENDERED thread is empty: a conversation whose only on-disk
+  // content is a goal still has one, since its `/goal` command echo is now dropped as noise. Goal
+  // state is disk-only (not on the live stream).
+  if (conv.kind !== "codex") void refreshActiveGoal(convId, conv.sessionId);
   // Codex renders LIVE-only (a resumed thread re-streams nothing), so its cold history
   // comes from its on-disk ROLLOUT via a distinct reader (full tool fidelity); Claude
   // reads its transcript. Both return the same `ConversationItem[]` result shape.
@@ -1301,6 +1319,10 @@ export async function loadConversationHistory(convId: string): Promise<void> {
 export async function reloadConversationHistory(convId: string): Promise<void> {
   const conv = useConversationsStore.getState().conversations.find((c) => c.id === convId);
   if (!conv?.sessionId) return;
+  // Re-seed the active `/goal` (Claude only) from the transcript — INDEPENDENT of the history reload
+  // below, so it survives an empty rendered timeline (a conversation whose only on-disk content is
+  // a goal, its command echo dropped as noise). Goal state is disk-only.
+  if (conv.kind !== "codex") void refreshActiveGoal(convId, conv.sessionId);
   // Codex cold history comes from its rollout reader; Claude from its transcript (see
   // loadConversationHistory). Same result shape either way.
   const res =
@@ -1510,6 +1532,8 @@ export async function wipeAllData(): Promise<void> {
   useWorkflowLiveStore.getState().clear();
   useGitViewStore.getState().clearAll();
   useRemoteControlStore.getState().clearAll();
+  useGoalStore.getState().clearAll();
+  clearAllArtifactsCache();
   useCodexPlanUsageStore.getState().clear();
   useLastMessageSummaryStore.getState().clearAll();
 }
diff --git a/src/store/goalStore.test.ts b/src/store/goalStore.test.ts
new file mode 100644
index 0000000..15c92dc
--- /dev/null
+++ b/src/store/goalStore.test.ts
@@ -0,0 +1,312 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { GoalState } from "../ipc/client";
+
+const ok = <T>(data: T) => ({ status: "ok" as const, data });
+const err = (error: string) => ({ status: "error" as const, error });
+
+vi.mock("../ipc/client", () => ({
+  commands: {
+    loadSessionGoal: vi.fn(),
+  },
+}));
+
+import { commands } from "../ipc/client";
+import {
+  useGoalStore,
+  refreshActiveGoal,
+  scheduleGoalRefresh,
+  seedActiveGoalOnce,
+  beginGoalClearing,
+  settleGoalClearing,
+  endGoalClearing,
+  markGoalSeen,
+  hasSeenGoal,
+  isGoalCommand,
+} from "./goalStore";
+
+const GOAL: GoalState = { condition: "all tests pass", reason: "2 failing" };
+
+/** The IPC result shape of `load_session_goal`, for hand-resolved (deferred) mock reads. */
+type GoalRead = Awaited<ReturnType<typeof commands.loadSessionGoal>>;
+
+beforeEach(() => {
+  // clearAll resets byConv AND the module-level goalSeen / clearing guards.
+  useGoalStore.getState().clearAll();
+  vi.mocked(commands.loadSessionGoal).mockReset();
+});
+
+describe("goalStore", () => {
+  it("refreshActiveGoal loads the goal and marks the conversation goalSeen", async () => {
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(commands.loadSessionGoal).toHaveBeenCalledWith("sess-1");
+    expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+    expect(hasSeenGoal("c1")).toBe(true); // now worth a per-turn refetch
+  });
+
+  it("a null read records the key and drops goalSeen (no more per-turn reads)", async () => {
+    markGoalSeen("c1");
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(null));
+    await refreshActiveGoal("c1", "sess-1");
+    expect("c1" in useGoalStore.getState().byConv).toBe(true);
+    expect(useGoalStore.getState().byConv.c1).toBeNull();
+    expect(hasSeenGoal("c1")).toBe(false);
+  });
+
+  it("clears the goal (no IPC) when the conversation has no session id yet", async () => {
+    useGoalStore.getState().set("c1", GOAL);
+    markGoalSeen("c1");
+    await refreshActiveGoal("c1", null);
+    expect(commands.loadSessionGoal).not.toHaveBeenCalled();
+    expect(useGoalStore.getState().byConv.c1).toBeNull();
+    expect(hasSeenGoal("c1")).toBe(false);
+  });
+
+  it("leaves the last known goal untouched on an IPC error", async () => {
+    useGoalStore.getState().set("c1", GOAL);
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(err("boom"));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+  });
+
+  it("set short-circuits an equal update (same object reference kept)", () => {
+    useGoalStore.getState().set("c1", { condition: "x", reason: null });
+    const before = useGoalStore.getState().byConv;
+    useGoalStore.getState().set("c1", { condition: "x", reason: null });
+    expect(useGoalStore.getState().byConv).toBe(before);
+  });
+
+  it("clear guard: while the clear send is IN FLIGHT, a stale still-active read is frozen out", async () => {
+    useGoalStore.getState().set("c1", GOAL);
+    beginGoalClearing("c1"); // arm at click
+    useGoalStore.getState().set("c1", null); // optimistic hide
+    // A busy edge fires during the (possibly cold-spawn) send: the transcript still reads active.
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(useGoalStore.getState().byConv.c1).toBeNull(); // NOT flipped back on
+  });
+
+  it("clear guard: after settle (send accepted), a confirmed null read settles it; a new goal then shows", async () => {
+    useGoalStore.getState().set("c1", GOAL);
+    beginGoalClearing("c1");
+    useGoalStore.getState().set("c1", null);
+    settleGoalClearing("c1"); // send accepted → grace window
+    // The clear landed: a null read releases the guard.
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(null));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(useGoalStore.getState().byConv.c1).toBeNull();
+    // A genuinely new goal set afterwards is shown normally.
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+  });
+
+  it("clear ROLLBACK: on send failure, endGoalClearing releases so the still-active goal is restored", async () => {
+    useGoalStore.getState().set("c1", GOAL);
+    beginGoalClearing("c1");
+    useGoalStore.getState().set("c1", null); // optimistic hide
+    endGoalClearing("c1"); // send failed → release the guard
+    // The rollback refetch reads the still-active goal and restores the chip.
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+    await refreshActiveGoal("c1", "sess-1");
+    expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+  });
+
+  it("seedActiveGoalOnce reads the transcript once, then skips (survives relaunch, no re-reads)", async () => {
+    vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+    seedActiveGoalOnce("c1", "sess-1");
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+    expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+    seedActiveGoalOnce("c1", "sess-1");
+    expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+  });
+
+  it("isGoalCommand matches /goal invocations, not prose mentions", () => {
+    expect(isGoalCommand("/goal all tests pass")).toBe(true);
+    expect(isGoalCommand("/goal clear")).toBe(true);
+    expect(isGoalCommand("/goal")).toBe(true);
+    expect(isGoalCommand("  /goal x")).toBe(true); // leading whitespace ok
+    expect(isGoalCommand("/goalie save")).toBe(false); // word-bounded
+    expect(isGoalCommand("please run /goal")).toBe(false); // not at the start
+    expect(isGoalCommand("set a goal")).toBe(false);
+  });
+
+  it("a stale slow read never clobbers a newer one (per-conversation sequence)", async () => {
+    // Two callers race (e.g. a Flight Deck card seed and the turn edge). The OLDER read is slow
+    // and answers with a goal that has since been cleared; it must be dropped, not written.
+    let landSlow!: (v: GoalRead) => void;
+    const slow = new Promise<GoalRead>((resolve) => {
+      landSlow = resolve;
+    });
+    vi.mocked(commands.loadSessionGoal)
+      .mockImplementationOnce(() => slow)
+      .mockImplementationOnce(() => Promise.resolve(ok(null)));
+
+    const older = refreshActiveGoal("c1", "sess-1"); // in flight
+    const newer = refreshActiveGoal("c1", "sess-1"); // started after → wins
+    await newer;
+    expect(useGoalStore.getState().byConv.c1).toBeNull();
+
+    landSlow(ok(GOAL)); // the stale answer finally arrives
+    await older;
+    expect(useGoalStore.getState().byConv.c1).toBeNull(); // dropped: no resurrected goal
+    expect(hasSeenGoal("c1")).toBe(false); // and its bookkeeping was dropped too
+  });
+
+  it("scheduleGoalRefresh stops as soon as the value changes (no polling)", async () => {
+    vi.useFakeTimers();
+    try {
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+      scheduleGoalRefresh("c1", () => "sess-1");
+      expect(commands.loadSessionGoal).not.toHaveBeenCalled(); // first rung is delayed
+      await vi.advanceTimersByTimeAsync(300);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+      expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+      await vi.advanceTimersByTimeAsync(20_000);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1); // value moved → ladder stopped
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("scheduleGoalRefresh skips a rung with no session id yet (fresh conversation), keeping goalSeen", async () => {
+    vi.useFakeTimers();
+    try {
+      useGoalStore.getState().set("c1", null); // already read: no goal at send time
+      markGoalSeen("c1"); // the composer armed the gate on the `/goal` send
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+      let sessionId: string | null = null; // system/init hasn't landed yet
+      scheduleGoalRefresh("c1", () => sessionId);
+
+      await vi.advanceTimersByTimeAsync(300); // rung 1: no session id → no read AT ALL
+      expect(commands.loadSessionGoal).not.toHaveBeenCalled();
+      expect(hasSeenGoal("c1")).toBe(true); // not disarmed by a bogus "no session ⇒ no goal"
+      expect(useGoalStore.getState().byConv.c1).toBeNull();
+
+      sessionId = "sess-1"; // the spawn reports its session id
+      await vi.advanceTimersByTimeAsync(1000); // rung 2 fires the real read
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+      expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+      await vi.advanceTimersByTimeAsync(20_000);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("scheduleGoalRefresh keeps climbing on an UNSEEDED conversation whose first read is empty", async () => {
+    vi.useFakeTimers();
+    try {
+      // ⌘N then `/goal <condition>` as the very FIRST message: nothing ever read this conversation,
+      // so its slot is absent — not `null`. Treating that `undefined → null` move as "the value
+      // changed" used to settle the ladder on rung 1, on the exact case it exists for.
+      expect("c1" in useGoalStore.getState().byConv).toBe(false);
+      markGoalSeen("c1"); // the composer armed the gate on the `/goal` send
+      vi.mocked(commands.loadSessionGoal)
+        .mockResolvedValueOnce(ok(null)) // the goal_status write hasn't landed yet
+        .mockResolvedValue(ok(GOAL)); // …and then it does
+      scheduleGoalRefresh("c1", () => "sess-1");
+
+      await vi.advanceTimersByTimeAsync(300); // rung 1: empty
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+      expect(hasSeenGoal("c1")).toBe(true); // an empty read mid-ladder must not disarm the fallback
+      await vi.advanceTimersByTimeAsync(1000); // rung 2 finds the goal
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(2);
+      expect(useGoalStore.getState().byConv.c1).toEqual(GOAL);
+      expect(hasSeenGoal("c1")).toBe(true);
+      await vi.advanceTimersByTimeAsync(20_000);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(2); // value moved → ladder stopped
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("a /goal queued mid-turn outlives the ladder: the turn-edge gate stays armed", async () => {
+    vi.useFakeTimers();
+    try {
+      // The CLI QUEUES a local command until the running turn yields, so every rung can honestly
+      // read "no goal". The ladder must hand over to the turn edge with the gate still armed —
+      // otherwise the goal is live on disk and invisible on both surfaces for the rest of the run.
+      useGoalStore.getState().set("c1", null);
+      markGoalSeen("c1");
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(null));
+      scheduleGoalRefresh("c1", () => "sess-1");
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(4); // the whole ladder, all empty
+      expect(hasSeenGoal("c1")).toBe(true);
+
+      // …and with no ladder left pending, a genuinely empty read disarms again: the "goalless
+      // conversations read nothing per turn" perf gate self-heals within one turn.
+      await refreshActiveGoal("c1", "sess-1");
+      expect(hasSeenGoal("c1")).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("scheduleGoalRefresh gives up after its last rung (bounded, never a poll loop)", async () => {
+    vi.useFakeTimers();
+    try {
+      useGoalStore.getState().set("c1", null);
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(null)); // value never moves
+      scheduleGoalRefresh("c1", () => "sess-1");
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(4); // the whole ladder, then stop
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("clear / clearAll cancel a pending refresh ladder (no leaked timers)", async () => {
+    vi.useFakeTimers();
+    try {
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(GOAL));
+      scheduleGoalRefresh("c1", () => "sess-1");
+      useGoalStore.getState().clear("c1"); // conversation removed before the first rung
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(commands.loadSessionGoal).not.toHaveBeenCalled();
+      expect("c1" in useGoalStore.getState().byConv).toBe(false); // nothing resurrected the key
+
+      scheduleGoalRefresh("c2", () => "sess-2");
+      useGoalStore.getState().clearAll(); // wipe-all
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(commands.loadSessionGoal).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("a second scheduleGoalRefresh supersedes the first (one ladder per conversation)", async () => {
+    vi.useFakeTimers();
+    try {
+      useGoalStore.getState().set("c1", null);
+      vi.mocked(commands.loadSessionGoal).mockResolvedValue(ok(null));
+      const stale = vi.fn((): string | null => "sess-stale");
+      const fresh = vi.fn((): string | null => "sess-fresh");
+      scheduleGoalRefresh("c1", stale);
+      scheduleGoalRefresh("c1", fresh); // supersedes: the first ladder is cancelled
+      await vi.advanceTimersByTimeAsync(300);
+      expect(stale).not.toHaveBeenCalled();
+      expect(commands.loadSessionGoal).toHaveBeenCalledTimes(1);
+      expect(commands.loadSessionGoal).toHaveBeenCalledWith("sess-fresh");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("clear prunes byConv + goalSeen; clearAll wipes everything", () => {
+    useGoalStore.getState().set("c1", GOAL);
+    markGoalSeen("c1");
+    useGoalStore.getState().set("c2", { condition: "y", reason: null });
+    useGoalStore.getState().clear("c1");
+    expect("c1" in useGoalStore.getState().byConv).toBe(false);
+    expect(hasSeenGoal("c1")).toBe(false); // module-level slice pruned too
+    expect(useGoalStore.getState().byConv.c2).toBeTruthy();
+    markGoalSeen("c2");
+    useGoalStore.getState().clearAll();
+    expect(useGoalStore.getState().byConv).toEqual({});
+    expect(hasSeenGoal("c2")).toBe(false);
+  });
+});
diff --git a/src/store/goalStore.ts b/src/store/goalStore.ts
new file mode 100644
index 0000000..1991588
--- /dev/null
+++ b/src/store/goalStore.ts
@@ -0,0 +1,292 @@
+// Active `/goal` per conversation. `/goal <condition>` is Claude Code's native goal feature:
+// Claude keeps working across turns until a small fast model confirms the condition holds, then
+// auto-clears. We only DISPLAY it — a target icon on the Flight Deck card and a chip (+ clear
+// button) in the composer bar — so the user can see whether a conversation is driving toward a goal.
+//
+// Read from the on-disk transcript, NOT the live stream: the CLI records goal state as
+// `attachment` lines of `type:"goal_status"` that are DISK-ONLY (never emitted on stdout), so
+// there is nothing to intercept live. We fetch it from the Rust `load_session_goal`, which scans
+// the WHOLE transcript forward — NOT a tail read: a goal set early and never terminated is still
+// active at the end of the file, so no suffix would do (a raw-substring pre-filter keeps that
+// affordable; see `history.rs::load_active_goal`). Called at conversation load/reload, once per
+// Flight Deck card, and on turn edges — but ONLY for conversations that have (or recently had) a
+// goal (`goalSeen`), so a fleet of goalless conversations never pays a per-turn transcript read. Kept in memory, keyed by the STABLE
+// conversation id; the transcript is its durable source of truth, so nothing to persist. Unlike
+// Remote Control, a goal SURVIVES session end (the CLI restores it on `--resume`), so its state is
+// only forgotten when the conversation itself is removed (stop/remove/removeRepo/wipe).
+
+import { create } from "zustand";
+import { commands } from "../ipc/client";
+import type { GoalState } from "../ipc/client";
+
+// Conversations that have, or recently had, an active goal. Only these pay a transcript refetch on
+// turn edges (see useGlobalSessionEvents) — a conversation that never used `/goal` reads nothing
+// per turn. Seeded by any non-null read, by the load-time seed, and by issuing a `/goal` command.
+const goalSeen = new Set<string>();
+// Clear lifecycle (composer chip's clear button). `/goal clear` is a LOCAL command whose transcript
+// write lands asynchronously — and worse, `useClearGoal` may cold-spawn a `--resume` process first
+// (several seconds). So the guard is driven by the mutation lifecycle, NOT a wall-clock from the
+// click: `clearingInFlight` freezes the optimistic null while the send is in flight (no flicker
+// however long the spawn takes), then a short post-send `clearGraceUntil` window covers the write
+// landing. On failure the guard is released and the true (still-active) goal is refetched.
+const clearingInFlight = new Set<string>();
+const clearGraceUntil = new Map<string, number>();
+/** Post-send grace: how long after `/goal clear` is accepted we still ignore a "still active" read
+ *  (the transcript write can lag the send). */
+const CLEAR_GRACE_MS = 2500;
+// Sequence of the LATEST read started per conversation. Three callers race on the same slice (a
+// Flight Deck card seeding, a history load/reload, the per-turn busy edge) and NOTHING sequences
+// their IPC responses, so a slow older read can land AFTER a newer one and overwrite fresh state
+// with stale (e.g. resurrecting a goal the newer read just saw cleared). Stamped at call start and
+// re-checked before every write — same convention as `lastMessageSummary.currentSeq`. Module-level
+// and non-reactive: it gates writes, it is never rendered.
+const currentSeq = new Map<string, number>();
+// Bounded post-send refresh ladder (delays in ms). `/goal` is a LOCAL command: it may complete
+// without ever producing a model turn, so the busy edge that normally refetches the goal may NEVER
+// fire — and both the thread bubble and the CLI stdout are suppressed, so without this the user
+// gets literally zero feedback until their next message. One immediate read isn't enough either:
+// the `goal_status` transcript write lands asynchronously, and a brand-new conversation has no
+// session id until `system/init` arrives. Hence a few widening attempts that stop as soon as the
+// value actually moves — never a poll loop (perf: a goalless fleet must pay nothing).
+const REFRESH_LADDER_MS = [200, 800, 2000, 4000];
+/** In-flight refresh ladder per conversation: at most one, so a new schedule supersedes the old and
+ *  teardown can cancel it (a leaked `setTimeout` would fire a read for a removed conversation). */
+interface RefreshLadder {
+  timer: ReturnType<typeof setTimeout> | null;
+  cancelled: boolean;
+}
+const refreshLadders = new Map<string, RefreshLadder>();
+
+interface GoalStore {
+  /** convId → active goal, or `null` when no goal is active. Absent = not yet fetched. */
+  byConv: Record<string, GoalState | null>;
+  set: (convId: string, goal: GoalState | null) => void;
+  clear: (convId: string) => void;
+  /** Drop every conversation's goal (wipe-all). */
+  clearAll: () => void;
+}
+
+export const useGoalStore = create<GoalStore>((set) => ({
+  byConv: {},
+  set: (convId, goal) =>
+    set((s) => {
+      // Short-circuit a genuine no-op (the turn-edge refetch runs every turn) so subscribers don't
+      // re-render. Guarded on the KEY already existing: a first fetch that returns `null` (no goal)
+      // must still RECORD the key, so `seedActiveGoalOnce` knows this conversation has been read.
+      if (convId in s.byConv && sameGoal(s.byConv[convId], goal)) return s;
+      return { byConv: { ...s.byConv, [convId]: goal } };
+    }),
+  clear: (convId) => {
+    // Prune every per-conversation goal slice on the same removal paths as the rest of the app.
+    goalSeen.delete(convId);
+    clearingInFlight.delete(convId);
+    clearGraceUntil.delete(convId);
+    // Dropping the seq also invalidates any read still in flight for this conversation: its
+    // stamp no longer matches, so it can't resurrect the key we're about to delete.
+    currentSeq.delete(convId);
+    cancelGoalRefresh(convId);
+    set((s) => {
+      if (!(convId in s.byConv)) return s;
+      const next = { ...s.byConv };
+      delete next[convId];
+      return { byConv: next };
+    });
+  },
+  clearAll: () => {
+    goalSeen.clear();
+    clearingInFlight.clear();
+    clearGraceUntil.clear();
+    currentSeq.clear();
+    for (const convId of [...refreshLadders.keys()]) cancelGoalRefresh(convId);
+    set({ byConv: {} });
+  },
+}));
+
+function sameGoal(a: GoalState | null, b: GoalState | null): boolean {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.condition === b.condition && (a.reason ?? null) === (b.reason ?? null);
+}
+
+/** Does this composer text invoke the `/goal` local command (set / clear / status)? Used to (a) mark
+ *  the conversation `goalSeen` so the next turn edge picks up a freshly set goal, and (b) send it
+ *  silently — goal plumbing is represented by the chip, never as a thread bubble. Word-bounded so a
+ *  message that merely mentions `/goal` in prose does not match. */
+export function isGoalCommand(text: string): boolean {
+  return /^\/goal(\s|$)/.test(text.trimStart());
+}
+
+/** Mark a conversation as having a goal to track, so its turn edges refetch (see the `goalSeen`
+ *  gate). Called when the user issues a `/goal` command — the goal_status lands on disk a moment
+ *  later, so the gate must be armed before the next turn edge, not by the read itself. */
+export function markGoalSeen(convId: string): void {
+  goalSeen.add(convId);
+}
+
+/** Whether a conversation is worth a per-turn goal refetch (it has, or recently had, a goal). */
+export function hasSeenGoal(convId: string): boolean {
+  return goalSeen.has(convId);
+}
+
+/** Arm the clear guard: freeze the optimistic null while `/goal clear` is in flight (however long a
+ *  cold `--resume` spawn takes). Call at click, before any async. */
+export function beginGoalClearing(convId: string): void {
+  clearingInFlight.add(convId);
+}
+
+/** The clear send was accepted: switch from "in flight" to a short grace window while the transcript
+ *  write lands, then normal refetches resume. */
+export function settleGoalClearing(convId: string): void {
+  clearingInFlight.delete(convId);
+  clearGraceUntil.set(convId, Date.now() + CLEAR_GRACE_MS);
+}
+
+/** The clear send FAILED: release the guard entirely so the caller's rollback refetch can restore
+ *  the still-active goal (never leave the chip wrongly hidden over a live goal). */
+export function endGoalClearing(convId: string): void {
+  clearingInFlight.delete(convId);
+  clearGraceUntil.delete(convId);
+}
+
+/**
+ * Refresh a conversation's active goal from its on-disk transcript. `sessionId` is the CLI
+ * session id (the transcript key); a conversation that never sent a message has none → no goal.
+ * A read failure is non-fatal (the next turn-edge refetch corrects it) and leaves the last known
+ * value untouched. Codex conversations have no Claude transcript, so callers gate this off for them.
+ * Concurrency-safe: several callers race, so each call stamps a per-conversation sequence and a
+ * response is DROPPED if a newer call started meanwhile (never overwrite fresh state with stale).
+ */
+export async function refreshActiveGoal(convId: string, sessionId: string | null | undefined): Promise<void> {
+  const seq = (currentSeq.get(convId) ?? 0) + 1;
+  currentSeq.set(convId, seq);
+  if (!sessionId) {
+    if (clearingInFlight.has(convId)) return; // a clear is racing — don't clobber it
+    // Same rule as the empty read below: while a ladder is pending, "no session id yet" is a
+    // transient, not a verdict, so it must not disarm the gate the composer just armed.
+    if (!refreshLadders.has(convId)) goalSeen.delete(convId);
+    useGoalStore.getState().set(convId, null);
+    return;
+  }
+  const res = await commands.loadSessionGoal(sessionId);
+  if (res.status !== "ok") {
+    console.error("loadSessionGoal failed:", res.error);
+    return;
+  }
+  // Stale response: a newer refresh started while this read was in flight (or the conversation was
+  // removed, dropping the seq). The newer answer is the truthful one, so drop this whole response
+  // — including its goalSeen / grace bookkeeping — instead of writing yesterday's transcript state.
+  if (currentSeq.get(convId) !== seq) return;
+  // A clear is still in flight (send not yet accepted): keep the optimistic null, ignore any read.
+  if (clearingInFlight.has(convId)) return;
+  const grace = clearGraceUntil.get(convId);
+  if (grace !== undefined && Date.now() < grace) {
+    // Post-send grace: accept a confirmed null (the clear landed → done), but ignore a still-active
+    // read (the transcript write hasn't caught up) so the chip doesn't flicker back on.
+    if (res.data == null) {
+      clearGraceUntil.delete(convId);
+      goalSeen.delete(convId);
+      useGoalStore.getState().set(convId, null);
+    }
+    return;
+  }
+  clearGraceUntil.delete(convId);
+  if (res.data != null) goalSeen.add(convId);
+  // A refresh ladder is pending ⇒ a `/goal` send is still landing, so an empty read means "the
+  // transcript write hasn't caught up", NOT "no goal" — the same call the ladder's missing-session-id
+  // rung already makes, applied to the read itself. Disarming here would strip the gate the composer
+  // armed on the send, and that gate is what makes the per-turn refetch (see `hasSeenGoal` in
+  // useGlobalSessionEvents) the fallback the ladder hands over to when it runs out of rungs: a goal
+  // that lands late would then stay invisible on BOTH surfaces for the rest of the run, with nothing
+  // left to correct it. A genuinely goalless conversation is disarmed by the next ladder-free read,
+  // so the "goalless fleets read nothing per turn" perf gate self-heals within one turn.
+  else if (!refreshLadders.has(convId)) goalSeen.delete(convId);
+  useGoalStore.getState().set(convId, res.data);
+}
+
+/** Cancel a conversation's pending refresh ladder, if any. Marks it cancelled as well as clearing
+ *  the timer, because a rung may be awaiting its IPC read right now — its continuation must not
+ *  re-arm the next rung after teardown. */
+function cancelGoalRefresh(convId: string): void {
+  const ladder = refreshLadders.get(convId);
+  if (!ladder) return;
+  ladder.cancelled = true;
+  if (ladder.timer !== null) clearTimeout(ladder.timer);
+  refreshLadders.delete(convId);
+}
+
+/**
+ * Refresh a conversation's goal shortly after a `/goal` command was sent, on a short bounded
+ * ladder (see `REFRESH_LADDER_MS`). Without it a `/goal <condition>` gives NO feedback at all: the
+ * bubble is suppressed, the CLI's stdout is suppressed, and being a local command it may never
+ * produce the model turn whose busy edge normally refetches the goal.
+ *
+ * Stops as soon as the stored value CHANGES relative to the snapshot taken here — which covers both
+ * directions (a goal appearing after `/goal <condition>`, and a goal disappearing after
+ * `/goal clear`) — otherwise runs out of rungs and gives up. Only one ladder per conversation: a
+ * new schedule supersedes the previous one, and `clear`/`clearAll` cancel it.
+ *
+ * `resolveSessionId` is re-invoked on EVERY attempt and supplied by the CALLER: a brand-new
+ * conversation has no session id until `system/init` lands, and this module must not import
+ * `conversationsStore` (which already imports this one — that would be a circular import).
+ */
+export function scheduleGoalRefresh(
+  convId: string,
+  resolveSessionId: () => string | null | undefined,
+): void {
+  cancelGoalRefresh(convId); // one ladder per conversation: the newest send wins
+  // ⚠️ `undefined` (never read) is NOT a value to settle on: to the user it means exactly what
+  // `null` (read, no goal) means — nothing shown. Coercing it here is what makes the ladder work on
+  // a BRAND-NEW conversation, the very case it exists for: ⌘N then `/goal <condition>` as the first
+  // message leaves the slot unseeded (`loadConversationHistory` bails for want of a session id, and
+  // no Flight Deck card is mounted to seed it), so the first rung reads before the `goal_status`
+  // write lands — and an `undefined → null` slot move would read as "the value changed" and settle
+  // the ladder on rung 1, on the exact case it was added for.
+  const before = useGoalStore.getState().byConv[convId] ?? null;
+  const ladder: RefreshLadder = { timer: null, cancelled: false };
+  refreshLadders.set(convId, ladder);
+
+  const settle = () => {
+    if (refreshLadders.get(convId) === ladder) refreshLadders.delete(convId);
+  };
+
+  const step = (rung: number) => {
+    if (ladder.cancelled) return;
+    if (rung >= REFRESH_LADDER_MS.length) return settle(); // out of rungs: the turn edge takes over
+    ladder.timer = setTimeout(() => {
+      ladder.timer = null;
+      if (ladder.cancelled) return;
+      const sessionId = resolveSessionId();
+      if (!sessionId) {
+        // No session id YET (the spawn hasn't reported `system/init`). Deliberately do NOT call
+        // `refreshActiveGoal` here: it treats a missing session id as an authoritative "no goal"
+        // and disarms `goalSeen` — which is exactly the gate the composer just armed for this
+        // send. In the ladder, a missing session id means "not yet", not "no goal" → skip the rung.
+        step(rung + 1);
+        return;
+      }
+      void refreshActiveGoal(convId, sessionId).then(() => {
+        if (ladder.cancelled) return;
+        // The value moved (goal appeared, or cleared) → the write landed, nothing left to wait for.
+        if (!sameGoal(before, useGoalStore.getState().byConv[convId] ?? null)) return settle();
+        step(rung + 1);
+      });
+    }, REFRESH_LADDER_MS[rung]);
+  };
+
+  step(0);
+}
+
+/** Seed a conversation's goal from its transcript the FIRST time it's needed this run (a Flight Deck
+ *  card mounting), so a goal set in a PRIOR app session shows right after quit/relaunch — the goal
+ *  lives on disk but this store is in-memory. No-op once the conversation has been read (its key is
+ *  present, even if the value is `null`). Live freshness then comes from the turn-edge refetch and
+ *  direct clears; a stopped conversation re-seeds on its next history reload. */
+export function seedActiveGoalOnce(convId: string, sessionId: string | null | undefined): void {
+  if (convId in useGoalStore.getState().byConv) return;
+  void refreshActiveGoal(convId, sessionId);
+}
+
+/** Reactive active goal for one conversation (`null` when none / not yet fetched). */
+export function useActiveGoal(convId: string | null | undefined): GoalState | null {
+  return useGoalStore((s) => (convId ? s.byConv[convId] ?? null : null));
+}
diff --git a/src/ui/conductor-conversation.css b/src/ui/conductor-conversation.css
index 24e2f7e..97a2dab 100644
--- a/src/ui/conductor-conversation.css
+++ b/src/ui/conductor-conversation.css
@@ -284,6 +284,89 @@
 .cv-tool-cmd { margin:0 0 10px; padding:8px 10px; background:#0e0e11; border:1px solid var(--wf-line); border-radius:6px; font-size:11.5px; line-height:1.5; color:#f0cd97; white-space:pre-wrap; word-break:break-word; }
 .cv-tool-cmd:last-child { margin-bottom:0; }
 
+/* ── Artifact card (inline `Artifact` publish) ───────────────────────────────
+   A polished, self-standing card (NOT the plain tool-row chrome): a rounded favicon
+   tile, a strong headline + a muted "Artifact · <label>" sub-line, and a trailing
+   "open" glyph that warms to coral on hover. Reads as a deliverable to open, not a
+   tool that ran. */
+.cv-art { display:flex; align-items:center; gap:11px; padding:10px 12px; border:1px solid var(--wf-line); border-radius:10px; background:var(--wf-panel); transition:border-color .14s ease, background .14s ease; }
+.cv-art[data-open] { cursor:pointer; }
+.cv-art[data-open]:hover { border-color:color-mix(in srgb, var(--wf-accent) 45%, var(--wf-line)); background:var(--wf-panel-3, var(--wf-panel)); }
+.cv-art-tile { flex:none; width:34px; height:34px; display:flex; align-items:center; justify-content:center; font-size:18px; line-height:1; border:1px solid var(--wf-line); border-radius:9px; background:var(--wf-bg-2); }
+.cv-art-body { flex:1; min-width:0; display:flex; flex-direction:column; gap:2px; }
+.cv-art-title { font-size:12.5px; color:var(--wf-tx-hi); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.cv-art-sub { display:flex; align-items:center; min-width:0; font-size:11px; color:var(--wf-tx-lo); }
+.cv-art-kind { flex:none; }
+.cv-art-detail { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.cv-art-detail::before { content:"·"; margin:0 5px; opacity:.55; }
+.cv-art-go { flex:none; display:inline-flex; align-items:center; color:var(--wf-tx-lo); transition:color .14s ease; }
+.cv-art[data-open]:hover .cv-art-go { color:var(--wf-accent); }
+.cv-art-go .wf-ico { width:15px; height:15px; }
+/* Failed/refused publish: surface it as an error (not the neutral "Unavailable" degrade) — the
+   reason rides the sub-line, full text on hover (title attr). Zero-silent-error. */
+.cv-art[data-state="error"] { border-color:color-mix(in srgb, var(--wf-err) 40%, var(--wf-line)); background:var(--wf-err-bg); }
+.cv-art[data-state="error"] .cv-art-tile { border-color:color-mix(in srgb, var(--wf-err) 45%, var(--wf-line)); }
+.cv-art[data-state="error"] .cv-art-kind,
+.cv-art[data-state="error"] .cv-art-detail,
+.cv-art[data-state="error"] .cv-art-go { color:var(--wf-err); }
+
+/* ── Artifacts popover (composer "Artifacts (N)" chip) ───────────────────────
+   Portal-rendered under the chip (fixed-positioned, opens upward from the composer).
+   Lists every artifact of the conversation newest-first, each with its version history. */
+.cv-artpop-backdrop { position:fixed; inset:0; z-index:150; }
+.cv-artpop { z-index:151; min-width:260px; max-width:320px; overflow-y:auto; overscroll-behavior:contain; padding:6px; display:flex; flex-direction:column; gap:3px; background:var(--wf-panel-2); border:1px solid var(--wf-line-2); border-radius:10px; box-shadow:0 14px 36px -12px #000, 0 0 0 1px #0006; }
+.cv-artpop-h { display:flex; align-items:center; gap:6px; padding:4px 6px 6px; font-size:10.5px; font-weight:600; letter-spacing:.3px; text-transform:uppercase; color:var(--wf-tx-xlo, var(--wf-tx-lo)); }
+.cv-artpop-h .wf-ico { width:12px; height:12px; }
+.cv-artpop-count { margin-left:auto; font-variant-numeric:tabular-nums; }
+.cv-artpop-item { display:flex; flex-direction:column; }
+.cv-artpop-head { display:flex; align-items:stretch; gap:2px; }
+.cv-artpop-open { flex:1; min-width:0; display:flex; align-items:center; gap:8px; padding:7px 8px; border:0; border-radius:7px; background:transparent; color:var(--wf-tx); font:inherit; text-align:left; cursor:pointer; transition:background .12s ease; }
+.cv-artpop-open:hover:not(:disabled) { background:var(--wf-panel-3, var(--wf-panel)); }
+.cv-artpop-open:disabled { cursor:default; opacity:.7; }
+.cv-artpop-open .wf-ico:last-child { flex:none; width:13px; height:13px; color:var(--wf-tx-lo); }
+.cv-artpop-fav { flex:none; width:20px; text-align:center; font-size:15px; line-height:1; }
+.cv-artpop-main { flex:1; min-width:0; display:flex; flex-direction:column; gap:1px; }
+.cv-artpop-title { font-size:12px; color:var(--wf-tx-hi); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.cv-artpop-desc { font-size:11px; color:var(--wf-tx-lo); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.cv-artpop-vbtn { flex:none; align-self:center; display:inline-flex; align-items:center; gap:2px; padding:3px 6px; border:1px solid var(--wf-line); border-radius:6px; background:transparent; color:var(--wf-tx-lo); font:inherit; font-size:11px; cursor:pointer; transition:background .12s ease, color .12s ease; }
+.cv-artpop-vbtn:hover { color:var(--wf-tx-hi); background:var(--wf-panel-3, var(--wf-panel)); }
+.cv-artpop-vbtn .wf-ico { width:11px; height:11px; }
+.cv-artpop-vbtn[aria-expanded="true"] .wf-ico { transform:rotate(180deg); }
+.cv-artpop-v1 { flex:none; align-self:center; padding:3px 6px; font-size:11px; color:var(--wf-tx-xlo, var(--wf-tx-lo)); }
+.cv-artpop-versions { display:flex; flex-direction:column; gap:1px; margin:1px 0 4px 30px; padding-left:8px; border-left:1px solid var(--wf-line); }
+.cv-artpop-vrow { display:flex; align-items:center; gap:8px; padding:3px 4px; font-size:11px; color:var(--wf-tx-lo); }
+.cv-artpop-vn { flex:none; color:var(--wf-tx-xlo, var(--wf-tx-lo)); font-variant-numeric:tabular-nums; }
+.cv-artpop-vlabel { flex:1; min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+
+/* ── Artifact reference card (a hosted-artifact link in Claude's prose) ───────
+   A compact inline pill in place of a plain anchor. Flows inside a paragraph. */
+.cv-artref { display:inline-flex; align-items:center; gap:5px; vertical-align:middle; max-width:100%; margin:0 1px; padding:1px 8px 2px; border:1px solid var(--wf-line); border-radius:7px; background:var(--wf-panel); color:var(--wf-tx-hi); cursor:pointer; line-height:1.3; transition:border-color .14s ease, background .14s ease; }
+.cv-artref:hover { border-color:color-mix(in srgb, var(--wf-accent) 45%, var(--wf-line)); background:var(--wf-panel-3, var(--wf-panel)); }
+.cv-artref-fav { flex:none; font-size:12px; line-height:1; }
+.cv-artref-t { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; max-width:24ch; }
+.cv-artref .wf-ico { flex:none; width:12px; height:12px; color:var(--wf-tx-lo); }
+.cv-artref:hover .wf-ico { color:var(--wf-accent); }
+
+/* ── Artifact viewer (side-region rendered preview) ──────────────────────────
+   Fills the side region. HTML renders in a sandboxed iframe (white backdrop so a
+   light artifact doesn't flash the dark app bg); Markdown via the thread renderer. */
+.cv-artview { flex:1; min-width:0; min-height:0; display:flex; flex-direction:column; background:var(--wf-bg); border-left:1px solid var(--wf-line); }
+.cv-artview-h { flex:none; display:flex; align-items:center; gap:8px; padding:8px 10px; border-bottom:1px solid var(--wf-line); background:var(--wf-panel); }
+.cv-artview-fav { flex:none; font-size:15px; line-height:1; }
+.cv-artview-title { flex:1; min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font-size:12.5px; color:var(--wf-tx-hi); }
+.cv-artview-btn { flex:none; display:inline-flex; align-items:center; justify-content:center; width:24px; height:24px; border:0; border-radius:6px; background:transparent; color:var(--wf-tx-lo); cursor:pointer; transition:background .12s ease, color .12s ease; }
+.cv-artview-btn:hover { background:var(--wf-panel-3, var(--wf-panel)); color:var(--wf-tx-hi); }
+.cv-artview-btn .wf-ico { width:15px; height:15px; }
+.cv-artview-body { flex:1; min-height:0; display:flex; flex-direction:column; overflow:hidden; }
+.cv-artview-frame { flex:1; width:100%; border:0; background:#fff; }
+.cv-artview-md { flex:1; min-height:0; overflow-y:auto; padding:14px 16px; }
+.cv-artview-msg { flex:1; display:flex; flex-direction:column; align-items:center; justify-content:center; gap:12px; padding:24px; text-align:center; color:var(--wf-tx-lo); font-size:12.5px; }
+.cv-artview-msg p { margin:0; max-width:34ch; }
+.cv-artview-msgfav { font-size:28px; opacity:.7; }
+.cv-artview-open { display:inline-flex; align-items:center; gap:6px; padding:6px 12px; border:1px solid var(--wf-line); border-radius:8px; background:var(--wf-panel); color:var(--wf-tx-hi); cursor:pointer; font:inherit; font-size:12px; }
+.cv-artview-open:hover { border-color:var(--wf-accent); color:var(--wf-accent); }
+.cv-artview-open .wf-ico { width:14px; height:14px; }
+
 /* ── Grouped tool steps ──────────────────────────────────────────────────────
    A run of consecutive tool calls collapses into one "Ran N steps" section
    (claude.ai/code shape). Collapsed by default; the body lists compact step rows,
@@ -810,3 +893,13 @@
   background:var(--wf-run-bg);
   border-color:#27513f;
 }
+
+/* Active `/goal` button in the composer foot bar: a small target chip (icon only — goals are
+   long, so the condition lives in the click-popover, not inline). Only mounts when a goal is
+   active (see GoalChip). The target glyph is coral to read as "on". */
+.cv-goal-chip .wf-ico:first-child { color:var(--wf-accent); opacity:.95; }
+/* The goal popover: header + full condition (wraps) + latest reason + a clear action. Reuses
+   the shared .wf-pop-h / .wf-pop-act; sizing mirrors the context popover (.wf-pop-ctx). */
+.cv-goal-pop { min-width:210px; max-width:min(320px, calc(100vw - 24px)); padding:10px 12px; display:flex; flex-direction:column; gap:7px; }
+.cv-goal-pop-cond { font-size:12.5px; line-height:1.4; color:var(--wf-tx-hi); overflow-wrap:break-word; white-space:pre-wrap; }
+.cv-goal-pop-reason { font-size:11px; line-height:1.4; color:var(--wf-tx-lo); overflow-wrap:break-word; }
diff --git a/src/ui/conductor-flightdeck.css b/src/ui/conductor-flightdeck.css
index bc26bb4..577070e 100644
--- a/src/ui/conductor-flightdeck.css
+++ b/src/ui/conductor-flightdeck.css
@@ -90,6 +90,12 @@
 .ag-backend .wf-claude, .ag-backend .wf-codex { width:14px; height:14px; }
 .ag-backend .wf-claude { color:var(--wf-accent); }
 .ag-backend.codex .wf-codex { color:var(--wf-tx-hi); }
+/* Active `/goal` — a clickable coral target that opens the goal popover (shown only when a goal
+   is active). Reset button chrome + a subtle hover, matching the card's other clickable bits. */
+.ag-goal { display:inline-flex; align-items:center; justify-content:center; flex:0 0 auto; font:inherit; padding:3px; margin:-3px 0; border:0; border-radius:6px; background:transparent; color:var(--wf-accent); cursor:pointer; transition:background .12s ease; }
+.ag-goal:hover, .ag-goal[data-open] { background:var(--wf-bg-2); }
+.ag-goal:focus-visible { outline:2px solid var(--wf-accent); outline-offset:1px; }
+.ag-goal .wf-ico { width:15px; height:15px; }
 /* "Last message you sent" — a few-word summary (≤6 words) of the user's latest message,
    under the tags. A small self-hugging box (not full width) with a coral "reply" arrow
    marking it as YOUR voice, distinct from the agent's activity line below. Live-only. */
diff --git a/src/ui/conductor-wirekit.css b/src/ui/conductor-wirekit.css
index cb72127..46783d6 100644
--- a/src/ui/conductor-wirekit.css
+++ b/src/ui/conductor-wirekit.css
@@ -460,8 +460,13 @@
 .wf-spin-fast { animation: wf-spin .8s linear infinite; transform-origin:50% 50%; }
 /* Real plan-usage window: label · % · reset on top, fill bar under. */
 .wf-pop-usage { display:flex; flex-direction:column; gap:4px; }
-.wf-pop-usage-top { display:flex; align-items:center; justify-content:space-between; font-size:11.5px; color:var(--wf-tx-lo); }
-.wf-pop-usage-top .wf-mono { color:var(--wf-tx-hi); }
+.wf-pop-usage-top { display:flex; align-items:center; gap:8px; justify-content:space-between; font-size:11.5px; color:var(--wf-tx-lo); }
+/* The label is data-driven for model-scoped caps (it carries the model's name), so it must
+   never push the figure out of the popover: it ellipsises, the % + reset never shrinks.
+   Targeted by CLASS, not by position: a `:first-child` rule would silently stop applying if
+   this row ever gained a leading element, and the breakage would only surface on a long name. */
+.wf-pop-usage-label { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.wf-pop-usage-top .wf-mono { color:var(--wf-tx-hi); flex:none; }
 /* Actionable error card when the real % can't be fetched (cause + next step). */
 .wf-pop-err { display:flex; flex-direction:column; gap:4px; }
 .wf-pop-err-msg { font-size:11.5px; font-weight:600; color:var(--wf-tx-hi); }
diff --git a/src/ui/kit.tsx b/src/ui/kit.tsx
index 0f8a8fb..9b2b99f 100644
--- a/src/ui/kit.tsx
+++ b/src/ui/kit.tsx
@@ -62,6 +62,9 @@ const WF_PATHS: Record<string, string> = {
   globe: "M11 3a8 8 0 1 0 0 16 8 8 0 0 0 0-16ZM3 11h16M11 3c2.4 2.2 2.4 13.8 0 16M11 3c-2.4 2.2-2.4 13.8 0 16",
   // A magic wand + sparkle — a skill/command invocation.
   wand: "M4 18 13 9M15 3l.9 2.1L18 6l-2.1.9L15 9l-.9-2.1L12 6l2.1-.9z",
+  // A document with a sparkle — a published `Artifact` (a generated, hosted deliverable).
+  // Distinct from `file` (plain doc), `globe` (remote control) and `layers` (extensions).
+  artifact: "M6 3h6l4 4v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2ZM12 3v4h4M10 10l1 2 2 1-2 1-1 2-1-2-2-1 2-1z",
   // A plug — an MCP server tool call.
   plug: "M7 3v4M13 3v4M5 7h10v2a5 5 0 0 1-10 0V7ZM10 14v5",
   // File-explorer context-menu glyphs (rename / copy / cut / paste / copy-path / reveal).
@@ -77,6 +80,8 @@ const WF_PATHS: Record<string, string> = {
   mute: "M4 8.5h3l4-3v11l-4-3H4zM14.5 9l4 4M18.5 9l-4 4",
   // A steaming coffee mug — the "Caffeinate" (keep the Mac awake) toggle.
   coffee: "M5 9h8v5a3 3 0 0 1-3 3H8a3 3 0 0 1-3-3zM13 11h1.5a2 2 0 0 1 0 4H13M8 4c1 1-1 2 0 3.2M11 4c1 1-1 2 0 3.2",
+  // A bullseye / target — an active `/goal` (Claude working toward a completion condition).
+  target: "M11 4a7 7 0 1 0 0 14 7 7 0 0 0 0-14M11 7.8a3.2 3.2 0 1 0 0 6.4 3.2 3.2 0 0 0 0-6.4M11 11h.01",
 };
 
 export function Ico({ name, className }: { name: string; className?: string }) {
@@ -312,8 +317,11 @@ const MENU_M = 8;
 
 /** Compute a collision-aware fixed placement from the trigger's rect, honouring
  *  `align`/`up` as the PREFERRED sides and flipping when a side lacks room. Mirrors
- *  CardPopover's approach so portaled menus behave like the other card popovers. */
-function menuPortalPlacement(r: DOMRect, align?: "right", up?: boolean): MenuPortalPos {
+ *  CardPopover's approach so portaled menus behave like the other card popovers.
+ *  `pop` is the popover's own measured rect (once mounted) — used to keep the WHOLE
+ *  popover on-screen for any width, so e.g. a right-aligned menu on a far-left card
+ *  never runs off the left edge. */
+export function menuPortalPlacement(r: DOMRect, align?: "right", up?: boolean, pop?: DOMRect | null): MenuPortalPos {
   const vw = window.innerWidth;
   const vh = window.innerHeight;
   // Enough to hold the tallest menu body (the usage card); used only for the flip test.
@@ -331,9 +339,16 @@ function menuPortalPlacement(r: DOMRect, align?: "right", up?: boolean): MenuPor
   };
   if (useUp) pos.bottom = vh - r.top + 6;
   else pos.top = r.bottom + 6;
-  // Anchor horizontally to the trigger's matching edge, clamped on-screen.
-  if (align === "right") pos.right = Math.max(MENU_M, vw - r.right);
-  else pos.left = Math.min(Math.max(MENU_M, r.left), Math.max(MENU_M, vw - 240 - MENU_M));
+  // Horizontal: anchor to the trigger's matching edge (align hint), then clamp so NEITHER edge
+  // leaves the viewport. Positioned via `left` always. The popover is mounted (hidden) BEFORE this
+  // runs, so `pop` carries its real measured width from the first placement pass; the `240` is only
+  // a defensive default for a missing ref. `right`-aligned menus put the popover's right edge at the
+  // trigger's right edge; the clamp then slides it back on-screen if that would overflow the left —
+  // the fix for a far-left card whose menu used to open off-screen.
+  const w = pop?.width || 240;
+  const preferredLeft = align === "right" ? r.right - w : r.left;
+  const maxLeft = Math.max(MENU_M, vw - w - MENU_M);
+  pos.left = Math.min(Math.max(MENU_M, preferredLeft), maxLeft);
   return pos;
 }
 
@@ -404,7 +419,9 @@ export function Menu({
     }
     const measure = () => {
       const r = triggerRef.current?.getBoundingClientRect();
-      if (r) setPos(menuPortalPlacement(r, align, up));
+      // Feed the popover's OWN measured rect so the placement keeps its full width on-screen
+      // (it is already mounted-but-hidden by the time this runs — see the render below).
+      if (r) setPos(menuPortalPlacement(r, align, up, popRef.current?.getBoundingClientRect()));
     };
     measure();
     window.addEventListener("resize", measure);
@@ -430,8 +447,12 @@ export function Menu({
   // Portaled popover: fixed-positioned at `pos`, mounted on document.body so no ancestor
   // `overflow` can clip it. `.up`/`.right` positioning classes are dropped in portal mode
   // (the inline `pos` owns every side); `.portaled` adds z-index + scroll clamp.
-  const popStyle: CSSProperties | undefined =
-    portal && pos
+  // Portaled: mount the popover immediately (so its width can be measured) but keep it
+  // hidden until the first placement lands — `useLayoutEffect` positions it before paint,
+  // so there is no visible flash at the origin.
+  const popStyle: CSSProperties | undefined = !portal
+    ? undefined
+    : pos
       ? {
           position: "fixed",
           left: pos.left,
@@ -440,7 +461,7 @@ export function Menu({
           bottom: pos.bottom,
           maxHeight: pos.maxHeight,
         }
-      : undefined;
+      : { position: "fixed", left: 0, top: 0, visibility: "hidden" };
   const popover = (
     <div
       ref={popRef}
@@ -458,7 +479,7 @@ export function Menu({
   return (
     <span className="wf-menu" ref={triggerRef}>
       {clonedTrigger}
-      {portal ? (pos ? createPortal(popover, document.body) : null) : popover}
+      {portal ? createPortal(popover, document.body) : popover}
     </span>
   );
 }
@@ -547,11 +568,23 @@ function resetToEpochSeconds(s: string | null): number | null {
   return Number.isNaN(ms) ? null : Math.floor(ms / 1000);
 }
 
+/** A rate-limit window scoped to ONE model rather than the whole account (e.g. Fable's
+ *  weekly allowance). Mirrors the core's `ScopedUsageWindow`; the `label` comes straight
+ *  from the endpoint, so a renamed/added scoped model needs no frontend change. */
+export interface PlanUsageScopedWindow {
+  label: string;
+  group: string | null;
+  window: PlanUsageWindow;
+}
+
 /** Real plan-usage %, the precise figure the stream does NOT carry. Each window is
  *  null when the endpoint did not report it. Mirrors the core's `PlanUsage`. */
 export interface PlanUsageInfo {
   five_hour: PlanUsageWindow | null;
   seven_day: PlanUsageWindow | null;
+  /** Model-scoped caps, listed alongside the two account-wide windows. Optional because
+   *  the core marks it `serde(default)` — an absent value reads as "none". */
+  scoped?: PlanUsageScopedWindow[];
 }
 
 /** Why the real plan-usage fetch failed — mirrors the core's `UsageError` union so
@@ -731,7 +764,12 @@ function UsageRow({
   return (
     <div className="wf-pop-usage">
       <div className="wf-pop-usage-top">
-        <span>{label}</span>
+        {/* Explicitly classed, NOT styled via a positional selector: a model-scoped cap's
+            label is data-driven (it carries the model's name), so it is the one label that
+            can be long enough to push the figure out of the popover, and it MUST keep its
+            ellipsis. A `:first-child` rule would stop applying the day this markup gains a
+            leading element — silently, the failure only showing up on a long model name. */}
+        <span className="wf-pop-usage-label">{label}</span>
         <span className="wf-mono">
           {pct}%{reset ? ` · ${fmtReset(reset)}` : ""}
         </span>
@@ -757,6 +795,14 @@ function planStatus(status: string | null): { label: string; color: string } {
   }
 }
 
+/** Label a model-scoped cap: its name plus the window it spans ("Fable · 7d"), so it reads in
+ *  the same idiom as the "5h"/"7d" rows above it. The suffix is derived from the payload's
+ *  `group`, and dropped when that is absent or unknown — a duration is never guessed. */
+function scopedUsageLabel(s: PlanUsageScopedWindow): string {
+  const win = s.group === "weekly" ? "7d" : s.group === "session" ? "5h" : null;
+  return win ? `${s.label} · ${win}` : s.label;
+}
+
 /** Human label for a rate-limit window type. */
 function planWindow(limitType: string | null): string {
   switch (limitType) {
@@ -895,6 +941,18 @@ function ContextUsageBody({
               fallbackReset={plan?.limitType === "seven_day" ? plan.resetsAt : null}
             />
           ) : null}
+          {/* Model-scoped caps (e.g. Fable's weekly allowance), listed after the two
+              account-wide windows. Rendered straight off the payload — no fallback reset,
+              since a scoped window that hasn't started reports none and the coarse `plan`
+              reset belongs to a different (account-wide) cap. */}
+          {(usage?.scoped ?? []).map((s) => (
+            <UsageRow
+              key={`${s.label}:${s.group ?? ""}`}
+              label={scopedUsageLabel(s)}
+              w={s.window}
+              fallbackReset={null}
+            />
+          ))}
           {/* Coarse status pill (warning / rejected) — always informative. */}
           {st && plan ? (
             <div className="wf-pop-row">
diff --git a/src/ui/menuPlacement.test.ts b/src/ui/menuPlacement.test.ts
new file mode 100644
index 0000000..34c4474
--- /dev/null
+++ b/src/ui/menuPlacement.test.ts
@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { menuPortalPlacement } from "./kit";
+
+// A minimal DOMRect for the trigger / popover.
+const rect = (left: number, right: number, top = 400, bottom = 414): DOMRect =>
+  ({ left, right, top, bottom, width: right - left, height: bottom - top, x: left, y: top, toJSON() {} }) as DOMRect;
+
+const VW = 1440;
+const VH = 900;
+
+beforeEach(() => {
+  Object.defineProperty(window, "innerWidth", { value: VW, configurable: true });
+  Object.defineProperty(window, "innerHeight", { value: VH, configurable: true });
+});
+
+describe("menuPortalPlacement", () => {
+  const POP = rect(0, 320, 0, 200); // a wide (320px) popover, e.g. the goal popover
+
+  it("keeps a right-aligned popover on-screen for a FAR-LEFT trigger (the goal-card bug)", () => {
+    // A tiny goal button hugging the left of a far-left card.
+    const pos = menuPortalPlacement(rect(30, 44), "right", false, POP);
+    expect(typeof pos.left).toBe("number");
+    const left = pos.left as number;
+    expect(left).toBeGreaterThanOrEqual(8); // never off the left edge
+    expect(left + POP.width).toBeLessThanOrEqual(VW - 8); // whole popover fits
+  });
+
+  it("keeps a right-aligned popover on-screen for a FAR-RIGHT trigger", () => {
+    const pos = menuPortalPlacement(rect(1390, 1404), "right", false, POP);
+    const left = pos.left as number;
+    expect(left).toBeGreaterThanOrEqual(8);
+    expect(left + POP.width).toBeLessThanOrEqual(VW - 8);
+  });
+
+  it("right-anchors to the trigger's right edge when there is room", () => {
+    // Trigger comfortably mid-screen: the popover's right edge sits at the trigger's right edge.
+    const pos = menuPortalPlacement(rect(700, 760), "right", false, POP);
+    expect(pos.left).toBe(760 - POP.width);
+  });
+});