diff --git a/src-tauri/src/automation/roster.rs b/src-tauri/src/automation/roster.rs
index 4d18f5ef..d953efbe 100644
--- a/src-tauri/src/automation/roster.rs
+++ b/src-tauri/src/automation/roster.rs
@@ -54,7 +54,7 @@ pub struct TargetSnapshot {
 }
 
 /// One picker row.
-#[derive(Debug, Clone, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WatchableTerminal {
     pub terminal_id: String,
@@ -63,6 +63,17 @@ pub struct WatchableTerminal {
     pub shell: Option<String>,
     pub pid: Option<u32>,
     pub cwd: Option<String>,
+    /// The tab/pane label the targeting resolver reads for `Tab name contains`. This is not the
+    /// terminal's internal `name`: renderer-created terminals all share a `Terminal-{shell}` name,
+    /// so that would make a shell name look like a tab title.
+    pub display_label: Option<String>,
+    /// The foreground process chain the targeting resolver reads for `Command contains`.
+    ///
+    /// The editor sends its roster back to the preview command, rather than implementing a second
+    /// matcher in TypeScript. Keeping the chain on this DTO is what lets that command use the same
+    /// resolver as the evaluator.
+    #[serde(default)]
+    pub command_lines: Vec<String>,
     /// `false` means "not open right now" — **dormant, never dead**. Session restore re-registers the
     /// same `tm-` under a new `pc-`, so absence is not death.
     pub alive: bool,
@@ -101,6 +112,8 @@ pub fn build(
             shell: Some(row.shell.clone()),
             pid: Some(row.pid),
             cwd: row.cwd.clone().or_else(|| snap.and_then(|s| s.folder.clone())),
+            display_label: row.display_label.clone(),
+            command_lines: row.command_lines.clone(),
             alive: true,
         });
     }
@@ -117,6 +130,8 @@ pub fn build(
             shell: None,
             pid: None,
             cwd: snap.and_then(|s| s.folder.clone()),
+            display_label: None,
+            command_lines: Vec::new(),
             alive: false,
         });
     }
diff --git a/src-tauri/src/automation/runtime.rs b/src-tauri/src/automation/runtime.rs
index 9bfdc4c1..f2b462f8 100644
--- a/src-tauri/src/automation/runtime.rs
+++ b/src-tauri/src/automation/runtime.rs
@@ -589,6 +589,16 @@ impl AutomationRuntime {
         self.watched.get(rule_id).map(|e| e.value().clone()).unwrap_or_default()
     }
 
+    /// Has the targeting loop resolved this rule's matched set even once?
+    ///
+    /// `watched_for` cannot answer this: it flattens a MISSING entry and an entry holding an empty
+    /// set into the same empty set, and those two mean opposite things to the row that reads them.
+    /// The targeting pass calls `set_watched` for every live rule, empty result included, so an
+    /// absent key means "not resolved yet" and only that.
+    pub fn has_resolved(&self, rule_id: &str) -> bool {
+        self.watched.contains_key(rule_id)
+    }
+
     pub fn watches(&self, rule_id: &str, tm: &str) -> bool {
         self.watched.get(rule_id).map(|e| e.value().contains(tm)).unwrap_or(false)
     }
diff --git a/src-tauri/src/automation/targeting.rs b/src-tauri/src/automation/targeting.rs
index 07748175..3c97e959 100644
--- a/src-tauri/src/automation/targeting.rs
+++ b/src-tauri/src/automation/targeting.rs
@@ -121,6 +121,50 @@ pub fn resolve(criterion: Criterion, value: &str, rows: &[RosterRow]) -> BTreeSe
         .collect()
 }
 
+/// The three target sets the editor needs to explain a rule.
+///
+/// `matched` is the unfiltered target set, `excluded` is the part of that set the rule filters
+/// out, and `watching` is the remainder. They are sets rather than counts because matching the
+/// wrong terminal can leave every displayed count unchanged.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TargetResolution {
+    pub matched: BTreeSet<String>,
+    pub excluded: BTreeSet<String>,
+    pub watching: BTreeSet<String>,
+}
+
+/// Resolve one rule's target sets for both the evaluator and the editor preview.
+///
+/// `previous` preserves the evaluator's frozen-set behaviour. The preview passes `None`, which
+/// answers what the draft resolves to now; the evaluator passes its stored set. Keeping those two
+/// callers here gives them one matcher and one exclusion gate.
+pub fn resolve_target_sets(
+    rule: &AutomationRule,
+    rows: &[RosterRow],
+    previous: Option<&BTreeSet<String>>,
+) -> TargetResolution {
+    let matched = match rule.target_mode {
+        TargetMode::Pinned => rule.target_ids.iter().cloned().collect(),
+        TargetMode::Rule => match (rule.follow_new, previous) {
+            (false, Some(frozen)) if !frozen.is_empty() => frozen.clone(),
+            _ => resolve(rule.criterion, &rule.criterion_value, rows),
+        },
+    };
+
+    let excluded = if rule.target_mode == TargetMode::Rule {
+        let mut candidates: BTreeSet<String> = rule.excluded_ids.iter().cloned().collect();
+        if let Some(criterion) = rule.exclude_criterion {
+            candidates.extend(resolve(criterion, &rule.exclude_criterion_value, rows));
+        }
+        matched.intersection(&candidates).cloned().collect()
+    } else {
+        BTreeSet::new()
+    };
+    let watching = matched.difference(&excluded).cloned().collect();
+
+    TargetResolution { matched, excluded, watching }
+}
+
 /// What changed between two ticks of the watched set.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct SetDelta {
@@ -165,13 +209,7 @@ pub fn watched_set(
     rows: &[RosterRow],
     previous: Option<&BTreeSet<String>>,
 ) -> BTreeSet<String> {
-    match rule.target_mode {
-        TargetMode::Pinned => rule.target_ids.iter().cloned().collect(),
-        TargetMode::Rule => match (rule.follow_new, previous) {
-            (false, Some(frozen)) if !frozen.is_empty() => frozen.clone(),
-            _ => resolve(rule.criterion, &rule.criterion_value, rows),
-        },
-    }
+    resolve_target_sets(rule, rows, previous).watching
 }
 
 #[cfg(test)]
@@ -466,6 +504,9 @@ mod tests {
             criterion_value: value.into(),
             follow_new,
             target_ids: vec!["tm-pinned".into()],
+            excluded_ids: vec![],
+            exclude_criterion: None,
+            exclude_criterion_value: String::new(),
             completed_at: None,
             verbose_until: None,
             sort_order: 0,
@@ -473,7 +514,7 @@ mod tests {
             graph: AutomationGraph {
                 layout: None,
                 timer: None,
-                monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0 }),
+                monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0, skip_typed_line: false }),
                 parse: Some(ParseStep {
                     preset: ParsePreset::Custom,
                     literal: None,
@@ -481,13 +522,14 @@ mod tests {
                     keep: Keep::Brackets,
                 }),
                 cond: Some(CondStep { finds: Finds::Reading, op: Some(CompareOp::Gt), threshold: Some(25.0), ..Default::default() }),
-                action: ActionStep {
+                action: Some(ActionStep {
                     message: "m".into(),
                     send_to: SendTo::Matched,
                     submit: true,
                     cli_type: "default".into(),
                     substitute: false,
-                },
+                }),
+                webhook: None,
             },
             created_at: 0,
             updated_at: 0,
@@ -565,6 +607,70 @@ mod tests {
         assert_eq!(ids(watched_set(&pinned, &[], None)), vec!["tm-pinned"]);
     }
 
+    #[test]
+    fn a_pinned_rule_ignores_exclusions_entirely() {
+        let rows = vec![row(Some("tm-a"), None, None, Some("claude"))];
+        let mut r = rule(TargetMode::Pinned, Criterion::CommandContains, "claude", true);
+        r.target_ids = vec!["tm-a".into()];
+        r.excluded_ids = vec!["tm-a".into()];
+        assert_eq!(
+            ids(watched_set(&r, &rows, None)),
+            vec!["tm-a"],
+            "a hand-picked set says what it means; exclusions do not apply"
+        );
+    }
+
+    #[test]
+    fn an_exclusion_pattern_removes_everything_it_matches() {
+        let rows = vec![
+            row(Some("tm-scratch"), None, Some("~/scratch/project"), None),
+            row(Some("tm-work"), None, Some("~/work/termflow"), None),
+        ];
+        let mut r = rule(TargetMode::Rule, Criterion::AllTerminals, "", true);
+        r.exclude_criterion = Some(Criterion::WorkingFolderUnder);
+        r.exclude_criterion_value = "~/scratch".into();
+
+        assert_eq!(ids(watched_set(&r, &rows, None)), vec!["tm-work"]);
+    }
+
+    #[test]
+    fn the_two_exclusion_kinds_union_rather_than_override() {
+        let rows = vec![
+            row(Some("tm-id"), None, Some("~/work/termflow"), None),
+            row(Some("tm-pattern"), None, Some("~/scratch/project"), None),
+            row(Some("tm-kept"), None, Some("~/work/other"), None),
+        ];
+        let mut r = rule(TargetMode::Rule, Criterion::AllTerminals, "", true);
+        r.excluded_ids = vec!["tm-id".into()];
+        r.exclude_criterion = Some(Criterion::WorkingFolderUnder);
+        r.exclude_criterion_value = "~/scratch".into();
+
+        assert_eq!(ids(watched_set(&r, &rows, None)), vec!["tm-kept"]);
+    }
+
+    /// Counts alone let the editor and the engine disagree while both "pass": excluding tm-b
+    /// instead of tm-c gives the same three numbers. Assert the SETS.
+    #[test]
+    fn the_preview_resolves_the_same_ids_the_engine_watches() {
+        let rows = [
+            row(Some("tm-a"), None, None, Some("node worker-a")),
+            row(Some("tm-b"), None, None, Some("node worker-b")),
+            row(Some("tm-c"), None, None, Some("node worker-c")),
+        ];
+        let mut r = rule(TargetMode::Rule, Criterion::CommandContains, "node", true);
+        r.excluded_ids = vec!["tm-b".into()];
+
+        let preview = resolve_target_sets(&r, &rows, None);
+        assert_eq!(ids(preview.matched), vec!["tm-a", "tm-b", "tm-c"]);
+        assert_eq!(ids(preview.excluded), vec!["tm-b"]);
+        assert_eq!(ids(preview.watching.clone()), vec!["tm-a", "tm-c"]);
+        assert_eq!(
+            ids(watched_set(&r, &rows, None)),
+            ids(preview.watching),
+            "the evaluator must use the preview's resolution, not merely have the same count"
+        );
+    }
+
     // -----------------------------------------------------------------------------------------
     // §10.12b — the departure is reported once
     // -----------------------------------------------------------------------------------------
diff --git a/src-tauri/src/automation_commands.rs b/src-tauri/src/automation_commands.rs
index b173ce48..7787b3cb 100644
--- a/src-tauri/src/automation_commands.rs
+++ b/src-tauri/src/automation_commands.rs
@@ -25,6 +25,7 @@ use tauri::{Emitter, State};
 
 use crate::automation::events::{ChangedPayload, AUTOMATION_CHANGED};
 use crate::automation::roster::{TargetSnapshot, WatchableTerminal};
+use crate::automation::targeting::resolve_target_sets;
 use crate::automation_engine::dry::DryRunReport;
 use crate::automation_engine::host::EngineHost;
 use crate::automation_store::{
@@ -43,6 +44,13 @@ fn to_string_err(e: AutomationStoreError) -> String {
     e.to_string()
 }
 
+/// Decode an IPC rule without forwarding serde's rendering of the submitted value. A malformed
+/// webhook object may contain its endpoint in that rendering, while callers only need to know that
+/// the draft was malformed.
+fn decode_automation_rule(value: serde_json::Value) -> Result<AutomationRule, String> {
+    serde_json::from_value(value).map_err(|_| "automation rule is malformed".to_string())
+}
+
 /// One rule-level log row — no terminal, so no name to carry.
 ///
 /// **The three definition kinds had no writer at all.** `Saved` is required by §3.5 and checked by GUI
@@ -175,20 +183,15 @@ pub async fn list_watchable_terminals(
     state: State<'_, AppState>,
     rule_id: Option<String>,
     include_ids: Option<Vec<String>>,
+    criteria: Vec<Criterion>,
 ) -> Result<Vec<WatchableTerminal>, String> {
     let owned = state.inner().clone();
     tokio::task::spawn_blocking(move || {
         let store = owned.automation_store.clone();
-        // Only the criterion of the rule being edited, so opening the picker on a `Terminal ID is`
-        // rule never enumerates the machine's processes (§10.13).
-        let criteria: Vec<Criterion> = match rule_id.as_deref() {
-            Some(id) => store
-                .get_rule(id)
-                .map_err(to_string_err)?
-                .map(|r| vec![r.criterion])
-                .unwrap_or_default(),
-            None => Vec::new(),
-        };
+        // The editor supplies its CURRENT rule-mode criteria, including the exception. `rule_id`
+        // scopes only the persisted label snapshots below: a saved row is stale while its draft is
+        // being edited, and a new draft has no saved row at all. Keeping those jobs separate means
+        // a command/cwd criterion gets the scan it needs before preview resolution.
         let live = EngineHost::roster(&owned, &criteria);
 
         // §4.3: scoped to the rule when the caller names one — the editor always knows which rule it
@@ -219,6 +222,48 @@ pub async fn list_watchable_terminals(
     .map_err(|e| e.to_string())?
 }
 
+/// The ids a draft targets right now, split into its unfiltered match, the part excluded, and what
+/// remains to watch. The renderer supplies the roster it is drawing so the preview and its picker
+/// describe one snapshot; matching itself remains in Rust alongside the evaluator.
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AutomationTargetPreview {
+    pub matched: Vec<String>,
+    pub excluded: Vec<String>,
+    pub watching: Vec<String>,
+}
+
+#[tauri::command]
+pub async fn preview_automation_targets(
+    rule: AutomationRule,
+    terminals: Vec<WatchableTerminal>,
+) -> Result<AutomationTargetPreview, String> {
+    tokio::task::spawn_blocking(move || {
+        let rows = terminals
+            .into_iter()
+            .filter(|terminal| terminal.alive)
+            .map(|terminal| crate::automation::roster::RosterRow {
+                terminal_id: Some(terminal.terminal_id),
+                process_id: terminal.process_id.unwrap_or_default(),
+                name: String::new(),
+                shell: terminal.shell.unwrap_or_default(),
+                pid: terminal.pid.unwrap_or_default(),
+                display_label: terminal.display_label,
+                cwd: terminal.cwd,
+                command_lines: terminal.command_lines,
+            })
+            .collect::<Vec<_>>();
+        let resolved = resolve_target_sets(&rule, &rows, None);
+        Ok(AutomationTargetPreview {
+            matched: resolved.matched.into_iter().collect(),
+            excluded: resolved.excluded.into_iter().collect(),
+            watching: resolved.watching.into_iter().collect(),
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
 /// Which pairs `Re-arm now` touches: one named leaf, or every leaf the rule watches.
 ///
 /// **A named leaf is filtered through the watch set too.** It arrives from a renderer that may be
@@ -260,9 +305,10 @@ fn reload_after_commit(owned: &AppState, at: i64) -> Result<(), String> {
 #[tauri::command]
 pub async fn dry_run_automation(
     state: State<'_, AppState>,
-    rule: AutomationRule,
+    rule: serde_json::Value,
     terminal_id: String,
 ) -> Result<DryRunReport, String> {
+    let rule = decode_automation_rule(rule)?;
     let owned = state.inner().clone();
     tokio::task::spawn_blocking(move || {
         let engine = owned.automations.clone();
@@ -301,11 +347,11 @@ pub struct AutomationSaveResult {
 #[tauri::command]
 pub async fn save_automation(
     state: State<'_, AppState>,
-    rule: AutomationRule,
+    rule: serde_json::Value,
     origin: String,
 ) -> Result<AutomationSaveResult, String> {
     let owned = state.inner().clone();
-    let mut rule = rule;
+    let mut rule = decode_automation_rule(rule)?;
     if rule.id.trim().is_empty() {
         // The same shape `duplicate_automation` mints, and deliberately the same prefix: one id
         // vocabulary, minted in one crate.
@@ -650,7 +696,46 @@ pub async fn rearm_automation(
 
 #[cfg(test)]
 mod source_tests {
-    use super::leaves_to_rearm;
+    use super::{decode_automation_rule, leaves_to_rearm};
+
+    #[test]
+    fn malformed_ipc_rule_errors_do_not_echo_a_webhook_url() {
+        let secret = "https://hooks.example.invalid/ipc-credential";
+        let value = serde_json::json!({
+            "id": "au-ipc",
+            "name": "bad webhook",
+            "enabled": false,
+            "runsOnce": false,
+            "targetMode": "pinned",
+            "criterion": "allTerminals",
+            "criterionValue": "",
+            "followNew": true,
+            "targetIds": [],
+            "excludedIds": [],
+            "completedAt": null,
+            "verboseUntil": null,
+            "sortOrder": 0,
+            "schemaVersion": 3,
+            "graph": { "webhook": {
+                "provider": secret,
+                "url": secret,
+                "body": "done"
+            }},
+            "createdAt": 0,
+            "updatedAt": 0
+        });
+
+        // This is the exact serde decode that Tauri used to perform for the command argument.
+        // Its real error includes the invalid provider, so accepting a typed parameter leaked it.
+        let raw = serde_json::from_value::<crate::automation_store::AutomationRule>(value.clone())
+            .expect_err("a URL is not a webhook provider")
+            .to_string();
+        assert!(raw.contains(secret), "premise: raw IPC decode did not contain the URL: {raw}");
+
+        let safe = decode_automation_rule(value).expect_err("the command rejects malformed IPC");
+        assert_eq!(safe, "automation rule is malformed");
+        assert!(!safe.contains(secret));
+    }
 
     /// `Re-arm now` reaches only pairs the rule actually watches.
     ///
@@ -890,7 +975,7 @@ mod source_tests {
     fn every_command_in_this_module_is_registered_in_lib() {
         let lib = crate::automation_engine::test_host::strip_comments(include_str!("lib.rs"));
         let names: Vec<String> = command_bodies().into_iter().map(|(n, _)| n).collect();
-        assert_eq!(names.len(), 14, "the command list changed: {:?}", names);
+        assert_eq!(names.len(), 15, "the command list changed: {:?}", names);
         for name in &names {
             assert!(
                 lib.contains(&format!("automation_commands::{},", name)),
diff --git a/src-tauri/src/automation_engine.rs b/src-tauri/src/automation_engine.rs
index 521cbe45..83f786fc 100644
--- a/src-tauri/src/automation_engine.rs
+++ b/src-tauri/src/automation_engine.rs
@@ -773,8 +773,28 @@ impl AutomationEngine {
         let mut rules = HashMap::new();
         for live in self.snapshot_live() {
             let id = &live.rule.id;
-            let watched = self.runtime.watched_for(id);
             let missing_for = missing.get(id).unwrap_or(&empty);
+            // **A rule that has never been resolved is absent, not a rule watching nothing.**
+            //
+            // The row treats these as opposite: an absent rule is `waiting` ("the engine has not
+            // reported this rule"), an empty one is the *Nothing to watch* error ("running, and
+            // nothing matches"). Every live rule was reported here from the moment it went live,
+            // and `watched_for` returns an empty set for a rule the targeting loop has not reached
+            // yet — so between a reload and the next targeting pass, up to `TARGETING_TICK_MS`,
+            // every rule-mode rule claimed nothing matched it.
+            //
+            // That window opens on the two occasions a user is most likely to be looking: app
+            // start, and the reload that follows their own save. Saving a `Command contains` rule
+            // with a matching terminal already open showed *"No open terminal matches ..."* for two
+            // seconds, and the pill was `Error` while it did.
+            //
+            // `missing` is parked by the same pass, so it cannot be present while `watched` is
+            // absent — but reporting the rule when it somehow is loses nothing, and hiding a known
+            // missing terminal would.
+            if !self.runtime.has_resolved(id) && missing_for.is_empty() {
+                continue;
+            }
+            let watched = self.runtime.watched_for(id);
             let mut pairs = HashMap::new();
             for tm in watched.iter().chain(missing_for.iter()) {
                 let (fired_count, last_fired_at) = match self.runtime.fire_record(id, tm) {
@@ -840,6 +860,9 @@ mod tests {
             criterion_value: String::new(),
             follow_new: true,
             target_ids: vec!["tm-1".to_string()],
+            excluded_ids: vec![],
+            exclude_criterion: None,
+            exclude_criterion_value: String::new(),
             completed_at: None,
             verbose_until: None,
             sort_order: 1,
@@ -851,6 +874,7 @@ mod tests {
                     read: ReadMode::NewOutput,
                     cadence: Cadence::OnOutput,
                     every_ms: 0,
+                    skip_typed_line: false,
                 }),
                 parse: Some(ParseStep {
                     preset: ParsePreset::Custom,
@@ -864,13 +888,14 @@ mod tests {
                     threshold: Some(25.0),
                     ..Default::default()
                 }),
-                action: ActionStep {
+                action: Some(ActionStep {
                     message: "prepare to do context-hand-off".to_string(),
                     send_to: SendTo::Matched,
                     submit: true,
                     cli_type: "default".to_string(),
                     substitute: false,
-                },
+                }),
+                webhook: None,
             },
             created_at: 1_000,
             updated_at: 1_000,
@@ -991,6 +1016,25 @@ mod tests {
         assert!(rows[1].contains("needs a newer version"), "{}", rows[1]);
     }
 
+    #[test]
+    fn reload_logs_a_real_malformed_webhook_value_without_its_url() {
+        let secret = "https://hooks.example.invalid/reload-credential";
+        let malformed = format!(
+            r#"{{"webhook":{{"provider":"{secret}","url":"{secret}","body":"done"}}}}"#
+        );
+        let store = AutomationStore::new_in_memory();
+        store.insert_raw_graph_for_test("au-malformed", &malformed);
+
+        let engine = AutomationEngine::new(0);
+        let report = engine.reload(&store, 7_000).expect("reload malformed row");
+        assert_eq!(report.skipped.len(), 1, "the malformed row was really skipped");
+        assert!(!report.skipped[0].1.contains(secret), "reload reason leaked: {:?}", report.skipped);
+
+        let rows = log_rows(&store);
+        assert_eq!(rows.len(), 1, "reload wrote its real activity row");
+        assert!(!rows[0].contains(secret), "activity detail leaked: {}", rows[0]);
+    }
+
     /// **A schedule rule has no pattern, and no pattern is not a broken pattern** (plan 032 §6.4).
     ///
     /// `reload` used to ask `pattern_refused_at_load(&graph.parse.find)` of every rule, and a rule
@@ -1967,6 +2011,67 @@ mod tests {
         assert_eq!(engine.runtime.arm_state("au-a", "tm-1"), ArmState::Fired { at_ms: 500 });
     }
 
+    /// "Un-ticking puts it back." An exclusion is a filter over the matched set, never a deletion from
+    /// it — and this must hold on a FROZEN (`follow_new: false`) rule, which is the case that can bake
+    /// the exclusion in. Spec §B3. Distinct timestamps are load-bearing: reload compares `updated_at`,
+    /// not content, so a same-millisecond save would not clear the set and the test would pass
+    /// vacuously.
+    #[test]
+    fn lifting_an_exclusion_restores_the_terminal_on_a_frozen_rule() {
+        let fake = Arc::new(
+            crate::automation_engine::test_host::FakeHost::new()
+                .with_terminal("tm-a", "pc-a", "a")
+                .with_terminal("tm-b", "pc-b", "b"),
+        );
+        let host: Arc<dyn crate::automation_engine::host::EngineHost> = fake.clone();
+        let engine = Arc::new(AutomationEngine::new(0));
+
+        let mut r = rule("au-frozen", r"ctx:(\d+)%");
+        r.target_mode = TargetMode::Rule;
+        r.criterion = Criterion::AllTerminals;
+        r.criterion_value.clear();
+        r.follow_new = false;
+        r.updated_at = 1_000;
+        fake.store.save_rule(&r).unwrap();
+        engine.reload(&fake.store, 1_000).unwrap();
+        crate::automation_engine::loops::targeting_tick(&engine, &host, 1_000);
+        assert_eq!(
+            engine.runtime.watched_for("au-frozen"),
+            HashSet::from(["tm-a".to_string(), "tm-b".to_string()]),
+            "premise: the frozen base set contains both terminals"
+        );
+
+        r.excluded_ids = vec!["tm-b".into()];
+        r.updated_at = 2_000;
+        fake.store.save_rule(&r).unwrap();
+        engine.reload(&fake.store, 2_000).unwrap();
+        assert!(
+            engine.runtime.watched_for("au-frozen").is_empty(),
+            "the changed timestamp must clear the frozen set before the next targeting pass"
+        );
+        crate::automation_engine::loops::targeting_tick(&engine, &host, 2_000);
+        assert_eq!(
+            engine.runtime.watched_for("au-frozen"),
+            HashSet::from(["tm-a".to_string()]),
+            "the exclusion filters tm-b from the frozen base set"
+        );
+
+        r.excluded_ids.clear();
+        r.updated_at = 3_000;
+        fake.store.save_rule(&r).unwrap();
+        engine.reload(&fake.store, 3_000).unwrap();
+        assert!(
+            engine.runtime.watched_for("au-frozen").is_empty(),
+            "lifting the exclusion must also clear the filtered frozen set"
+        );
+        crate::automation_engine::loops::targeting_tick(&engine, &host, 3_000);
+        assert_eq!(
+            engine.runtime.watched_for("au-frozen"),
+            HashSet::from(["tm-a".to_string(), "tm-b".to_string()]),
+            "the original matched terminal returns after a real save and reload"
+        );
+    }
+
     // -----------------------------------------------------------------------------------------
     // §7.8 — completion is an in-memory event first
     // -----------------------------------------------------------------------------------------
@@ -2030,6 +2135,41 @@ mod tests {
         assert!(!p.missing);
     }
 
+    /// The three states of a rule's matched set, as a table — because two of them are an empty map
+    /// and the row treats them as opposites.
+    ///
+    /// Never resolved => ABSENT, which the row reads as `waiting`. Resolved to nothing => PRESENT
+    /// and empty, which is the *Nothing to watch* error. Resolved to something => the pairs.
+    ///
+    /// The middle row is the one that makes the first row safe: hiding an unresolved rule must not
+    /// also hide a rule that genuinely matches no terminal, or the error becomes unreachable.
+    #[test]
+    fn a_rule_is_absent_until_targeting_resolves_it_and_empty_only_when_nothing_matches() {
+        let store = AutomationStore::new_in_memory();
+        store.save_rule(&rule("au-a", r"ctx:(\d+)%")).unwrap();
+        let engine = AutomationEngine::new(0);
+        engine.reload(&store, 1_000).unwrap();
+
+        assert!(
+            !engine.state_payload(&HashMap::new()).rules.contains_key("au-a"),
+            "a live rule the targeting loop has not reached yet must not claim nothing matches it",
+        );
+
+        engine.runtime.set_watched("au-a", HashSet::new());
+        let resolved_to_nothing = engine.state_payload(&HashMap::new());
+        assert_eq!(
+            resolved_to_nothing.rules.get("au-a").map(|p| p.len()),
+            Some(0),
+            "resolved-and-matching-nothing is still reported, as an empty map",
+        );
+
+        engine.runtime.set_watched("au-a", ["tm-1".to_string()].into());
+        assert_eq!(
+            engine.state_payload(&HashMap::new()).rules["au-a"].len(),
+            1,
+        );
+    }
+
     /// Every field moves for the right reason — and `fired_count` survives a re-arm, which is what
     /// `arm` alone structurally cannot express.
     #[test]
diff --git a/src-tauri/src/automation_engine/dry.rs b/src-tauri/src/automation_engine/dry.rs
index 0d699373..bfd7d47b 100644
--- a/src-tauri/src/automation_engine/dry.rs
+++ b/src-tauri/src/automation_engine/dry.rs
@@ -26,8 +26,8 @@ use crate::automation_engine::schedule::clock_time;
 use crate::automation_engine::subst;
 use crate::automation_engine::AutomationEngine;
 use crate::automation_store::{
-    AutomationLogEntry, AutomationRule, Clause, CompareOp, Finds, Join, LogKind, Test, TextOp,
-    TimerMode, TimerStep,
+    ActionStep, AutomationLogEntry, AutomationRule, Clause, CompareOp, Finds, Join, LogKind, Test, TextOp,
+    TimerMode, TimerStep, WebhookStep,
 };
 
 /// One step of the graph, as the editor's Test panel draws it.
@@ -73,6 +73,7 @@ const PARSE: &str = "parse";
 const COND: &str = "cond";
 const TIMER: &str = "timer";
 const ACTION: &str = "action";
+const WEBHOOK: &str = "webhook";
 
 /// An `AfterMatch` wait, in the pane's own terse style — `30 s`, `1.5 s`, `2 min` — never restating
 /// `MAX_DELAY_MS`/`MIN_DELAY_MS` as a bound, because this is naming a CONCRETE wait, not a range.
@@ -126,6 +127,56 @@ fn skipped(kind: &str) -> StepTrace {
     step(kind, "skipped", "not reached".to_string())
 }
 
+fn action_trace(action: Option<&ActionStep>, caps: Option<&eval::Captures>, terminal_name: Option<&str>) -> Option<StepTrace> {
+    let action = action?;
+    Some(match preview_message(&action.message, action.substitute, caps) {
+        Ok(body) => step(ACTION, "ok", match terminal_name {
+            Some(name) => format!("would type `{}` into {}", body, name),
+            None => format!("would type `{}`", body),
+        }),
+        Err(e) => step(ACTION, "failed", format!("nothing would be sent — `{}` had no value here", e)),
+    })
+}
+
+fn push_skipped_action(steps: &mut Vec<StepTrace>, action: Option<&ActionStep>) {
+    if action.is_some() { steps.push(skipped(ACTION)); }
+}
+
+fn masked_webhook_url(url: &str) -> String {
+    match reqwest::Url::parse(url) {
+        Ok(url) => match url.host_str() {
+            Some(host) => format!("{}://{}", url.scheme(), host),
+            None => "an invalid webhook URL".to_string(),
+        },
+        Err(_) => "an invalid webhook URL".to_string(),
+    }
+}
+
+fn webhook_trace(webhook: Option<&WebhookStep>, caps: Option<&eval::Captures>) -> Option<StepTrace> {
+    let webhook = webhook?;
+    Some(match preview_message(&webhook.body, webhook.substitute, caps) {
+        Ok(message) => {
+            let body = String::from_utf8(crate::automation_webhook::payload(webhook.provider, &message))
+                .expect("a webhook payload from a UTF-8 string is UTF-8");
+            step(
+                WEBHOOK,
+                "ok",
+                format!(
+                    "would post via {:?} `{}` to {}",
+                    webhook.provider,
+                    body,
+                    masked_webhook_url(&webhook.url),
+                ),
+            )
+        }
+        Err(e) => step(WEBHOOK, "failed", format!("nothing would be sent — `{}` had no value here", e)),
+    })
+}
+
+fn push_skipped_webhook(steps: &mut Vec<StepTrace>, webhook: Option<&WebhookStep>) {
+    if webhook.is_some() { steps.push(skipped(WEBHOOK)); }
+}
+
 fn symbol(op: CompareOp) -> &'static str {
     match op {
         CompareOp::Gt => ">",
@@ -264,7 +315,10 @@ pub fn evaluate_once(
             // this branch still answers an unsaved draft or a row that predates the guard, so it
             // stays the honest, non-panicking answer regardless of whether validation would also
             // have refused it.
-            return finish(UNREADABLE, vec![skipped(TIMER), skipped(ACTION)]);
+            let mut steps = vec![skipped(TIMER)];
+            push_skipped_action(&mut steps, rule.graph.action.as_ref());
+            push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref());
+            return finish(UNREADABLE, steps);
         };
         // **I1.** `schedule_due` refuses a `minute_of_day` outside `0..MINUTES_PER_DAY` and a
         // `days` mask with no weekday bit set — and until this check existed, this branch asked
@@ -293,10 +347,7 @@ pub fn evaluate_once(
             };
             return finish(
                 WOULD_NOT_FIRE,
-                vec![
-                    step(TIMER, "failed", format!("this schedule can never fire — {why}")),
-                    skipped(ACTION),
-                ],
+                { let mut steps = vec![step(TIMER, "failed", format!("this schedule can never fire — {why}"))]; push_skipped_action(&mut steps, rule.graph.action.as_ref()); push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref()); steps },
             );
         }
         let timer_step = step(
@@ -309,42 +360,29 @@ pub fn evaluate_once(
         let Some(_pc) = host.process_for_leaf(tm) else {
             return finish(
                 UNREADABLE,
-                vec![timer_step, step(ACTION, "failed", "that terminal is not open right now".to_string())],
+                { let mut steps = vec![timer_step]; if rule.graph.action.is_some() { steps.push(step(ACTION, "failed", "that terminal is not open right now".to_string())); } push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref()); steps },
             );
         };
-        let action_step = match preview_message(&rule.graph.action.message, rule.graph.action.substitute, None) {
-            Ok(body) => step(
-                ACTION,
-                "ok",
-                match &terminal_name {
-                    Some(name) => format!("would type `{}` into {}", body, name),
-                    None => format!("would type `{}`", body),
-                },
-            ),
-            Err(e) => step(ACTION, "failed", format!("nothing would be sent — `{}` had no value here", e)),
-        };
-        return finish(WOULD_FIRE, vec![timer_step, action_step]);
+        let mut steps = vec![timer_step];
+        if let Some(action_step) = action_trace(rule.graph.action.as_ref(), None, terminal_name.as_deref()) { steps.push(action_step); }
+        if let Some(webhook_step) = webhook_trace(rule.graph.webhook.as_ref(), None) { steps.push(webhook_step); }
+        return finish(WOULD_FIRE, steps);
     }
 
     let Some(steps) = eval::InputSteps::of(&rule.graph) else {
         return finish(
             UNREADABLE,
-            vec![skipped(MONITOR), skipped(PARSE), skipped(COND), skipped(ACTION)],
+            { let mut steps = vec![skipped(MONITOR), skipped(PARSE), skipped(COND)]; push_skipped_action(&mut steps, rule.graph.action.as_ref()); push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref()); steps },
         );
     };
     let pattern = steps.parse.find.clone();
 
     // 1. Monitor. A terminal that is not live is not readable, and that is the whole answer.
     let Some(pc) = host.process_for_leaf(tm) else {
-        return finish(
-            UNREADABLE,
-            vec![
-                step(MONITOR, "failed", "that terminal is not open right now".to_string()),
-                skipped(PARSE),
-                skipped(COND),
-                skipped(ACTION),
-            ],
-        );
+        let mut steps = vec![step(MONITOR, "failed", "that terminal is not open right now".to_string()), skipped(PARSE), skipped(COND)];
+        push_skipped_action(&mut steps, rule.graph.action.as_ref());
+        push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref());
+        return finish(UNREADABLE, steps);
     };
 
     // 2. The pattern has to compile before anything can be read for it. The editor's validation says
@@ -352,9 +390,7 @@ pub fn evaluate_once(
     let re = match crate::automation_validation::compile(&pattern) {
         Ok(re) => re,
         Err(e) => {
-            return finish(
-                WOULD_NOT_FIRE,
-                vec![
+            let mut steps = vec![
                     step(MONITOR, "ok", "the terminal is open".to_string()),
                     step(
                         PARSE,
@@ -365,9 +401,10 @@ pub fn evaluate_once(
                         ),
                     ),
                     skipped(COND),
-                    skipped(ACTION),
-                ],
-            );
+                ];
+            push_skipped_action(&mut steps, rule.graph.action.as_ref());
+            push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref());
+            return finish(WOULD_NOT_FIRE, steps);
         }
     };
 
@@ -398,15 +435,10 @@ pub fn evaluate_once(
     let echoes = engine.runtime.echoes_for(tm, now_ms);
     let port = HostPort(host);
     let Some(ev) = eval::evaluate(folded, &re, &echoes, prev, &port, &pc, now_ms) else {
-        return finish(
-            UNREADABLE,
-            vec![
-                step(MONITOR, "failed", "there is nothing to read from that terminal yet".to_string()),
-                skipped(PARSE),
-                skipped(COND),
-                skipped(ACTION),
-            ],
-        );
+        let mut steps = vec![step(MONITOR, "failed", "there is nothing to read from that terminal yet".to_string()), skipped(PARSE), skipped(COND)];
+        push_skipped_action(&mut steps, rule.graph.action.as_ref());
+        push_skipped_webhook(&mut steps, rule.graph.webhook.as_ref());
+        return finish(UNREADABLE, steps);
     };
 
     let monitor = step(MONITOR, "ok", format!("read {}", eval::depth_words(ev.depth)));
@@ -518,30 +550,14 @@ pub fn evaluate_once(
 
     let would_fire = ev.condition == Truth::True;
     let action = if would_fire {
-        match preview_message(
-            &rule.graph.action.message,
-            rule.graph.action.substitute,
-            ev.captures.as_ref(),
-        ) {
-            Ok(body) => step(
-                ACTION,
-                "ok",
-                match &terminal_name {
-                    Some(name) => format!("would type `{}` into {}", body, name),
-                    None => format!("would type `{}`", body),
-                },
-            ),
-            // §4.4: the same refusal `run_send` would make, reported rather than typed. The
-            // verdict below still answers the CONDITION (it matched), and this row alone carries
-            // that the send itself would be refused.
-            Err(e) => step(
-                ACTION,
-                "failed",
-                format!("nothing would be sent — `{}` had no value here", e),
-            ),
-        }
+        action_trace(rule.graph.action.as_ref(), ev.captures.as_ref(), terminal_name.as_deref())
     } else {
-        step(ACTION, "skipped", "nothing would be sent".to_string())
+        rule.graph.action.as_ref().map(|_| step(ACTION, "skipped", "nothing would be sent".to_string()))
+    };
+    let webhook = if would_fire {
+        webhook_trace(rule.graph.webhook.as_ref(), ev.captures.as_ref())
+    } else {
+        rule.graph.webhook.as_ref().map(|_| step(WEBHOOK, "skipped", "nothing would be sent".to_string()))
     };
 
     // A DELAY rule (`AfterMatch`) inserts a `timer` row here, between the comparison and the send —
@@ -565,7 +581,8 @@ pub fn evaluate_once(
     if let Some(t) = timer_step {
         all_steps.push(t);
     }
-    all_steps.push(action);
+    if let Some(action) = action { all_steps.push(action); }
+    if let Some(webhook) = webhook { all_steps.push(webhook); }
     finish(verdict, all_steps)
 }
 
@@ -589,6 +606,7 @@ mod tests {
     use crate::automation_engine::test_host::*;
     use crate::automation_store::{
         Clause, CondStep, Finds, Join, Keep, LogOrder, LogScope, Source, Test as ClauseTest, TextOp,
+        WebhookProvider, WebhookStep,
     };
 
     fn kinds(report: &DryRunReport) -> Vec<&str> {
@@ -1114,6 +1132,29 @@ mod tests {
         assert_eq!(report.terminal_id, "tm-1");
     }
 
+    #[test]
+    fn the_webhook_step_names_its_provider_and_payload_without_its_secret_url_path() {
+        let (engine, fake, host) = wire(vec![]);
+        let mut rule = ctx_rule("au-1");
+        rule.graph.webhook = Some(WebhookStep {
+            provider: WebhookProvider::Discord,
+            url: "https://hooks.example.invalid/secret-token".into(),
+            body: "build failed".into(),
+            substitute: false,
+        });
+        fake.say("pc-1", "ctx:63%\n");
+
+        let report = evaluate_once(&engine, host.as_ref(), &rule, "tm-1", 1_000);
+
+        assert_eq!(kinds(&report), vec!["monitor", "parse", "cond", "action", "webhook"]);
+        let webhook = detail(&report, "webhook");
+        assert_eq!(status(&report, "webhook"), "ok");
+        assert!(webhook.contains("Discord"), "{webhook}");
+        assert!(webhook.contains(r#"{"content":"build failed"}"#), "{webhook}");
+        assert!(webhook.contains("https://hooks.example.invalid"), "{webhook}");
+        assert!(!webhook.contains("/secret-token"), "{webhook}");
+    }
+
     // =============================================================================================
     // §1.1 — the preview must not disagree with the send
     // =============================================================================================
@@ -1151,8 +1192,8 @@ mod tests {
         let mut rule = ctx_rule("au-1");
         rule.graph.parse_mut().find = r"FAILED (\d+) tests in (\S+)".into();
         rule.graph.cond = Some(CondStep { finds: Finds::Event, ..Default::default() });
-        rule.graph.action.message = "Fix the $1 failing tests in $2".into();
-        rule.graph.action.substitute = true;
+        rule.graph.action_mut().message = "Fix the $1 failing tests in $2".into();
+        rule.graph.action_mut().substitute = true;
         fake.say("pc-1", "FAILED 17 tests in a.ts");
 
         let report = evaluate_once(&engine, host.as_ref(), &rule, "tm-1", 1_000);
@@ -1174,8 +1215,8 @@ mod tests {
         let mut rule = ctx_rule("au-1");
         rule.graph.parse_mut().find = r"FAILED (\d+)".into();
         rule.graph.cond = Some(CondStep { finds: Finds::Event, ..Default::default() });
-        rule.graph.action.message = "Fix $3".into();
-        rule.graph.action.substitute = true;
+        rule.graph.action_mut().message = "Fix $3".into();
+        rule.graph.action_mut().substitute = true;
         fake.say("pc-1", "FAILED 17");
 
         let report = evaluate_once(&engine, host.as_ref(), &rule, "tm-1", 1_000);
diff --git a/src-tauri/src/automation_engine/eval.rs b/src-tauri/src/automation_engine/eval.rs
index 8d88d979..c87f969f 100644
--- a/src-tauri/src/automation_engine/eval.rs
+++ b/src-tauri/src/automation_engine/eval.rs
@@ -101,7 +101,12 @@ pub enum ReadDepth {
 /// the leaf once per pair before calling it and never resolves inside — a function that silently
 /// accepts either id space is how the next call site gets it wrong. Plan §7.4.
 pub trait ScreenSource {
-    fn tail(&self, process_id: &str, depth: ReadDepth) -> Option<String>;
+    /// `skip_typed_line` is the rule's `monitor.skip_typed_line`, carried here rather than folded
+    /// into `ReadDepth` because it is not a depth: `depth_for` decides HOW FAR BACK to read, and
+    /// this decides whether one line of what it finds counts as output at all. Widening the depth
+    /// enum would put both answers in one table and double its rows for a dimension that does not
+    /// interact with either of the other two.
+    fn tail(&self, process_id: &str, depth: ReadDepth, skip_typed_line: bool) -> Option<String>;
 }
 
 // ---------------------------------------------------------------------------------------------
@@ -716,7 +721,11 @@ pub fn evaluate(
     process_id: &str,
     now_ms: i64,
 ) -> Option<Evaluation> {
-    evaluate_text(steps, re, echoes, prev, &|d| src.tail(process_id, d), now_ms)
+    // The ONE place a `ScreenSource` becomes a reader, so the rule's opt-out is applied here rather
+    // than inside `evaluate_text`: a caller that supplies its own reader is by definition holding
+    // text that came from somewhere else, and a second gate there could only disagree with this one.
+    let skip_typed_line = steps.monitor.skip_typed_line;
+    evaluate_text(steps, re, echoes, prev, &|d| src.tail(process_id, d, skip_typed_line), now_ms)
 }
 
 /// `evaluate` over an already-resolved reader, for a caller that has the text by another route.
@@ -868,7 +877,7 @@ mod tests {
         AutomationGraph {
             layout: None,
             timer: None,
-            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0 }),
+            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0, skip_typed_line: false }),
             parse: Some(ParseStep {
                 preset: ParsePreset::Custom,
                 literal: None,
@@ -876,13 +885,14 @@ mod tests {
                 keep: Keep::Brackets,
             }),
             cond: Some(CondStep { finds, op, threshold, ..Default::default() }),
-            action: ActionStep {
+            action: Some(ActionStep {
                 message: "prepare to do context-hand-off".to_string(),
                 send_to: SendTo::Matched,
                 submit: true,
                 cli_type: "default".to_string(),
                 substitute: false,
-            },
+            }),
+            webhook: None,
         }
     }
 
@@ -923,6 +933,12 @@ mod tests {
         fn feed(&self, line: &str) {
             self.parser.borrow_mut().process(format!("{}\r\n", line).as_bytes());
         }
+        /// Text left sitting under the cursor: a command typed and NOT submitted. The only
+        /// difference from `feed` is the missing newline, which is the whole of what separates a
+        /// keystroke echo from output as far as any of this can tell.
+        fn type_without_enter(&self, text: &str) {
+            self.parser.borrow_mut().process(text.as_bytes());
+        }
         fn depths(&self) -> Vec<ReadDepth> {
             self.asked.borrow().clone()
         }
@@ -932,7 +948,7 @@ mod tests {
     }
 
     impl ScreenSource for VtSource {
-        fn tail(&self, _process_id: &str, depth: ReadDepth) -> Option<String> {
+        fn tail(&self, _process_id: &str, depth: ReadDepth, skip_typed_line: bool) -> Option<String> {
             self.asked.borrow_mut().push(depth);
             let mut parser = self.parser.borrow_mut();
             let screen = parser.screen_mut();
@@ -940,7 +956,10 @@ mod tests {
                 ReadDepth::Window(n) => n,
                 ReadDepth::VisibleScreen => screen.size().0 as usize,
             };
-            Some(crate::state::render_tail_lines(screen, max))
+            // Passed THROUGH, not swallowed: the fake exists to resolve a depth exactly as
+            // `AppState` does, and a fake that ignored the flag would let `evaluate` stop
+            // forwarding it with every test here still green.
+            Some(crate::state::render_tail_lines(screen, max, skip_typed_line))
         }
     }
 
@@ -1715,7 +1734,7 @@ mod tests {
             "check 5 must re-arm: `FAILED` has left the screen even though scrollback still holds it"
         );
         // The proof that this was a DEPTH decision and not an empty terminal.
-        let deep = src.tail("pc-1", ReadDepth::Window(200)).unwrap();
+        let deep = src.tail("pc-1", ReadDepth::Window(200), false).unwrap();
         assert!(deep.contains("FAILED 3 test"), "scrollback must still hold the line");
         // 6 — nothing matching.
         assert_eq!(step(&src, &mut state, 6), Decision::Checked);
@@ -1894,7 +1913,7 @@ mod tests {
             let guarded = if entry == "evaluate" {
                 evaluate(ins(&g), &r, &needles, fired.next, &src, "pc-1", 2).unwrap()
             } else {
-                evaluate_text(ins(&g), &r, &needles, fired.next, &|d| src.tail("pc-1", d), 2).unwrap()
+                evaluate_text(ins(&g), &r, &needles, fired.next, &|d| src.tail("pc-1", d, false), 2).unwrap()
             };
             assert_eq!(
                 guarded.decision,
@@ -1908,7 +1927,7 @@ mod tests {
             let unguarded = if entry == "evaluate" {
                 evaluate(ins(&g), &r, NO_ECHOES, fired.next, &src, "pc-1", 2).unwrap()
             } else {
-                evaluate_text(ins(&g), &r, NO_ECHOES, fired.next, &|d| src.tail("pc-1", d), 2).unwrap()
+                evaluate_text(ins(&g), &r, NO_ECHOES, fired.next, &|d| src.tail("pc-1", d, false), 2).unwrap()
             };
             assert_eq!(unguarded.decision, Decision::Held, "{}: premise", entry);
         }
@@ -2035,7 +2054,7 @@ mod tests {
 
         // The line is still well inside the 200-line window.
         assert!(
-            src.tail("pc-1", ReadDepth::Window(200)).unwrap().contains("FAILED 3 test"),
+            src.tail("pc-1", ReadDepth::Window(200), false).unwrap().contains("FAILED 3 test"),
             "premise: the match is still in scrollback"
         );
 
@@ -2053,6 +2072,41 @@ mod tests {
         );
     }
 
+    /// `monitor.skip_typed_line` reaches the read — the whole point of the field.
+    ///
+    /// This is the DESTINATION check. The rendering half is pinned in `state.rs`'s own
+    /// `tail_read_tests`, and every one of those would stay green if `evaluate` quietly stopped
+    /// forwarding the flag: the failure of a plumbing bug is a feature that does nothing, which is
+    /// invisible from either end on its own. Driving a real `vt100::Parser` is what makes "the
+    /// command is only typed, not submitted" a fact about a terminal rather than about a fixture.
+    #[test]
+    fn a_rule_that_skips_the_typed_line_does_not_read_it() {
+        let src = VtSource::new(6, 40);
+        let mut g = failed_rule();
+        let r = re(&g.parse_ref().find);
+        src.feed("running tests");
+        src.type_without_enter("$ grep 'FAILED 3 tests' log.txt");
+
+        // Off — the reported bug, and the premise for the other half: the words ARE on the screen,
+        // and nothing about them says the user has not pressed Enter yet.
+        let read = evaluate(ins(&g), &r, NO_ECHOES, ArmState::Unseen, &src, "pc-1", 1).unwrap();
+        assert_eq!(read.outcome, Outcome::Presence(true), "premise: it matches what was typed");
+
+        g.monitor_mut().skip_typed_line = true;
+        let skipped = evaluate(ins(&g), &r, NO_ECHOES, ArmState::Unseen, &src, "pc-1", 1).unwrap();
+        assert_eq!(
+            skipped.outcome,
+            Outcome::Presence(false),
+            "the rule opted out and the typed line was read anyway"
+        );
+
+        // And the opt-out costs it nothing once the command is actually submitted.
+        src.feed("");
+        src.feed("FAILED 3 tests in 2 files");
+        let submitted = evaluate(ins(&g), &r, NO_ECHOES, ArmState::Unseen, &src, "pc-1", 2).unwrap();
+        assert_eq!(submitted.outcome, Outcome::Presence(true), "real output must still match");
+    }
+
     /// A terminal that is not live yields no evaluation, no log line and an untouched arm state.
     #[test]
     fn a_dormant_terminal_is_skipped_rather_than_re_armed() {
diff --git a/src-tauri/src/automation_engine/host.rs b/src-tauri/src/automation_engine/host.rs
index bdf42921..b7ee1a0e 100644
--- a/src-tauri/src/automation_engine/host.rs
+++ b/src-tauri/src/automation_engine/host.rs
@@ -43,7 +43,7 @@ pub trait EngineHost: Send + Sync {
     fn live_processes(&self) -> Vec<String>;
 
     /// Matchable text for one terminal — the `ScreenSource` port, by another name.
-    fn tail(&self, pc: &str, depth: ReadDepth) -> Option<String>;
+    fn tail(&self, pc: &str, depth: ReadDepth, skip_typed_line: bool) -> Option<String>;
 
     /// One terminal-bound write — the `TerminalWriter` port, by another name.
     fn write(&self, pc: &str, bytes: &[u8]) -> Result<(), String>;
@@ -85,8 +85,8 @@ pub trait EngineHost: Send + Sync {
 pub struct HostPort<'a>(pub &'a dyn EngineHost);
 
 impl ScreenSource for HostPort<'_> {
-    fn tail(&self, process_id: &str, depth: ReadDepth) -> Option<String> {
-        self.0.tail(process_id, depth)
+    fn tail(&self, process_id: &str, depth: ReadDepth, skip_typed_line: bool) -> Option<String> {
+        self.0.tail(process_id, depth, skip_typed_line)
     }
 }
 
diff --git a/src-tauri/src/automation_engine/loops.rs b/src-tauri/src/automation_engine/loops.rs
index 88a06ee0..992b9e06 100644
--- a/src-tauri/src/automation_engine/loops.rs
+++ b/src-tauri/src/automation_engine/loops.rs
@@ -11,9 +11,9 @@
 //! milestones that contain the entire engine.
 
 use std::collections::{BTreeSet, HashMap, HashSet};
-use std::sync::atomic::Ordering;
 #[cfg(test)]
 use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -24,7 +24,9 @@ use crate::automation::targeting::watched_set;
 use crate::automation_engine::due::{
     due_now, select_due, settled_processes, BASE_TICK_MS, MAX_EVALS_PER_TICK, TARGETING_TICK_MS,
 };
-use crate::automation_engine::eval::{self, ArmState, Captures, Decision, Evaluation, Outcome, Read};
+use crate::automation_engine::eval::{
+    self, ArmState, Captures, Decision, Evaluation, Outcome, Read,
+};
 use crate::automation_engine::host::{EngineHost, HostPort};
 use crate::automation_engine::schedule;
 use crate::automation_engine::subst;
@@ -74,7 +76,10 @@ pub async fn run_tap(
             // so is one extra evaluation each; the cost of dropping it is a missed match with no
             // symptom. `Lagged` is exactly why the tap carries a signal instead of the bytes.
             Ok(Err(RecvError::Lagged(n))) => {
-                log::warn!("automations: tap lagged {} messages, marking every terminal dirty", n);
+                log::warn!(
+                    "automations: tap lagged {} messages, marking every terminal dirty",
+                    n
+                );
                 for pc in host.live_processes() {
                     engine.runtime.mark_dirty(&pc);
                 }
@@ -84,6 +89,435 @@ pub async fn run_tap(
     }
 }
 
+#[cfg(test)]
+mod task8_tests {
+    use super::*;
+    use crate::automation_engine::test_host::{
+        ctx_rule,
+        rig_with_rule_bypassing_the_enable_gate,
+        strip_comments,
+        wire_bypassing_the_enable_gate,
+    };
+    use crate::automation_store::{LogOrder, LogScope, WebhookProvider, WebhookStep};
+    use std::io::{Read, Write};
+    use std::net::{TcpListener, TcpStream};
+    use std::sync::mpsc::{self, Receiver, Sender};
+
+    fn pending(
+        engine: &Arc<AutomationEngine>,
+        host: &Arc<dyn EngineHost>,
+        prev: ArmState,
+        at_ms: i64,
+    ) -> PendingSend {
+        let rule = engine
+            .snapshot_live()
+            .into_iter()
+            .next()
+            .expect("live rule");
+        engine
+            .runtime
+            .set_arm(&rule.rule.id, "tm-1", ArmState::Fired { at_ms });
+        PendingSend {
+            pair: Pair {
+                rule,
+                tm: "tm-1".into(),
+                pc: "pc-1".into(),
+            },
+            prev,
+            label: host.label_for("tm-1"),
+            at_ms,
+            captures: None,
+        }
+    }
+
+    fn webhook_endpoint() -> (String, Receiver<()>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind loopback webhook listener");
+        let url = format!(
+            "http://{}",
+            listener.local_addr().expect("listener address")
+        );
+        let (sent, received) = mpsc::channel();
+        std::thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept webhook request");
+            read_webhook_request(&mut stream);
+            stream
+                .write_all(
+                    b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+                )
+                .expect("reply");
+            sent.send(()).expect("record webhook request");
+        });
+        (url, received)
+    }
+
+    /// A one-request endpoint that KEEPS the request bytes.
+    ///
+    /// `webhook_endpoint` only reports that something arrived, which is enough for the delivery
+    /// tests and is exactly not enough for a substitution one: a rule that posts its template
+    /// verbatim arrives just as reliably as one that posts the resolved body. The bytes are the
+    /// only place the difference exists.
+    fn capturing_webhook_endpoint() -> (String, Receiver<Vec<u8>>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind loopback webhook listener");
+        let url = format!(
+            "http://{}",
+            listener.local_addr().expect("listener address")
+        );
+        let (sent, received) = mpsc::channel();
+        std::thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept webhook request");
+            stream
+                .set_read_timeout(Some(Duration::from_secs(3)))
+                .expect("read timeout");
+            let mut buffer = [0_u8; 4096];
+            let read = stream.read(&mut buffer).expect("read request");
+            stream
+                .write_all(
+                    b"HTTP/1.1 204 No Content
+Content-Length: 0
+Connection: close
+
+",
+                )
+                .expect("reply");
+            sent.send(buffer[..read].to_vec()).expect("record webhook request");
+        });
+        (url, received)
+    }
+
+    fn held_webhook_endpoint() -> (String, Sender<()>, Receiver<()>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind loopback webhook listener");
+        let url = format!(
+            "http://{}",
+            listener.local_addr().expect("listener address")
+        );
+        let (release_sent, release_received) = mpsc::channel();
+        let (arrived_sent, arrived_received) = mpsc::channel();
+        std::thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept webhook request");
+            read_webhook_request(&mut stream);
+            arrived_sent.send(()).expect("record webhook arrival");
+            release_received.recv().expect("release webhook response");
+            stream
+                .write_all(
+                    b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+                )
+                .expect("reply");
+        });
+        (url, release_sent, arrived_received)
+    }
+
+    fn read_webhook_request(stream: &mut TcpStream) {
+        stream
+            .set_read_timeout(Some(Duration::from_secs(3)))
+            .expect("read timeout");
+        let mut buffer = [0_u8; 4096];
+        assert_ne!(stream.read(&mut buffer).expect("read request"), 0);
+    }
+
+    fn add_discord_webhook(graph: &mut crate::automation_store::AutomationGraph, url: String) {
+        graph.webhook = Some(WebhookStep {
+            provider: WebhookProvider::Discord,
+            url,
+            body: "webhook body".into(),
+            substitute: false,
+        });
+    }
+
+    // =============================================================================================
+    // Task 8 — one crossing, two destinations
+    // =============================================================================================
+
+    /// Normal live-terminal scenario: the terminal stays live after the crossing is decided, but
+    /// its malformed webhook endpoint fails. That failure must not suppress the terminal delivery.
+    #[tokio::test]
+    async fn a_failed_webhook_leaves_the_terminal_send_alone() {
+        let (engine, fake, host) = rig_with_rule_bypassing_the_enable_gate(|graph| {
+            // reqwest rejects this while building the request; it cannot leave this machine.
+            add_discord_webhook(graph, "not a valid URL".into());
+        });
+        let send = pending(&engine, &host, ArmState::armed(), 4_000);
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        assert!(
+            fake.written()
+                .iter()
+                .any(|write| write.contains("prepare to do context-hand-off")),
+            "the terminal destination was suppressed by a failed webhook: {:?}",
+            fake.written()
+        );
+        let rows = fake
+            .store
+            .load_automation_log(&LogScope::All, LogOrder::Asc, 10)
+            .unwrap();
+        assert_eq!(
+            rows.len(),
+            2,
+            "each destination writes its own outcome: {rows:?}"
+        );
+        assert!(rows
+            .iter()
+            .any(|row| row.kind == LogKind::Sent && row.terminal_id.as_deref() == Some("tm-1")));
+        assert!(rows
+            .iter()
+            .any(|row| row.kind == LogKind::Failed && row.terminal_id.is_none()));
+    }
+
+    /// Already-decided / terminal-closed scenario from the scope note: the leaf disappears after
+    /// the crossing exists, so the terminal fails, but the webhook still sends once and retires the
+    /// runs-once rule rather than rolling the arm back for a repeat.
+    #[tokio::test]
+    async fn a_failed_terminal_send_does_not_let_the_webhook_repeat() {
+        let (url, requested) = webhook_endpoint();
+        let mut rule = ctx_rule("au-1");
+        rule.runs_once = true;
+        add_discord_webhook(&mut rule.graph, url);
+        let (engine, fake, host) = wire_bypassing_the_enable_gate(vec![rule]);
+        let send = pending(&engine, &host, ArmState::armed(), 4_000);
+        fake.close("tm-1");
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        requested
+            .recv_timeout(Duration::from_secs(3))
+            .expect("the webhook was sent after the terminal closed");
+        assert!(
+            !engine.is_live("au-1"),
+            "the successful webhook completed the crossing once"
+        );
+        let rows = fake
+            .store
+            .load_automation_log(&LogScope::All, LogOrder::Asc, 10)
+            .unwrap();
+        assert!(rows
+            .iter()
+            .any(|row| row.kind == LogKind::Failed && row.terminal_id.as_deref() == Some("tm-1")));
+        assert!(rows
+            .iter()
+            .any(|row| row.kind == LogKind::Sent && row.terminal_id.is_none()));
+    }
+
+    /// Normal live-terminal scenario: both destinations succeed for one already-decided crossing,
+    /// so its fire history increments once rather than once per destination.
+    #[tokio::test]
+    async fn a_crossing_records_one_fire_however_many_destinations_it_had() {
+        let (url, requested) = webhook_endpoint();
+        let (engine, _fake, host) =
+            rig_with_rule_bypassing_the_enable_gate(|graph| add_discord_webhook(graph, url));
+        let send = pending(&engine, &host, ArmState::armed(), 4_000);
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        requested
+            .recv_timeout(Duration::from_secs(3))
+            .expect("webhook request");
+        assert_eq!(
+            engine.runtime.fire_record("au-1", "tm-1"),
+            Some((1, 4_000)),
+            "two destinations are one crossing, not two fires"
+        );
+    }
+
+    /// Normal live-terminal scenario: the terminal has finished its 500 ms delivery while the
+    /// webhook deliberately waits for its local response. Completion must wait for that response.
+    #[tokio::test]
+    async fn completion_waits_for_every_destination_not_the_first() {
+        let (url, release, arrived) = held_webhook_endpoint();
+        let mut rule = ctx_rule("au-1");
+        rule.runs_once = true;
+        add_discord_webhook(&mut rule.graph, url);
+        let (engine, fake, host) = wire_bypassing_the_enable_gate(vec![rule]);
+        let send = pending(&engine, &host, ArmState::armed(), 4_000);
+        let task = tokio::spawn(run_crossing(engine.clone(), host.clone(), send));
+
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        arrived
+            .try_recv()
+            .expect("webhook request reached the held listener");
+        tokio::time::sleep(Duration::from_millis(650)).await;
+        assert!(
+            fake.written()
+                .iter()
+                .any(|write| write.contains("prepare to do context-hand-off")),
+            "the terminal destination did not complete"
+        );
+        assert!(
+            engine.is_live("au-1"),
+            "the first completed destination retired the rule early"
+        );
+        assert!(
+            !task.is_finished(),
+            "the crossing returned before the held webhook did"
+        );
+
+        release.send(()).expect("release webhook response");
+        task.await.expect("crossing task");
+        assert!(
+            !engine.is_live("au-1"),
+            "completion did not follow both destination outcomes"
+        );
+    }
+
+    /// Normal live-terminal scenario: this is the strong two-row oracle. Both rows must name the
+    /// same rule and decision timestamp, while their terminal identity, provider identity, kind,
+    /// and observed delivery outcomes distinguish a terminal send from a webhook send.
+    #[tokio::test]
+    async fn one_crossing_with_two_destinations_writes_one_row_each() {
+        let (url, requested) = webhook_endpoint();
+        let (engine, fake, host) =
+            rig_with_rule_bypassing_the_enable_gate(|graph| add_discord_webhook(graph, url));
+        let send = pending(&engine, &host, ArmState::armed(), 4_242);
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        requested
+            .recv_timeout(Duration::from_secs(3))
+            .expect("webhook request");
+        assert!(
+            fake.written()
+                .iter()
+                .any(|write| write.contains("prepare to do context-hand-off")),
+            "the terminal delivery did not occur"
+        );
+        let rows = fake
+            .store
+            .load_automation_log(&LogScope::All, LogOrder::Asc, 10)
+            .unwrap();
+        assert_eq!(rows.len(), 2, "not a bare count: inspect both rows below");
+        let terminal = rows
+            .iter()
+            .find(|row| row.terminal_id.as_deref() == Some("tm-1"))
+            .expect("terminal destination row");
+        assert_eq!(terminal.rule_id, "au-1");
+        assert_eq!(terminal.at, 4_242);
+        assert_eq!(terminal.kind, LogKind::Sent);
+        assert_eq!(terminal.terminal_name.as_deref(), Some("codex · core"));
+        assert_eq!(terminal.detail, "sent to codex · core");
+
+        let webhook = rows
+            .iter()
+            .find(|row| row.terminal_id.is_none())
+            .expect("webhook destination row");
+        assert_eq!(webhook.rule_id, "au-1");
+        assert_eq!(webhook.at, 4_242);
+        assert_eq!(webhook.kind, LogKind::Sent);
+        assert_eq!(webhook.terminal_name, None);
+        assert_eq!(webhook.detail, "webhook sent via Discord");
+    }
+
+    /// Source-derived rather than behavioural: the dispatch code has no clock of its own, and the
+    /// webhook sibling never takes `send_lock`. This test exercises no terminal scenario.
+    #[test]
+    fn the_webhook_path_adds_no_new_clock() {
+        let source = strip_comments(include_str!("loops.rs"));
+        let crossing_start = source
+            .rfind("async fn run_crossing(")
+            .expect("crossing function");
+        let webhook_start = source
+            .rfind("async fn run_webhook(")
+            .expect("webhook function");
+        let terminal_start = source
+            .rfind("async fn run_send(")
+            .expect("terminal function");
+        let completion_start = source
+            .rfind("fn complete_crossing(")
+            .expect("completion function");
+        let crossing = &source[crossing_start..terminal_start];
+        let webhook = &source[webhook_start..completion_start];
+        assert!(
+            crossing.contains("tokio::join!"),
+            "destinations must be aggregated together"
+        );
+        for body in [crossing, webhook] {
+            assert!(
+                !body.contains("tokio::time::interval"),
+                "a webhook path added an interval"
+            );
+            assert!(
+                !body.contains("tokio::time::sleep"),
+                "a webhook path added a sleep"
+            );
+        }
+        assert!(
+            !webhook.contains("send_lock"),
+            "a webhook must not queue behind a terminal send"
+        );
+        assert!(crossing.contains("run_send") && crossing.contains("run_webhook"));
+    }
+
+    /// **The webhook destination posts the RESOLVED body**, the exact twin of the test above.
+    ///
+    /// Reported from a live build: *"on Discord I got the $0, not the matched value"*. The
+    /// substitution in `run_webhook` was correct, and nothing covered it — every webhook test until
+    /// now asserted only that a request ARRIVED, which a rule posting its template verbatim does
+    /// just as reliably. `capturing_webhook_endpoint` exists so the assertion can be about the
+    /// bytes, where the difference actually lives.
+    ///
+    /// Driven through `run_crossing` with a hand-built `Captures` rather than through a tick,
+    /// because the two neighbouring webhook tests do: reqwest is real I/O and the tick-driven
+    /// tests run on a paused clock.
+    #[tokio::test]
+    async fn a_crossing_posts_the_resolved_webhook_body() {
+        let (url, posted) = capturing_webhook_endpoint();
+        let (engine, _fake, host) = rig_with_rule_bypassing_the_enable_gate(|graph| {
+            add_discord_webhook(graph, url);
+            let webhook = graph.webhook.as_mut().expect("the webhook just added");
+            webhook.body = "Fix the $1 failing tests in $2".into();
+            webhook.substitute = true;
+        });
+        let mut send = pending(&engine, &host, ArmState::armed(), 4_000);
+        send.captures = Some(Captures {
+            groups: vec![
+                Some("FAILED 17 tests in a.ts".into()),
+                Some("17".into()),
+                Some("a.ts".into()),
+            ],
+            named: Default::default(),
+        });
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        let request = posted
+            .recv_timeout(Duration::from_secs(3))
+            .expect("the webhook was never posted");
+        let text = String::from_utf8_lossy(&request);
+        assert!(
+            text.contains("Fix the 17 failing tests in a.ts"),
+            "the resolved body never reached the wire: {text}"
+        );
+        // The complaint in its own words: the token itself must not survive the send.
+        assert!(!text.contains("$1"), "a raw token was posted: {text}");
+    }
+
+    /// The other half of the pair, and the reason the flag is worth having: with substitution off
+    /// the body is posted EXACTLY as typed. Asserted so that "resolved" above cannot be satisfied
+    /// by a sender that always substitutes — a webhook body is sometimes JSON a user wrote by
+    /// hand, and `$` is not always a token.
+    #[tokio::test]
+    async fn a_webhook_that_opted_out_posts_its_body_verbatim() {
+        let (url, posted) = capturing_webhook_endpoint();
+        let (engine, _fake, host) = rig_with_rule_bypassing_the_enable_gate(|graph| {
+            add_discord_webhook(graph, url);
+            let webhook = graph.webhook.as_mut().expect("the webhook just added");
+            webhook.body = "Fix the $1 failing tests in $2".into();
+            webhook.substitute = false;
+        });
+        let mut send = pending(&engine, &host, ArmState::armed(), 4_000);
+        send.captures = Some(Captures {
+            groups: vec![Some("FAILED 17 tests in a.ts".into()), Some("17".into())],
+            named: Default::default(),
+        });
+
+        run_crossing(engine.clone(), host.clone(), send).await;
+
+        let request = posted
+            .recv_timeout(Duration::from_secs(3))
+            .expect("the webhook was never posted");
+        let text = String::from_utf8_lossy(&request);
+        assert!(text.contains("$1"), "the opted-out body was rewritten: {text}");
+    }
+}
+
 // =================================================================================================
 // The evaluator (§2.3)
 // =================================================================================================
@@ -215,7 +649,11 @@ pub async fn evaluator_step(
         // the pair's *"Waiting to send"* pill sits on a countdown that reached zero and stopped,
         // until something unrelated repaints it. Marked and not emitted: one drain point, one rate
         // limit, and `evaluate_tick` below is that point.
-        if engine.runtime.drop_stale_parked(now_ms, crate::automation_validation::MAX_DELAY_MS) > 0 {
+        if engine
+            .runtime
+            .drop_stale_parked(now_ms, crate::automation_validation::MAX_DELAY_MS)
+            > 0
+        {
             engine.mark_state_dirty();
         }
     }
@@ -255,7 +693,11 @@ pub async fn evaluate_tick(
     let now_local = schedule::local_now(now_ms);
     for live in engine.snapshot_live() {
         // Sorted, so which pairs the cap holds over is a property of the rule and not of hash order.
-        let mut leaves: Vec<String> = engine.runtime.watched_for(&live.rule.id).into_iter().collect();
+        let mut leaves: Vec<String> = engine
+            .runtime
+            .watched_for(&live.rule.id)
+            .into_iter()
+            .collect();
         leaves.sort();
         // **§6.3's two rule-level facts, decided BEFORE the leaves.**
         //
@@ -278,11 +720,17 @@ pub async fn evaluate_tick(
         // crossing as well as on the clock. `schedule_due` is deliberately false for `AfterMatch`, so
         // it cannot double as the "is this a schedule rule" question: that is what `scheduled` is.
         let scheduled = match &live.rule.graph.timer {
-            Some(TimerStep { mode: mode @ TimerMode::DailyAt { .. } }) => Some(mode),
+            Some(TimerStep {
+                mode: mode @ TimerMode::DailyAt { .. },
+            }) => Some(mode),
             _ => None,
         };
         let fires_now = scheduled.is_some_and(|mode| {
-            schedule::schedule_due(mode, engine.runtime.last_fired_day(&live.rule.id), now_local)
+            schedule::schedule_due(
+                mode,
+                engine.runtime.last_fired_day(&live.rule.id),
+                now_local,
+            )
         });
         for tm in leaves {
             // The ONE tm -> pc conversion. `None` is dormant (§4.5), not dead: no evaluation, no log
@@ -332,21 +780,22 @@ pub async fn evaluate_tick(
             // message it is about to type.
             if let Some(parked) = engine.runtime.take_parked_due(&live.rule.id, &tm, now_ms) {
                 admit(
-                    engine,
-                    host,
                     &mut sends,
                     PendingSend {
                         // **`parked.pc`, never the `pc` this tick just resolved.** The restart
                         // guard in `run_send` compares the leaf's process at lock time against
                         // this field; filled from the drain's own lookup it compares a value
                         // against itself and the whole park is unguarded.
-                        pair: Pair { rule: live.clone(), tm: tm.clone(), pc: parked.pc },
+                        pair: Pair {
+                            rule: live.clone(),
+                            tm: tm.clone(),
+                            pc: parked.pc,
+                        },
                         prev: parked.prev,
                         label: parked.label,
                         at_ms: now_ms,
                         captures: parked.captures,
                     },
-                    now_ms,
                 );
             }
             let seq = engine.runtime.dirty_seq(&pc);
@@ -376,11 +825,13 @@ pub async fn evaluate_tick(
             if scheduled.is_some() {
                 if fires_now {
                     admit(
-                        engine,
-                        host,
                         &mut sends,
                         PendingSend {
-                            pair: Pair { rule: live.clone(), tm: tm.clone(), pc },
+                            pair: Pair {
+                                rule: live.clone(),
+                                tm: tm.clone(),
+                                pc,
+                            },
                             // **Read, not assumed.** `prev` is what `run_send`'s three failure paths
                             // roll back to, and a schedule rule has no crossing to roll back to — so
                             // the only correct target is whatever is already there, which makes
@@ -402,7 +853,6 @@ pub async fn evaluate_tick(
                             // template into a live agent.
                             captures: None,
                         },
-                        now_ms,
                     );
                 }
                 continue;
@@ -432,7 +882,11 @@ pub async fn evaluate_tick(
                 engine.runtime.last_eval(&live.rule.id, &tm),
                 now_ms,
             ) {
-                due.push(Pair { rule: live.clone(), tm, pc });
+                due.push(Pair {
+                    rule: live.clone(),
+                    tm,
+                    pc,
+                });
             } else if monitor.cadence == Cadence::OnOutput {
                 // No `seq.is_some()` here, deliberately: a CLEAN process contributes no due pair, so
                 // it never reaches `due_pcs` and `settled_processes` can never name it — the extra
@@ -456,7 +910,9 @@ pub async fn evaluate_tick(
             let Some(TimerMode::DailyAt { minute_of_day, .. }) = scheduled else {
                 unreachable!("fires_now requires a daily schedule");
             };
-            engine.runtime.set_last_fired_day(&live.rule.id, now_local.day_ordinal, *minute_of_day);
+            engine
+                .runtime
+                .set_last_fired_day(&live.rule.id, now_local.day_ordinal, *minute_of_day);
         }
     }
 
@@ -472,7 +928,7 @@ pub async fn evaluate_tick(
 
     for i in &picked {
         match evaluate_pair(engine, host, &due[*i], now_ms) {
-            Evaluated::Read(Some(send)) => admit(engine, host, &mut sends, send, now_ms),
+            Evaluated::Read(Some(send)) => admit(&mut sends, send),
             // Read, decided, nothing to send: this pair has consumed the output and may spend it.
             Evaluated::Read(None) => {}
             // **The third door.** `settled_processes`'s enumeration named two and this was neither:
@@ -497,9 +953,16 @@ pub async fn evaluate_tick(
     // sends in one tick would freeze evaluation for two seconds. Serialisation is unaffected: it was
     // never the tick that provided it, it was the per-terminal lock.
     for send in sends {
+        // A crossing owns its destinations and all of their shared bookkeeping. In particular, a
+        // webhook-only rule has no terminal destination: never manufacture an ActionStep merely to
+        // route it through `run_send`, because an empty action can submit a bare Enter.
+        if send.pair.rule.rule.graph.action.is_none() && send.pair.rule.rule.graph.webhook.is_none()
+        {
+            continue;
+        }
         let engine = engine.clone();
         let host = host.clone();
-        tokio::spawn(async move { run_send(engine, host, send).await });
+        tokio::spawn(async move { run_crossing(engine, host, send).await });
     }
 
     if engine.take_state_emit(now_ms) {
@@ -509,59 +972,13 @@ pub async fn evaluate_tick(
     next_cursor
 }
 
-/// Put one decided send on this tick's dispatch list, if R6 lets it through.
-///
-/// **R6 is per RULE — not per pair, and not per TICK.** A `runs_once` rule watching three terminals
-/// crosses on all three, and the send lock is per LEAF, so three tasks take three different locks
-/// and three messages go out on a rule the user asked to run once.
+/// Put one decided crossing on this tick's dispatch list.
 ///
-/// The claim is taken HERE, where the crossing is decided. The first version of this scanned the
-/// current tick's `sends` vector, which covers the three-in-one-tick case and nothing else: two
-/// terminals crossing on consecutive ticks are two separate vectors, and the only cross-tick guard
-/// was `is_live`, which does not go false until `complete_rule` runs — after `deliver` returns, two
-/// ticks later. The arm states advance either way; only the send is dropped, so a pair that did not
-/// send stays `Fired` and never sends.
-///
-/// **It is a function because there are now two routes onto that list**, and a gate written at one
-/// caller is a gate the next caller opts out of. §6.2's parked sends are the second route, and they
-/// need it more than the first: a `runs_once` rule with a delay parks on every terminal that
-/// crosses *during* the wait — the arm machine cannot stop that, because those are different pairs —
-/// and all of them come ripe on the same tick, where without this they would be three sends.
-fn admit(
-    engine: &Arc<AutomationEngine>,
-    host: &Arc<dyn EngineHost>,
-    sends: &mut Vec<PendingSend>,
-    send: PendingSend,
-    now_ms: i64,
-) {
-    let rule_id = &send.pair.rule.rule.id;
-    if !send.pair.rule.rule.runs_once || engine.runtime.claim_once(rule_id) {
-        sends.push(send);
-        return;
-    }
-    // **A dropped crossing that says nothing is a crossing the user cannot account for.** The arm
-    // state advanced at decide time and the parked entry was taken out of the map by
-    // `take_parked_due`, so this pair is finished either way — and on the delay route it had been
-    // visibly *"Waiting to send"* for up to ten minutes first. Without a row the only trace of it is
-    // a countdown that stopped.
-    //
-    // `Held` and not `Failed`, for the seeding row's reason: nothing went wrong. The rule was asked
-    // and the rule declined, which is also what keeps it out of the verbose gate. It is bounded by
-    // the claim itself — one row per losing pair per crossing, and a claimed `runs_once` rule
-    // leaves the live set as soon as its send lands.
-    //
-    // Written HERE rather than at the parked drain that found it, because `admit` is the one gate
-    // all three routes go through and a row written at one caller is a row the next caller opts out
-    // of — the same reasoning that put the claim itself in this function.
-    append(
-        host,
-        rule_id,
-        Some(&send.pair.tm),
-        send.label.clone(),
-        LogKind::Held,
-        "not sent — this rule runs once, and another terminal had already claimed its one send",
-        now_ms,
-    );
+/// Both immediate and parked crossings use this one dispatch seam. Admission, including the
+/// runs-once claim, belongs to `run_crossing`: it is crossing-wide bookkeeping rather than a
+/// property of either destination.
+fn admit(sends: &mut Vec<PendingSend>, send: PendingSend) {
+    sends.push(send);
 }
 
 /// What one pair's evaluation leaves for the tick to do.
@@ -615,15 +1032,9 @@ pub fn evaluate_pair(
         return Evaluated::Unread;
     };
 
-    let Some(ev): Option<Evaluation> = eval::evaluate(
-        steps,
-        re,
-        &echoes,
-        prev,
-        &port,
-        &pair.pc,
-        now_ms,
-    ) else {
+    let Some(ev): Option<Evaluation> =
+        eval::evaluate(steps, re, &echoes, prev, &port, &pair.pc, now_ms)
+    else {
         // `host.tail` found no parser for this process — it closed between this tick's leaf
         // resolution and the read. §4.5: no evaluation, no row, arm state untouched. `set_last_eval`
         // is deliberately not reached either, so the pair is due again immediately.
@@ -644,12 +1055,22 @@ pub fn evaluate_pair(
     }
 
     let repeat = engine.runtime.last_decision(&rule.id, &pair.tm) == Some(ev.decision);
-    engine.runtime.set_last_decision(&rule.id, &pair.tm, ev.decision);
+    engine
+        .runtime
+        .set_last_decision(&rule.id, &pair.tm, ev.decision);
 
     if !ev.decision.sends() {
         // Live by construction: `evaluate_pair` only runs for a pair whose leaf just resolved.
         let name = host.label_for(&pair.tm);
-        append(host, &rule.id, Some(&pair.tm), name, kind_for(&ev, repeat), &ev.detail, now_ms);
+        append(
+            host,
+            &rule.id,
+            Some(&pair.tm),
+            name,
+            kind_for(&ev, repeat),
+            &ev.detail,
+            now_ms,
+        );
         return Evaluated::Read(None);
     }
 
@@ -660,7 +1081,10 @@ pub fn evaluate_pair(
     // it. `Read(None)` and not `Unread`, because this pair genuinely READ the terminal's output —
     // that read is how it found the match — so the dirty flag is spent exactly as it would have
     // been by a send.
-    if let Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms } }) = &rule.graph.timer {
+    if let Some(TimerStep {
+        mode: TimerMode::AfterMatch { delay_ms },
+    }) = &rule.graph.timer
+    {
         engine.runtime.park(
             &rule.id,
             &pair.tm,
@@ -726,21 +1150,156 @@ fn kind_for(ev: &Evaluation, repeat: bool) -> LogKind {
 }
 
 // =================================================================================================
-// The send (§2.5, §2.6)
+// The crossing and its destinations (§2.5, §2.6, A8)
 // =================================================================================================
 
-/// Take the terminal's queue, re-check it is still there, write, and record what happened.
+/// The result of one destination, deliberately separate from the crossing's shared state.
+enum DestinationOutcome {
+    Sent,
+    Failed(String),
+    Stopped,
+}
+
+/// Dispatch both destinations for one already-decided crossing, then perform its bookkeeping once.
 ///
-/// **Every failure path rolls the arm state back and writes exactly one log line** — the queue timed
-/// out, the terminal closed between the decision and the write, the write itself failed. Never left
-/// `Fired`, because a crossing that produced no message must still be able to fire.
-pub async fn run_send(
-    engine: Arc<AutomationEngine>,
-    host: Arc<dyn EngineHost>,
-    send: PendingSend,
-) {
+/// A terminal delivery and a webhook are independent side effects: one failure must not prevent the
+/// other from running. Their common effects — the fire history, runs-once completion, and rollback —
+/// are therefore deliberately below the join, where there is one answer for the crossing rather than
+/// one answer per destination.
+async fn run_crossing(engine: Arc<AutomationEngine>, host: Arc<dyn EngineHost>, send: PendingSend) {
+    let rule = &send.pair.rule.rule;
+    if engine.stopping.load(Ordering::Relaxed) {
+        rollback_crossing(&engine, &send);
+        return;
+    }
+
+    // R6 is per crossing, not per terminal destination. This task begins at the one shared
+    // boundary before the concurrent sends, so a second crossing cannot send either destination
+    // after the first one has claimed the rule.
+    if rule.runs_once && !engine.runtime.claim_once(&rule.id) {
+        append(
+            &host,
+            &rule.id,
+            Some(&send.pair.tm),
+            send.label.clone(),
+            LogKind::Held,
+            "not sent — this rule runs once, and another terminal had already claimed its one send",
+            send.at_ms,
+        );
+        return;
+    }
+
+    let has_action = rule.graph.action.is_some();
+    let has_webhook = rule.graph.webhook.is_some();
+    let (terminal, webhook) = tokio::join!(
+        async {
+            if has_action {
+                Some(run_send(&engine, &host, &send).await)
+            } else {
+                None
+            }
+        },
+        async {
+            if has_webhook {
+                Some(run_webhook(&engine, &send).await)
+            } else {
+                None
+            }
+        },
+    );
+
+    let outcomes = [terminal, webhook];
+    if outcomes
+        .iter()
+        .flatten()
+        .any(|outcome| matches!(outcome, DestinationOutcome::Stopped))
+    {
+        rollback_crossing(&engine, &send);
+        return;
+    }
+
+    let mut sent = false;
+    if let Some(outcome) = outcomes[0].as_ref() {
+        match outcome {
+            DestinationOutcome::Sent => {
+                sent = true;
+                append(
+                    &host,
+                    &rule.id,
+                    Some(&send.pair.tm),
+                    send.label.clone(),
+                    LogKind::Sent,
+                    &sent_detail(&send),
+                    send.at_ms,
+                );
+            }
+            DestinationOutcome::Failed(reason) => append(
+                &host,
+                &rule.id,
+                Some(&send.pair.tm),
+                send.label.clone(),
+                LogKind::Failed,
+                reason,
+                send.at_ms,
+            ),
+            DestinationOutcome::Stopped => unreachable!("stopped outcomes returned above"),
+        }
+    }
+    if let Some(outcome) = outcomes[1].as_ref() {
+        match outcome {
+            DestinationOutcome::Sent => {
+                sent = true;
+                append(
+                    &host,
+                    &rule.id,
+                    None,
+                    None,
+                    LogKind::Sent,
+                    &webhook_sent_detail(&send),
+                    send.at_ms,
+                );
+            }
+            DestinationOutcome::Failed(reason) => append(
+                &host,
+                &rule.id,
+                None,
+                None,
+                LogKind::Failed,
+                reason,
+                send.at_ms,
+            ),
+            DestinationOutcome::Stopped => unreachable!("stopped outcomes returned above"),
+        }
+    }
+
+    if !sent {
+        rollback_crossing(&engine, &send);
+        return;
+    }
+
+    // One crossing records one fire however many destinations completed. A terminal echo/settle
+    // remains owned by `run_send`, because only terminal bytes can be echoed back into a screen.
+    engine
+        .runtime
+        .record_fire(&rule.id, &send.pair.tm, send.at_ms);
+    complete_crossing(&engine, &host, &send);
+    engine.mark_state_dirty();
+}
+
+/// Take the terminal's queue, re-check it is still there, and write its destination.
+///
+/// This function has no crossing bookkeeping: `run_crossing` aggregates its result with the webhook
+/// before it records a fire, completes a runs-once rule, or rolls an arm back.
+async fn run_send(
+    engine: &Arc<AutomationEngine>,
+    host: &Arc<dyn EngineHost>,
+    send: &PendingSend,
+) -> DestinationOutcome {
     let rule = &send.pair.rule.rule;
     let tm = send.pair.tm.clone();
+    let Some(action) = rule.graph.action.as_ref() else {
+        return DestinationOutcome::Failed("the rule has no terminal destination".into());
+    };
     // **Before the queue.** §2.6 layer 2 runs for `ECHO_SETTLE_MS` after the WRITE, and the wait for
     // this terminal's lock is up to `SEND_QUEUE_TIMEOUT_MS` of the distance between the decision and
     // that write. Started after the lock, this measured only `deliver` — so the second and later
@@ -749,21 +1308,20 @@ pub async fn run_send(
     let began = tokio::time::Instant::now();
     let lock = engine.runtime.send_lock(&tm);
 
-    let _guard = match tokio::time::timeout(
-        Duration::from_millis(SEND_QUEUE_TIMEOUT_MS),
-        lock.lock(),
-    )
-    .await
-    {
-        Ok(guard) => guard,
-        Err(_) => {
-            return fail(&engine, &host, &send, "another rule was still sending");
-        }
-    };
+    let _guard =
+        match tokio::time::timeout(Duration::from_millis(SEND_QUEUE_TIMEOUT_MS), lock.lock()).await
+        {
+            Ok(guard) => guard,
+            Err(_) => {
+                return DestinationOutcome::Failed("another rule was still sending".into());
+            }
+        };
 
     // Inside the lock, because the terminal can close between the decision and our turn at the queue.
     let Some(pc) = host.process_for_leaf(&tm) else {
-        return fail(&engine, &host, &send, "the terminal closed before the message was sent");
+        return DestinationOutcome::Failed(
+            "the terminal closed before the message was sent".into(),
+        );
     };
 
     // **And it can close AND COME BACK, which resolving by leaf alone cannot see.** `tm-` is durable
@@ -781,7 +1339,9 @@ pub async fn run_send(
     // carries the crossing's process across that wait — built from the drain's own lookup instead,
     // this comparison would be a value against itself for every delayed rule.
     if pc != send.pair.pc {
-        return fail(&engine, &host, &send, "the terminal restarted before the message was sent");
+        return DestinationOutcome::Failed(
+            "the terminal restarted before the message was sent".into(),
+        );
     }
 
     // And so can the RULE. The queue wait is up to ten seconds, and a user who disables a rule inside
@@ -793,24 +1353,17 @@ pub async fn run_send(
     // that completed on another terminal, and told the user their rule had been turned off when
     // nobody had touched it.
     if !engine.is_live(&rule.id) {
-        return fail(&engine, &host, &send, "the rule was turned off before the message was sent");
+        return DestinationOutcome::Failed(
+            "the rule was turned off before the message was sent".into(),
+        );
     }
 
     // §2.1: checked before the FIRST write and never between the paste and the submit, so a quit
     // leaves the send either unstarted or complete — there is no half-typed line to reason about.
     if engine.stopping.load(Ordering::Relaxed) {
-        // The same rollback as `fail`, minus the row — the app is going down and the store is
-        // closing. It was the one rollback of three that announced nothing, so a pill caught
-        // mid-transition stayed on whatever it had last painted.
-        engine.runtime.restore_arm(&rule.id, &tm, send.prev);
-        if rule.runs_once {
-            engine.runtime.release_once(&rule.id);
-        }
-        engine.mark_state_dirty();
-        return;
+        return DestinationOutcome::Stopped;
     }
 
-    let action = &rule.graph.action;
     let body = if action.substitute {
         match subst::substitute(&action.message, send.captures.as_ref()) {
             Ok(s) => s,
@@ -818,12 +1371,9 @@ pub async fn run_send(
             // the "unintended content" this whole feature exists to prevent, and a refusal that is
             // logged is the safe fallback it asks for instead.
             Err(e) => {
-                return fail(
-                    &engine,
-                    &host,
-                    &send,
-                    &format!("nothing sent — {e} had no value at the moment it fired"),
-                );
+                return DestinationOutcome::Failed(format!(
+                    "nothing sent — {e} had no value at the moment it fired"
+                ));
             }
         }
     } else {
@@ -835,14 +1385,17 @@ pub async fn run_send(
         &HostPort(host.as_ref()),
         &pc,
         &action.cli_type,
-        crate::automation::send::SubmitPattern { separator, end_indicator },
+        crate::automation::send::SubmitPattern {
+            separator,
+            end_indicator,
+        },
         &body,
         action.submit,
     )
     .await;
 
     if let Err(e) = outcome {
-        return fail(&engine, &host, &send, &format!("the message could not be sent: {}", e));
+        return DestinationOutcome::Failed(format!("the message could not be sent: {}", e));
     }
 
     let at = send.at_ms;
@@ -855,14 +1408,57 @@ pub async fn run_send(
     // still strips it. The needle is `body` — what actually reached the terminal — never
     // `action.message`: with substitution on, the terminal echoes the RESOLVED text, and a needle
     // still carrying `$1` would never match it.
-    engine.runtime.push_echo(&tm, &crate::automation::send::normalise(&body), landed);
+    engine
+        .runtime
+        .push_echo(&tm, &crate::automation::send::normalise(&body), landed);
     engine.runtime.settle_until(&tm, landed + ECHO_SETTLE_MS);
-    engine.runtime.record_fire(&rule.id, &tm, at);
+    DestinationOutcome::Sent
+}
 
-    let name = send.label.clone();
-    append(&host, &rule.id, Some(&tm), name, LogKind::Sent, &sent_detail(&send), at);
+/// Post the webhook destination for this crossing. It intentionally never reaches the terminal
+/// queue lock: a slow endpoint must not serialise terminal writes, and a terminal failure must not
+/// suppress an already-decided webhook.
+async fn run_webhook(engine: &Arc<AutomationEngine>, send: &PendingSend) -> DestinationOutcome {
+    let rule = &send.pair.rule.rule;
+    let Some(webhook) = rule.graph.webhook.as_ref() else {
+        return DestinationOutcome::Failed("the rule has no webhook destination".into());
+    };
+    if engine.stopping.load(Ordering::Relaxed) {
+        return DestinationOutcome::Stopped;
+    }
+    if !engine.is_live(&rule.id) {
+        return DestinationOutcome::Failed(
+            "the rule was turned off before the webhook was sent".into(),
+        );
+    }
+    let body = if webhook.substitute {
+        match subst::substitute(&webhook.body, send.captures.as_ref()) {
+            Ok(body) => body,
+            Err(e) => {
+                return DestinationOutcome::Failed(format!(
+                    "webhook not sent — {e} had no value at the moment it fired"
+                ))
+            }
+        }
+    } else {
+        webhook.body.clone()
+    };
+    match crate::automation_webhook::send_body(webhook, &body).await {
+        Ok(()) => DestinationOutcome::Sent,
+        Err(error) => DestinationOutcome::Failed(format!("webhook failed: {error}")),
+    }
+}
 
-    // §7.8 — completion is an in-memory event FIRST and a row second, in this same critical section.
+/// Complete a successful crossing once, after every destination has returned.
+fn complete_crossing(
+    engine: &Arc<AutomationEngine>,
+    host: &Arc<dyn EngineHost>,
+    send: &PendingSend,
+) {
+    let rule = &send.pair.rule.rule;
+    let tm = &send.pair.tm;
+    let at = send.at_ms;
+    // §7.8 — completion is an in-memory event FIRST and a row second, after every destination.
     // `reload` runs from mutating store commands and this is the engine, which is not one: without
     // the in-memory removal the rule stays live in `Fired`, re-arms the moment its value drops, and
     // sends a SECOND message in the same session from a row the UI already shows as Completed.
@@ -893,7 +1489,7 @@ pub async fn run_send(
             append(
                 &host,
                 &rule.id,
-                Some(&tm),
+                Some(tm),
                 None,
                 LogKind::Failed,
                 "fired, but its completion could not be recorded — it may run again after a restart",
@@ -918,7 +1514,6 @@ pub async fn run_send(
         // the thing that failed, which makes disk stale rather than true.
         host.emit_changed(vec![rule.id.clone()]);
     }
-    engine.mark_state_dirty();
 }
 
 fn sent_detail(send: &PendingSend) -> String {
@@ -928,15 +1523,25 @@ fn sent_detail(send: &PendingSend) -> String {
     }
 }
 
-/// One failure: roll the arm state back to exactly where it was, and say so once.
-fn fail(
-    engine: &Arc<AutomationEngine>,
-    host: &Arc<dyn EngineHost>,
-    send: &PendingSend,
-    reason: &str,
-) {
+fn webhook_sent_detail(send: &PendingSend) -> String {
+    let provider = send
+        .pair
+        .rule
+        .rule
+        .graph
+        .webhook
+        .as_ref()
+        .expect("a webhook outcome requires a webhook step")
+        .provider;
+    format!("webhook sent via {provider:?}")
+}
+
+/// Roll one wholly failed crossing back to exactly the arm state it had when it was decided.
+fn rollback_crossing(engine: &Arc<AutomationEngine>, send: &PendingSend) {
     let rule_id = &send.pair.rule.rule.id;
-    engine.runtime.restore_arm(rule_id, &send.pair.tm, send.prev);
+    engine
+        .runtime
+        .restore_arm(rule_id, &send.pair.tm, send.prev);
     // A rollback restores; it never creates. The claim was taken when this crossing was DECIDED, so a
     // crossing that produced no message must give it back — otherwise one queue timeout retires a
     // single-run rule that has never sent anything.
@@ -944,17 +1549,6 @@ fn fail(
         engine.runtime.release_once(rule_id);
     }
     engine.mark_state_dirty();
-    append(
-        host,
-        rule_id,
-        Some(&send.pair.tm),
-        // The label resolved at DECIDE time. This is the whole reason `PendingSend` carries one:
-        // `the terminal closed` is written when there is no name left to look up.
-        send.label.clone(),
-        LogKind::Failed,
-        reason,
-        send.at_ms,
-    );
 }
 
 /// Append one row and emit if the store says one is due.
@@ -989,7 +1583,11 @@ fn append(
     match host.store().append(&entry) {
         Ok(Some(outcome)) if outcome.emit => host.emit_activity(outcome.rule_ids),
         Ok(_) => {}
-        Err(e) => log::warn!("automations: could not write a log row for {}: {}", rule_id, e),
+        Err(e) => log::warn!(
+            "automations: could not write a log row for {}: {}",
+            rule_id,
+            e
+        ),
     }
 }
 
@@ -1007,8 +1605,10 @@ pub async fn run_targeting(engine: Arc<AutomationEngine>, host: Arc<dyn EngineHo
     // BOTH halves of what `state_payload` is built from. Diffing only `missing` meant opening a
     // second terminal — adopted into `watched`, a new row in the payload — emitted nothing, so the
     // Settings page showed the rule watching one terminal until something else happened to fire.
-    let mut last: (HashMap<String, HashSet<String>>, HashMap<String, HashSet<String>>) =
-        (HashMap::new(), HashMap::new());
+    let mut last: (
+        HashMap<String, HashSet<String>>,
+        HashMap<String, HashSet<String>>,
+    ) = (HashMap::new(), HashMap::new());
     loop {
         if engine.stopping.load(Ordering::Relaxed) {
             return;
@@ -1017,7 +1617,8 @@ pub async fn run_targeting(engine: Arc<AutomationEngine>, host: Arc<dyn EngineHo
         // `new_all()` is 50-200 ms, and `ProcSnapshot`'s own doc says this call belongs off a
         // tokio worker.
         let (e, h) = (engine.clone(), host.clone());
-        let pass = match tokio::task::spawn_blocking(move || targeting_tick(&e, &h, now_ms())).await {
+        let pass = match tokio::task::spawn_blocking(move || targeting_tick(&e, &h, now_ms())).await
+        {
             Ok(pass) => pass,
             Err(e) => {
                 // `unwrap_or_default()` here turned a panicked roster pass into an EMPTY one, which
@@ -1075,14 +1676,19 @@ pub fn targeting_tick(
     let criteria: Vec<Criterion> = rules
         .iter()
         .filter(|l| l.rule.target_mode == TargetMode::Rule)
-        .map(|l| l.rule.criterion)
+        .flat_map(|l| std::iter::once(l.rule.criterion).chain(l.rule.exclude_criterion))
         .collect();
     let rows = host.roster(&criteria);
     // Indexed once, outside the rule loop: the snapshot walk below wants the row for a terminal it
     // already knows it watches, and scanning the whole roster per rule made that `rules × roster`.
-    let by_id: HashMap<&str, &crate::automation::roster::RosterRow> =
-        rows.iter().filter_map(|r| r.terminal_id.as_deref().map(|t| (t, r))).collect();
-    let live_leaves: HashSet<&str> = rows.iter().filter_map(|r| r.terminal_id.as_deref()).collect();
+    let by_id: HashMap<&str, &crate::automation::roster::RosterRow> = rows
+        .iter()
+        .filter_map(|r| r.terminal_id.as_deref().map(|t| (t, r)))
+        .collect();
+    let live_leaves: HashSet<&str> = rows
+        .iter()
+        .filter_map(|r| r.terminal_id.as_deref())
+        .collect();
     let grace_over = crate::automation::roster::grace_elapsed(now_ms, engine.started_at_ms());
     let mut missing = HashMap::new();
     let mut watched: HashMap<String, HashSet<String>> = HashMap::new();
@@ -1095,7 +1701,9 @@ pub fn targeting_tick(
         // consumer.)
         let previous: BTreeSet<String> = engine.runtime.watched_for(id).into_iter().collect();
         let next = watched_set(&live.rule, &rows, Some(&previous));
-        engine.runtime.set_watched(id, next.iter().cloned().collect());
+        engine
+            .runtime
+            .set_watched(id, next.iter().cloned().collect());
 
         // §2.4: *"keys are cleared when … a terminal leaves the watch set"*. Three of that
         // sentence's four events were implemented and this one was not. A `Command contains` rule
@@ -1116,17 +1724,24 @@ pub fn targeting_tick(
             let Some(row) = by_id.get(tm.as_str()) else {
                 continue;
             };
-            let label = crate::automation::labels::label_at(&crate::automation::labels::LabelInputs {
-                display_label: row.display_label.as_deref(),
-                name: Some(row.name.as_str()),
-                shell: Some(row.shell.as_str()),
-                // Writing the snapshot, so the snapshot is not an input to it.
-                snapshot: None,
-            });
+            let label =
+                crate::automation::labels::label_at(&crate::automation::labels::LabelInputs {
+                    display_label: row.display_label.as_deref(),
+                    name: Some(row.name.as_str()),
+                    shell: Some(row.shell.as_str()),
+                    // Writing the snapshot, so the snapshot is not an input to it.
+                    snapshot: None,
+                });
             if let Err(e) =
-                host.store().touch_target(id, tm, label.as_deref(), row.cwd.as_deref(), now_ms)
+                host.store()
+                    .touch_target(id, tm, label.as_deref(), row.cwd.as_deref(), now_ms)
             {
-                log::warn!("automations: could not record {}'s view of {}: {}", id, tm, e);
+                log::warn!(
+                    "automations: could not record {}'s view of {}: {}",
+                    id,
+                    tm,
+                    e
+                );
             }
         }
 
@@ -1147,14 +1762,13 @@ pub fn targeting_tick(
     TargetingPass { missing, watched }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
     // The fake, the canonical rule and the wiring are shared with the dry run's tests so there can
     // only ever be one of each.
-    use crate::automation_engine::test_host::*;
     use crate::automation::roster::RosterRow;
+    use crate::automation_engine::test_host::*;
     use crate::automation_store::{AutomationRule, Finds, Keep};
     use chrono::{Datelike, Local, NaiveDate, TimeZone, Weekday};
 
@@ -1178,17 +1792,26 @@ mod tests {
         // Twenty into a channel of four, before the tap has read any of them: the receiver is
         // guaranteed to see `Lagged`, which is the case that must not silently drop terminals.
         for i in 0..20 {
-            let _ = tx.send(ChannelPayload { id: format!("pc-{}", i % 2 + 1), data: vec![b'x'] });
+            let _ = tx.send(ChannelPayload {
+                id: format!("pc-{}", i % 2 + 1),
+                data: vec![b'x'],
+            });
         }
         let tap = tokio::spawn(run_tap(engine.clone(), host.clone(), rx));
         tokio::time::sleep(Duration::from_millis(50)).await;
 
         assert!(engine.runtime.is_dirty("pc-1"), "pc-1 never marked");
-        assert!(engine.runtime.is_dirty("pc-2"), "a lagged window must mark every live terminal");
+        assert!(
+            engine.runtime.is_dirty("pc-2"),
+            "a lagged window must mark every live terminal"
+        );
 
         engine.stop();
         tokio::time::sleep(Duration::from_millis(BASE_TICK_MS * 3)).await;
-        assert!(tap.is_finished(), "the tap must return once `stopping` is set");
+        assert!(
+            tap.is_finished(),
+            "the tap must return once `stopping` is set"
+        );
         drop(tx);
     }
 
@@ -1197,15 +1820,22 @@ mod tests {
     #[test]
     fn the_tap_body_never_reads_the_payload_bytes() {
         let source = strip_comments(include_str!("loops.rs"));
-        let start = source.find("pub async fn run_tap(").expect("run_tap must exist");
+        let start = source
+            .find("pub async fn run_tap(")
+            .expect("run_tap must exist");
         let rest = &source[start..];
-        let end = rest.find("\n}\n").expect("its body must be closed at column zero");
+        let end = rest
+            .find("\n}\n")
+            .expect("its body must be closed at column zero");
         let body = &rest[..end];
         assert!(
             !body.contains(".data"),
             "the tap carries a SIGNAL, not data: the parser already has every byte, losslessly"
         );
-        assert!(body.contains("mark_dirty"), "and it must actually mark something");
+        assert!(
+            body.contains("mark_dirty"),
+            "and it must actually mark something"
+        );
     }
 
     // =============================================================================================
@@ -1227,13 +1857,19 @@ mod tests {
         let targeting = tokio::spawn(run_targeting(engine.clone(), host.clone()));
 
         // The tap does work.
-        let _ = tx.send(ChannelPayload { id: "pc-1".into(), data: vec![b'x'] });
+        let _ = tx.send(ChannelPayload {
+            id: "pc-1".into(),
+            data: vec![b'x'],
+        });
         tokio::time::sleep(Duration::from_millis(50)).await;
         assert!(engine.runtime.is_dirty("pc-1"), "the tap did nothing");
 
         // The targeting tick does work: it re-resolves `All terminals` and adopts tm-1.
         tokio::time::sleep(Duration::from_millis(TARGETING_TICK_MS)).await;
-        assert!(engine.runtime.watches("au-1", "tm-1"), "the targeting tick did nothing");
+        assert!(
+            engine.runtime.watches("au-1", "tm-1"),
+            "the targeting tick did nothing"
+        );
 
         // And the evaluator does work: with a terminal watched and dirty, the pair evaluates.
         tokio::time::sleep(Duration::from_millis(BASE_TICK_MS * 4)).await;
@@ -1265,12 +1901,21 @@ mod tests {
 
         let cursor = evaluate_tick(&engine, &host, 0, 1_000).await;
         assert_eq!(cursor, 0);
-        assert!(fake.written().is_empty(), "a first sight must arm, never type");
+        assert!(
+            fake.written().is_empty(),
+            "a first sight must arm, never type"
+        );
         assert_eq!(engine.runtime.arm_state("au-1", "tm-1"), ArmState::armed());
         // Nothing in the log, and that is the verbose gate doing its job: an ordinary check is the
         // outcome of most evaluations and would otherwise write four rows a second per pair.
-        assert!(log_kinds(&fake.store).is_empty(), "an ungated check would flood the log");
-        assert!(!engine.runtime.is_dirty("pc-1"), "the only pair on pc-1 ran, so its flag is spent");
+        assert!(
+            log_kinds(&fake.store).is_empty(),
+            "an ungated check would flood the log"
+        );
+        assert!(
+            !engine.runtime.is_dirty("pc-1"),
+            "the only pair on pc-1 ran, so its flag is spent"
+        );
 
         // The crossing. `dirty` again, and past the 250 ms floor.
         engine.runtime.mark_dirty("pc-1");
@@ -1281,7 +1926,9 @@ mod tests {
 
         let writes = fake.written();
         assert!(
-            writes.iter().any(|w| w.contains("prepare to do context-hand-off")),
+            writes
+                .iter()
+                .any(|w| w.contains("prepare to do context-hand-off")),
             "the message was never typed: {:?}",
             writes
         );
@@ -1300,10 +1947,14 @@ mod tests {
         // message had even been typed — so the next tick read the rule's own echo as organic output.
         let gap = crate::automation::send::PASTE_SUBMIT_GAP_MS as i64;
         assert!(
-            engine.runtime.is_settling("tm-1", 2_000 + ECHO_SETTLE_MS + 1),
+            engine
+                .runtime
+                .is_settling("tm-1", 2_000 + ECHO_SETTLE_MS + 1),
             "the window closed a paste-to-submit gap too early"
         );
-        assert!(!engine.runtime.is_settling("tm-1", 2_000 + gap + ECHO_SETTLE_MS + 1));
+        assert!(!engine
+            .runtime
+            .is_settling("tm-1", 2_000 + gap + ECHO_SETTLE_MS + 1));
     }
 
     // =============================================================================================
@@ -1319,8 +1970,8 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = r"FAILED (\d+) tests in (\S+)".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "Fix the $1 failing tests in $2".into();
-            g.action.substitute = true;
+            g.action_mut().message = "Fix the $1 failing tests in $2".into();
+            g.action_mut().substitute = true;
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -1330,7 +1981,9 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
         assert!(
-            fake.written().iter().any(|w| w.contains("Fix the 17 failing tests in a.ts")),
+            fake.written()
+                .iter()
+                .any(|w| w.contains("Fix the 17 failing tests in a.ts")),
             "the resolved message was never typed: {:?}",
             fake.written()
         );
@@ -1357,10 +2010,17 @@ mod tests {
     #[tokio::test(start_paused = true)]
     async fn a_schedule_rule_reads_nothing_sends_nothing_and_logs_nothing() {
         let (engine, fake, host) = wire(vec![schedule_only_rule("au-sched")]);
-        assert_eq!(engine.snapshot_live().len(), 1, "premise: the rule IS live and IS walked");
+        assert_eq!(
+            engine.snapshot_live().len(),
+            1,
+            "premise: the rule IS live and IS walked"
+        );
 
-        fake.say("pc-1", "ctx:99% FAILED 3 tests
-");
+        fake.say(
+            "pc-1",
+            "ctx:99% FAILED 3 tests
+",
+        );
         // **What `wire` already wrote, before the ticks run.** `wire` reloads at epoch 0 and §7's
         // seeding writes one `held` row for a schedule whose minute is already past *in the
         // runner's own zone* — 19:00 the previous evening west of UTC, midnight on it. So an
@@ -1373,7 +2033,11 @@ mod tests {
         }
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
-        assert!(fake.written().is_empty(), "a rule with no pattern typed something: {:?}", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "a rule with no pattern typed something: {:?}",
+            fake.written()
+        );
         assert_eq!(
             log_rows(&fake.store),
             before,
@@ -1398,17 +2062,20 @@ mod tests {
     /// is identical; only the pattern is present. If the rig itself were broken, this would be
     /// silent too, and "sends nothing" would prove nothing at all.
     #[tokio::test(start_paused = true)]
-    async fn the_same_rig_with_a_pattern_does_send()  {
+    async fn the_same_rig_with_a_pattern_does_send() {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "FAILED".into();
             g.parse_mut().keep = Keep::Whole;
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "stand-up notes?".into();
+            g.action_mut().message = "stand-up notes?".into();
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
 
-        fake.say("pc-1", "ctx:99% FAILED 3 tests
-");
+        fake.say(
+            "pc-1",
+            "ctx:99% FAILED 3 tests
+",
+        );
         for tick in 0..8 {
             engine.runtime.mark_dirty("pc-1");
             evaluate_tick(&engine, &host, 0, 1_000 + tick * 250).await;
@@ -1450,7 +2117,9 @@ mod tests {
 
     /// The local ordinal `at_local`'s day maps to — `last_fired_day`'s key.
     fn day_ordinal(y: i32, m: u32, d: u32) -> i32 {
-        NaiveDate::from_ymd_opt(y, m, d).expect("a real date").num_days_from_ce()
+        NaiveDate::from_ymd_opt(y, m, d)
+            .expect("a real date")
+            .num_days_from_ce()
     }
 
     /// A rig with several terminals and each rule's watched set given explicitly.
@@ -1500,7 +2169,9 @@ mod tests {
         }
         for rule in &rules {
             if bypass_enable_gate {
-                fake.store.save_rule_bypassing_the_enable_gate_for_tests(rule).unwrap();
+                fake.store
+                    .save_rule_bypassing_the_enable_gate_for_tests(rule)
+                    .unwrap();
             } else {
                 fake.store.save_rule(rule).unwrap();
             }
@@ -1508,7 +2179,9 @@ mod tests {
         let engine = Arc::new(AutomationEngine::new(0));
         engine.reload(&fake.store, 0).unwrap();
         for (id, leaves) in watched {
-            engine.runtime.set_watched(id, leaves.iter().map(|tm| tm.to_string()).collect());
+            engine
+                .runtime
+                .set_watched(id, leaves.iter().map(|tm| tm.to_string()).collect());
         }
         let host: Arc<dyn EngineHost> = fake.clone();
         (engine, fake, host)
@@ -1530,9 +2203,20 @@ mod tests {
     #[tokio::test(start_paused = true)]
     async fn a_schedule_rule_sends_to_every_target_when_the_minute_arrives_and_reads_nothing() {
         let (engine, fake, host) = wire_targets(
-            vec![schedule_only_rule("au-sched"), ctx_rule_saying("au-read", "a reader", 2)],
-            &[("tm-1", "pc-1"), ("tm-2", "pc-2"), ("tm-3", "pc-3"), ("tm-4", "pc-4")],
-            &[("au-sched", &["tm-1", "tm-2", "tm-3"]), ("au-read", &["tm-4"])],
+            vec![
+                schedule_only_rule("au-sched"),
+                ctx_rule_saying("au-read", "a reader", 2),
+            ],
+            &[
+                ("tm-1", "pc-1"),
+                ("tm-2", "pc-2"),
+                ("tm-3", "pc-3"),
+                ("tm-4", "pc-4"),
+            ],
+            &[
+                ("au-sched", &["tm-1", "tm-2", "tm-3"]),
+                ("au-read", &["tm-4"]),
+            ],
         );
         // The reader has output and sits below its threshold, so it reads, arms, and sends nothing.
         fake.say("pc-4", "ctx:5%\n");
@@ -1562,8 +2246,16 @@ mod tests {
 
         // 6.3: a schedule rule has no arm state and must not disturb one.
         for tm in ["tm-1", "tm-2", "tm-3"] {
-            assert_eq!(engine.runtime.arm_state("au-sched", tm), ArmState::Unseen, "{tm} armed");
-            assert_eq!(engine.runtime.last_eval("au-sched", tm), None, "{tm} was evaluated");
+            assert_eq!(
+                engine.runtime.arm_state("au-sched", tm),
+                ArmState::Unseen,
+                "{tm} armed"
+            );
+            assert_eq!(
+                engine.runtime.last_eval("au-sched", tm),
+                None,
+                "{tm} was evaluated"
+            );
         }
         assert_eq!(
             engine.runtime.last_fired_day("au-sched"),
@@ -1619,7 +2311,10 @@ mod tests {
             &[("tm-1", "pc-1"), ("tm-3", "pc-3")],
             &[("au-sched", &["tm-1", "tm-2", "tm-3"])],
         );
-        assert!(host.process_for_leaf("tm-2").is_none(), "premise: tm-2 is dormant");
+        assert!(
+            host.process_for_leaf("tm-2").is_none(),
+            "premise: tm-2 is dormant"
+        );
 
         evaluate_tick(&engine, &host, 0, at_local(2026, 9, 7, Weekday::Mon, 9, 0)).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -1651,9 +2346,15 @@ mod tests {
     /// was killed outright.
     #[tokio::test(start_paused = true)]
     async fn a_schedule_whose_targets_were_all_asleep_does_not_nag_the_first_one_to_wake() {
-        let (engine, fake, host) =
-            wire_targets(vec![schedule_only_rule("au-sched")], &[], &[("au-sched", &["tm-1"])]);
-        assert!(host.process_for_leaf("tm-1").is_none(), "premise: nothing is awake");
+        let (engine, fake, host) = wire_targets(
+            vec![schedule_only_rule("au-sched")],
+            &[],
+            &[("au-sched", &["tm-1"])],
+        );
+        assert!(
+            host.process_for_leaf("tm-1").is_none(),
+            "premise: nothing is awake"
+        );
 
         evaluate_tick(&engine, &host, 0, at_local(2026, 9, 7, Weekday::Mon, 9, 0)).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -1726,11 +2427,22 @@ mod tests {
         let tuesday_afternoon = at_local(2026, 9, 8, Weekday::Tue, 14, 0);
         evaluator_step(&engine, &host, 0, Some(woke_at), tuesday_afternoon).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
-        assert!(fake.written().is_empty(), "delivered later the same day: {:?}", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "delivered later the same day: {:?}",
+            fake.written()
+        );
 
         // Wednesday, with the app genuinely awake across the minute.
         let wednesday = at_local(2026, 9, 9, Weekday::Wed, 9, 0);
-        evaluator_step(&engine, &host, 0, Some(wednesday - BASE_TICK_MS as i64), wednesday).await;
+        evaluator_step(
+            &engine,
+            &host,
+            0,
+            Some(wednesday - BASE_TICK_MS as i64),
+            wednesday,
+        )
+        .await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
         assert_eq!(
             sent_to(&fake, "stand-up notes?"),
@@ -1772,14 +2484,21 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
         let rows: Vec<_> = log_rows(&fake.store).split_off(before);
-        assert_eq!(rows.len(), 1, "the wake spent Tuesday and said nothing: {rows:?}");
+        assert_eq!(
+            rows.len(),
+            1,
+            "the wake spent Tuesday and said nothing: {rows:?}"
+        );
         assert_eq!(rows[0].0, "Held", "{rows:?}");
         assert_eq!(
             rows[0].1,
             "09:00 went by while nothing was watching the clock, so today's run was skipped",
             "{rows:?}"
         );
-        assert_eq!(rows[0].2, None, "a schedule's suppression names no terminal: {rows:?}");
+        assert_eq!(
+            rows[0].2, None,
+            "a schedule's suppression names no terminal: {rows:?}"
+        );
         assert!(
             fake.activity.load(std::sync::atomic::Ordering::Relaxed) > emits_before,
             "the row was written and no window was told to refetch the log"
@@ -1817,7 +2536,12 @@ mod tests {
         evaluator_step(&engine, &host, 0, Some(nine - BASE_TICK_MS as i64), nine).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
-        assert_eq!(sent_to(&fake, "stand-up notes?"), vec!["pc-1"], "{:?}", fake.written());
+        assert_eq!(
+            sent_to(&fake, "stand-up notes?"),
+            vec!["pc-1"],
+            "{:?}",
+            fake.written()
+        );
         let rows: Vec<_> = log_rows(&fake.store).split_off(before);
         assert!(
             rows.iter().all(|(kind, _, _)| kind != "Held"),
@@ -1953,14 +2677,19 @@ mod tests {
     async fn a_failed_schedule_send_rolls_back_to_what_was_there_and_still_names_the_terminal() {
         let mut hybrid = ctx_rule_saying("au-both", "stand-up notes?", 1);
         hybrid.graph.timer = Some(TimerStep {
-            mode: TimerMode::DailyAt { minute_of_day: 9 * 60, days: 0b0001_1111 },
+            mode: TimerMode::DailyAt {
+                minute_of_day: 9 * 60,
+                days: 0b0001_1111,
+            },
         });
         let (engine, fake, host) = wire_targets_bypassing_the_enable_gate(
             vec![hybrid],
             &[("tm-1", "pc-1")],
             &[("au-both", &["tm-1"])],
         );
-        engine.runtime.set_arm("au-both", "tm-1", ArmState::Fired { at_ms: 5 });
+        engine
+            .runtime
+            .set_arm("au-both", "tm-1", ArmState::Fired { at_ms: 5 });
         // `wire`'s own reload may have written §7's suppression row already, depending on the
         // runner's zone — see `a_schedule_rule_reads_nothing_sends_nothing_and_logs_nothing`. The
         // rows this test is about are the ones the tick adds.
@@ -1971,7 +2700,11 @@ mod tests {
         fake.close("tm-1");
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
-        assert!(fake.written().is_empty(), "{:?} reached a closed terminal", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "{:?} reached a closed terminal",
+            fake.written()
+        );
         assert_eq!(
             engine.runtime.arm_state("au-both", "tm-1"),
             ArmState::Fired { at_ms: 5 },
@@ -1981,7 +2714,9 @@ mod tests {
         assert_eq!(rows.len(), 1, "exactly one row: {rows:?}");
         assert_eq!(rows[0].0, "Failed", "{rows:?}");
         assert!(
-            rows[0].1.contains("the terminal closed before the message was sent"),
+            rows[0]
+                .1
+                .contains("the terminal closed before the message was sent"),
             "{rows:?}"
         );
         assert_eq!(
@@ -2039,7 +2774,10 @@ mod tests {
     async fn a_schedule_rule_that_also_has_a_monitor_reads_nothing_and_fires_on_the_clock() {
         let mut hybrid = ctx_rule_saying("au-both", "stand-up notes?", 1);
         hybrid.graph.timer = Some(TimerStep {
-            mode: TimerMode::DailyAt { minute_of_day: 9 * 60, days: 0b0001_1111 },
+            mode: TimerMode::DailyAt {
+                minute_of_day: 9 * 60,
+                days: 0b0001_1111,
+            },
         });
         let (engine, fake, host) = wire_targets_bypassing_the_enable_gate(
             vec![hybrid, ctx_rule_saying("au-read", "a reader", 2)],
@@ -2060,7 +2798,11 @@ mod tests {
             "the monitor crossed on a rule the clock has not reached: {:?}",
             fake.written()
         );
-        assert_eq!(fake.tailed(), vec!["pc-4"], "and the control read a window to prove it could");
+        assert_eq!(
+            fake.tailed(),
+            vec!["pc-4"],
+            "and the control read a window to prove it could"
+        );
 
         engine.runtime.mark_dirty("pc-1");
         engine.runtime.mark_dirty("pc-4");
@@ -2092,8 +2834,8 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = r"FAILED (\d+)".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "awk '{print $1}'".into();
-            g.action.substitute = false;
+            g.action_mut().message = "awk '{print $1}'".into();
+            g.action_mut().substitute = false;
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2103,7 +2845,9 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
         assert!(
-            fake.written().iter().any(|w| w.contains("awk '{print $1}'")),
+            fake.written()
+                .iter()
+                .any(|w| w.contains("awk '{print $1}'")),
             "the literal message was never typed: {:?}",
             fake.written()
         );
@@ -2123,8 +2867,8 @@ mod tests {
         let (engine, fake, host) = rig_with_rule_bypassing_the_enable_gate(|g| {
             g.parse_mut().find = r"FAILED (\d+)".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "Fix $3".into();
-            g.action.substitute = true;
+            g.action_mut().message = "Fix $3".into();
+            g.action_mut().substitute = true;
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2133,13 +2877,20 @@ mod tests {
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
-        assert!(fake.written().is_empty(), "nothing may be typed: {:?}", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "nothing may be typed: {:?}",
+            fake.written()
+        );
         let log = log_details(&fake.store);
         assert!(
             log.iter().any(|(_, detail)| detail.contains("$3")),
             "the failure row must name the token, got: {log:?}"
         );
-        assert!(log.iter().any(|(kind, _)| kind == "Failed"), "and it must be a Failed row: {log:?}");
+        assert!(
+            log.iter().any(|(kind, _)| kind == "Failed"),
+            "and it must be a Failed row: {log:?}"
+        );
     }
 
     // =============================================================================================
@@ -2162,8 +2913,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2179,7 +2932,11 @@ mod tests {
 
         evaluate_tick(&engine, &host, 0, 20_000).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
-        assert!(fake.written().is_empty(), "still holding at 19s: {:?}", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "still holding at 19s: {:?}",
+            fake.written()
+        );
 
         evaluate_tick(&engine, &host, 0, 31_001).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -2204,8 +2961,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2244,7 +3003,12 @@ mod tests {
         // `due_at_ms` is the moment it may go, not the moment after.
         evaluate_tick(&engine, &host, 0, 31_000).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
-        assert_eq!(times_sent(&fake, "resume"), 1, "exactly one message: {:?}", fake.written());
+        assert_eq!(
+            times_sent(&fake, "resume"),
+            1,
+            "exactly one message: {:?}",
+            fake.written()
+        );
         assert_eq!(
             engine.runtime.parked_at("au-1", "tm-1"),
             None,
@@ -2264,8 +3028,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2313,8 +3079,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 300_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 300_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2323,7 +3091,11 @@ mod tests {
         // The crossing parks a send due at 301_000 (five minutes out).
         evaluator_step(&engine, &host, 0, None, 1_000).await;
         tokio::time::sleep(Duration::from_millis(500)).await;
-        assert_eq!(engine.runtime.parked_at("au-1", "tm-1"), Some(301_000), "premise: it is parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-1", "tm-1"),
+            Some(301_000),
+            "premise: it is parked"
+        );
 
         // A resume that drops nothing: over `RESUME_GAP_MS`, and the send is not yet even due.
         let quiet = fake.states.load(std::sync::atomic::Ordering::Relaxed);
@@ -2364,8 +3136,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 300_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 300_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2385,7 +3159,11 @@ mod tests {
             Some(301_000),
             "a resume dropped a send that was not yet stale"
         );
-        assert!(fake.written().is_empty(), "the send is not due yet: {:?}", fake.written());
+        assert!(
+            fake.written().is_empty(),
+            "the send is not due yet: {:?}",
+            fake.written()
+        );
 
         // An ordinary tick, once the wait is genuinely over, must still deliver it.
         evaluator_step(&engine, &host, 0, Some(120_000), 301_001).await;
@@ -2409,8 +3187,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2459,15 +3239,20 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = r"API error (\d+)".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume after $1".into();
-            g.action.substitute = true;
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume after $1".into();
+            g.action_mut().substitute = true;
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
         fake.say("pc-1", "API error 529");
         evaluate_tick(&engine, &host, 0, 1_000).await;
-        assert!(fake.written().is_empty(), "the premise: the crossing parked rather than sending");
+        assert!(
+            fake.written().is_empty(),
+            "the premise: the crossing parked rather than sending"
+        );
 
         // Half a minute of build output later, nothing of the match is left anywhere.
         fake.say("pc-1", "all clear\n");
@@ -2505,8 +3290,10 @@ mod tests {
             let (engine, fake, host) = rig_with_rule(|g| {
                 g.parse_mut().find = "API error".into();
                 g.cond_mut().finds = Finds::Event;
-                g.action.message = "resume".into();
-                g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+                g.action_mut().message = "resume".into();
+                g.timer = Some(TimerStep {
+                    mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+                });
             });
             engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
             engine.runtime.mark_dirty("pc-1");
@@ -2522,7 +3309,10 @@ mod tests {
             if restarted {
                 // A spawn re-indexing a LIVE leaf, which is all `IdentityIndex::index` does. Not a
                 // `forget_terminal`, because that is the path this hazard is NOT on.
-                fake.leaves.lock().unwrap().insert("tm-1".into(), "pc-2".into());
+                fake.leaves
+                    .lock()
+                    .unwrap()
+                    .insert("tm-1".into(), "pc-2".into());
             }
 
             evaluate_tick(&engine, &host, 0, 31_001).await;
@@ -2567,8 +3357,10 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
@@ -2577,11 +3369,18 @@ mod tests {
         evaluate_tick(&engine, &host, 0, 1_000).await;
         // Guard against the vacuous version: a test that never parked anything would trivially type
         // nothing and stay green forever.
-        assert_eq!(engine.runtime.parked_at("au-1", "tm-1"), Some(31_000), "the premise: it parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-1", "tm-1"),
+            Some(31_000),
+            "the premise: it parked"
+        );
 
         fake.store.set_enabled_checked("au-1", false).unwrap();
         engine.reload(&fake.store, 2_000).unwrap();
-        assert!(!engine.is_live("au-1"), "the premise: disabling drops it from the live set");
+        assert!(
+            !engine.is_live("au-1"),
+            "the premise: disabling drops it from the live set"
+        );
 
         evaluate_tick(&engine, &host, 0, 31_001).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -2599,19 +3398,31 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
         fake.say("pc-1", "API error");
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
-        assert_eq!(engine.runtime.parked_at("au-1", "tm-1"), Some(31_000), "the premise: it parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-1", "tm-1"),
+            Some(31_000),
+            "the premise: it parked"
+        );
 
-        assert!(fake.store.delete_rule("au-1").unwrap(), "the premise: the rule existed to delete");
+        assert!(
+            fake.store.delete_rule("au-1").unwrap(),
+            "the premise: the rule existed to delete"
+        );
         engine.reload(&fake.store, 2_000).unwrap();
-        assert!(!engine.is_live("au-1"), "the premise: a deleted rule is not live");
+        assert!(
+            !engine.is_live("au-1"),
+            "the premise: a deleted rule is not live"
+        );
 
         evaluate_tick(&engine, &host, 0, 31_001).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -2630,18 +3441,27 @@ mod tests {
         let (engine, fake, host) = rig_with_rule(|g| {
             g.parse_mut().find = "API error".into();
             g.cond_mut().finds = Finds::Event;
-            g.action.message = "resume".into();
-            g.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+            g.action_mut().message = "resume".into();
+            g.timer = Some(TimerStep {
+                mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+            });
         });
         engine.runtime.set_arm("au-1", "tm-1", ArmState::armed());
         engine.runtime.mark_dirty("pc-1");
         fake.say("pc-1", "API error");
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
-        assert_eq!(engine.runtime.parked_at("au-1", "tm-1"), Some(31_000), "the premise: it parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-1", "tm-1"),
+            Some(31_000),
+            "the premise: it parked"
+        );
 
-        let mut edited =
-            fake.store.get_rule("au-1").unwrap().expect("the rule must still be in the store");
+        let mut edited = fake
+            .store
+            .get_rule("au-1")
+            .unwrap()
+            .expect("the rule must still be in the store");
         edited.updated_at = 2_000;
         fake.store.save_rule(&edited).unwrap();
         engine.reload(&fake.store, 2_000).unwrap();
@@ -2654,7 +3474,9 @@ mod tests {
         // `TARGETING_TICK_MS` — that tick does not run in this harness. Re-establishing it here is
         // NOT the thing under test; skipping it would let the walk skip "tm-1" for a reason that has
         // nothing to do with §6.1, and the test would pass vacuously for the wrong reason.
-        engine.runtime.set_watched("au-1", ["tm-1".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-1", ["tm-1".to_string()].into());
 
         evaluate_tick(&engine, &host, 0, 31_001).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
@@ -2676,10 +3498,14 @@ mod tests {
         once.runs_once = true;
         once.graph.parse_mut().find = "API error".into();
         once.graph.cond_mut().finds = Finds::Event;
-        once.graph.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+        once.graph.timer = Some(TimerStep {
+            mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+        });
         let (engine, fake, host) = wire(vec![once]);
         open_second_terminal(&fake);
-        engine.runtime.set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
         for tm in ["tm-1", "tm-2"] {
             engine.runtime.set_arm("au-once", tm, ArmState::armed());
         }
@@ -2691,7 +3517,11 @@ mod tests {
         engine.runtime.mark_dirty("pc-2");
         evaluate_tick(&engine, &host, 0, 1_250).await;
         assert_eq!(engine.runtime.parked_at("au-once", "tm-1"), Some(31_000));
-        assert_eq!(engine.runtime.parked_at("au-once", "tm-2"), Some(31_250), "both parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-once", "tm-2"),
+            Some(31_250),
+            "both parked"
+        );
 
         evaluate_tick(&engine, &host, 0, 31_250).await;
         tokio::time::sleep(Duration::from_millis(4_000)).await;
@@ -2727,10 +3557,14 @@ mod tests {
         once.runs_once = true;
         once.graph.parse_mut().find = "API error".into();
         once.graph.cond_mut().finds = Finds::Event;
-        once.graph.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
+        once.graph.timer = Some(TimerStep {
+            mode: TimerMode::AfterMatch { delay_ms: 30_000 },
+        });
         let (engine, fake, host) = wire(vec![once]);
         open_second_terminal(&fake);
-        engine.runtime.set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
         for tm in ["tm-1", "tm-2"] {
             engine.runtime.set_arm("au-once", tm, ArmState::armed());
         }
@@ -2742,14 +3576,27 @@ mod tests {
         engine.runtime.mark_dirty("pc-2");
         evaluate_tick(&engine, &host, 0, 1_250).await;
         assert_eq!(engine.runtime.parked_at("au-once", "tm-1"), Some(31_000));
-        assert_eq!(engine.runtime.parked_at("au-once", "tm-2"), Some(31_250), "premise: both parked");
+        assert_eq!(
+            engine.runtime.parked_at("au-once", "tm-2"),
+            Some(31_250),
+            "premise: both parked"
+        );
 
         evaluate_tick(&engine, &host, 0, 31_250).await;
         tokio::time::sleep(Duration::from_millis(4_000)).await;
 
         let sent = sent_to(&fake, "once only");
-        assert_eq!(sent.len(), 1, "premise: R6 still lets exactly one through: {:?}", fake.written());
-        let loser = if sent[0] == "pc-1" { "second" } else { "codex · core" };
+        assert_eq!(
+            sent.len(),
+            1,
+            "premise: R6 still lets exactly one through: {:?}",
+            fake.written()
+        );
+        let loser = if sent[0] == "pc-1" {
+            "second"
+        } else {
+            "codex · core"
+        };
 
         let dropped: Vec<_> = log_rows(&fake.store)
             .into_iter()
@@ -2782,14 +3629,19 @@ mod tests {
     #[tokio::test(start_paused = true)]
     async fn a_dormant_terminal_produces_no_evaluation_and_no_log_line() {
         let (engine, fake, host) = wired();
-        engine.runtime.set_arm("au-1", "tm-1", ArmState::Fired { at_ms: 5 });
+        engine
+            .runtime
+            .set_arm("au-1", "tm-1", ArmState::Fired { at_ms: 5 });
         engine.runtime.mark_dirty("pc-1");
         // Watched, but the leaf resolves to nothing: session restore has not re-registered it.
         fake.close("tm-1");
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
 
-        assert_eq!(engine.runtime.arm_state("au-1", "tm-1"), ArmState::Fired { at_ms: 5 });
+        assert_eq!(
+            engine.runtime.arm_state("au-1", "tm-1"),
+            ArmState::Fired { at_ms: 5 }
+        );
         assert_eq!(engine.runtime.last_eval("au-1", "tm-1"), None);
         assert!(log_kinds(&fake.store).is_empty());
     }
@@ -2804,7 +3656,11 @@ mod tests {
         engine.runtime.settle_until("tm-1", 5_000);
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
-        assert_eq!(engine.runtime.last_eval("au-1", "tm-1"), None, "settling means untouched");
+        assert_eq!(
+            engine.runtime.last_eval("au-1", "tm-1"),
+            None,
+            "settling means untouched"
+        );
 
         // And once the window closes it evaluates normally again.
         evaluate_tick(&engine, &host, 0, 5_001).await;
@@ -2830,9 +3686,15 @@ mod tests {
             .into_iter()
             .find(|l| l.rule.id == rule_id)
             .expect("the rule must be live for a send to have been decided");
-        engine.runtime.set_arm(rule_id, "tm-1", ArmState::Fired { at_ms });
+        engine
+            .runtime
+            .set_arm(rule_id, "tm-1", ArmState::Fired { at_ms });
         PendingSend {
-            pair: Pair { rule, tm: "tm-1".into(), pc: "pc-1".into() },
+            pair: Pair {
+                rule,
+                tm: "tm-1".into(),
+                pc: "pc-1".into(),
+            },
             prev,
             label: host.label_for("tm-1"),
             at_ms,
@@ -2881,7 +3743,12 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
         let writes = fake.written();
-        assert_eq!(writes.len(), 6, "two sends of three writes each: {:?}", writes);
+        assert_eq!(
+            writes.len(),
+            6,
+            "two sends of three writes each: {:?}",
+            writes
+        );
         assert_eq!(
             paste_positions(&writes),
             vec![0, 3],
@@ -2894,11 +3761,20 @@ mod tests {
         for i in [0usize, 3] {
             let alpha = writes[i].contains("alpha speaking");
             let bravo = writes[i].contains("bravo speaking");
-            assert_ne!(alpha, bravo, "one paste carried both messages: {:?}", writes);
+            assert_ne!(
+                alpha, bravo,
+                "one paste carried both messages: {:?}",
+                writes
+            );
             carried.push(if alpha { "alpha" } else { "bravo" });
         }
         carried.sort_unstable();
-        assert_eq!(carried, vec!["alpha", "bravo"], "both rules must have sent: {:?}", writes);
+        assert_eq!(
+            carried,
+            vec!["alpha", "bravo"],
+            "both rules must have sent: {:?}",
+            writes
+        );
     }
 
     /// A send that cannot take the terminal's queue within [`SEND_QUEUE_TIMEOUT_MS`] gives up: one
@@ -2915,9 +3791,12 @@ mod tests {
         let _held = lock.lock().await;
 
         let send = pending(&engine, &host, "au-1", ArmState::re_armed(), 1_000);
-        run_send(engine.clone(), host.clone(), send).await;
+        run_crossing(engine.clone(), host.clone(), send).await;
 
-        assert!(fake.written().is_empty(), "a send that never got the queue must type nothing");
+        assert!(
+            fake.written().is_empty(),
+            "a send that never got the queue must type nothing"
+        );
         assert_eq!(
             engine.runtime.arm_state("au-1", "tm-1"),
             ArmState::re_armed(),
@@ -2926,8 +3805,16 @@ mod tests {
         let rows = log_details(&fake.store);
         assert_eq!(rows.len(), 1, "exactly one row: {:?}", rows);
         assert_eq!(rows[0].0, "Failed");
-        assert!(rows[0].1.contains("another rule was still sending"), "{:?}", rows);
-        assert_eq!(engine.runtime.fire_record("au-1", "tm-1"), None, "a failed send never fired");
+        assert!(
+            rows[0].1.contains("another rule was still sending"),
+            "{:?}",
+            rows
+        );
+        assert_eq!(
+            engine.runtime.fire_record("au-1", "tm-1"),
+            None,
+            "a failed send never fired"
+        );
     }
 
     // =============================================================================================
@@ -2966,7 +3853,7 @@ mod tests {
             let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
             break_it(&fake);
 
-            run_send(engine.clone(), host.clone(), send).await;
+            run_crossing(engine.clone(), host.clone(), send).await;
             tokio::time::sleep(Duration::from_millis(1_500)).await;
 
             assert_eq!(
@@ -2976,7 +3863,12 @@ mod tests {
                 what,
                 fake.written()
             );
-            assert_eq!(engine.runtime.arm_state("au-1", "tm-1"), ArmState::armed(), "{}", what);
+            assert_eq!(
+                engine.runtime.arm_state("au-1", "tm-1"),
+                ArmState::armed(),
+                "{}",
+                what
+            );
             let rows = log_details(&fake.store);
             assert_eq!(rows.len(), 1, "{}: exactly one row, got {:?}", what, rows);
             assert_eq!(rows[0].0, "Failed", "{}: {:?}", what, rows);
@@ -3016,8 +3908,15 @@ mod tests {
         bad.graph.parse_mut().find = r"ctx:(\d+%".into();
         let (engine, fake, host) = wire(vec![bad]);
 
-        assert_eq!(log_kinds(&fake.store), vec!["Failed".to_string()], "one row, written at load");
-        assert!(engine.snapshot_live().is_empty(), "and the rule is not running");
+        assert_eq!(
+            log_kinds(&fake.store),
+            vec!["Failed".to_string()],
+            "one row, written at load"
+        );
+        assert!(
+            engine.snapshot_live().is_empty(),
+            "and the rule is not running"
+        );
 
         fake.say("pc-1", "ctx:63%\n");
         let mut cursor = 0;
@@ -3026,8 +3925,15 @@ mod tests {
             cursor = evaluate_tick(&engine, &host, cursor, t * 1_000).await;
         }
 
-        assert_eq!(log_kinds(&fake.store), vec!["Failed".to_string()], "a tick wrote a second row");
-        assert!(fake.written().is_empty(), "and an uncompilable rule must never send");
+        assert_eq!(
+            log_kinds(&fake.store),
+            vec!["Failed".to_string()],
+            "a tick wrote a second row"
+        );
+        assert!(
+            fake.written().is_empty(),
+            "and an uncompilable rule must never send"
+        );
     }
 
     // =============================================================================================
@@ -3042,9 +3948,12 @@ mod tests {
             let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
             engine.stop();
 
-            run_send(engine.clone(), host.clone(), send).await;
+            run_crossing(engine.clone(), host.clone(), send).await;
 
-            assert!(fake.written().is_empty(), "a send that started after the quit must type nothing");
+            assert!(
+                fake.written().is_empty(),
+                "a send that started after the quit must type nothing"
+            );
             assert_eq!(
                 engine.runtime.arm_state("au-1", "tm-1"),
                 ArmState::armed(),
@@ -3056,7 +3965,11 @@ mod tests {
             // the arm state is restored, the crossing is still armed, and it fires on the next launch.
             // A row here would be the only trace of a non-event, in a 200-row log §3.3 reserves for
             // decisions a user can act on.
-            assert!(log_kinds(&fake.store).is_empty(), "{:?}", log_details(&fake.store));
+            assert!(
+                log_kinds(&fake.store).is_empty(),
+                "{:?}",
+                log_details(&fake.store)
+            );
         }
 
         // Already typing: the flag is set during the paste-to-submit gap and the submit still goes
@@ -3064,10 +3977,14 @@ mod tests {
         {
             let (engine, fake, host) = wired();
             let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
-            let task = tokio::spawn(run_send(engine.clone(), host.clone(), send));
+            let task = tokio::spawn(run_crossing(engine.clone(), host.clone(), send));
 
             tokio::time::sleep(Duration::from_millis(100)).await;
-            assert_eq!(fake.written().len(), 1, "the paste must be out and the gap running");
+            assert_eq!(
+                fake.written().len(),
+                1,
+                "the paste must be out and the gap running"
+            );
             engine.stop();
             tokio::time::sleep(Duration::from_millis(1_000)).await;
             assert!(task.is_finished(), "the send must not park on the flag");
@@ -3104,8 +4021,16 @@ mod tests {
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
-        assert_eq!(fake.written().len(), 3, "the crossing must send: {:?}", fake.written());
-        assert_eq!(engine.runtime.echoes_for("tm-1", 1_000), vec!["HANDOFF now".to_string()]);
+        assert_eq!(
+            fake.written().len(),
+            3,
+            "the crossing must send: {:?}",
+            fake.written()
+        );
+        assert_eq!(
+            engine.runtime.echoes_for("tm-1", 1_000),
+            vec!["HANDOFF now".to_string()]
+        );
 
         // The real line has scrolled off. All that is left is what this rule typed.
         fake.say("pc-1", "HANDOFF now\n");
@@ -3213,7 +4138,10 @@ mod tests {
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
-        assert!(!engine.is_live("au-once"), "§7.8: completion is an in-memory event FIRST");
+        assert!(
+            !engine.is_live("au-once"),
+            "§7.8: completion is an in-memory event FIRST"
+        );
         assert_eq!(
             engine.runtime.arm_state("au-once", "tm-1"),
             ArmState::Unseen,
@@ -3246,7 +4174,11 @@ mod tests {
             tokio::time::sleep(Duration::from_millis(2_000)).await;
         }
 
-        assert_eq!(times_sent(&fake, "once only"), 1, "a runs-once rule fired twice in one session");
+        assert_eq!(
+            times_sent(&fake, "once only"),
+            1,
+            "a runs-once rule fired twice in one session"
+        );
         assert_eq!(
             times_sent(&fake, "every time"),
             2,
@@ -3256,16 +4188,27 @@ mod tests {
         // (b) The next launch: a fresh engine loads the same store and must not run it at all.
         let next = Arc::new(AutomationEngine::new(0));
         next.reload(&fake.store, 6_000).unwrap();
-        assert!(!next.is_live("au-once"), "the reload filter is the second line of defence");
-        assert!(next.is_live("au-many"), "and only the completed rule is filtered");
+        assert!(
+            !next.is_live("au-once"),
+            "the reload filter is the second line of defence"
+        );
+        assert!(
+            next.is_live("au-many"),
+            "and only the completed rule is filtered"
+        );
 
-        next.runtime.set_watched("au-once", ["tm-1".to_string()].into());
+        next.runtime
+            .set_watched("au-once", ["tm-1".to_string()].into());
         next.runtime.set_arm("au-once", "tm-1", ArmState::armed());
         fake.say("pc-1", "ctx:77%\n");
         next.runtime.mark_dirty("pc-1");
         evaluate_tick(&next, &host, 0, 7_000).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
-        assert_eq!(times_sent(&fake, "once only"), 1, "a completed rule ran after a reload");
+        assert_eq!(
+            times_sent(&fake, "once only"),
+            1,
+            "a completed rule ran after a reload"
+        );
     }
 
     /// **The completion nobody was told about.**
@@ -3293,14 +4236,24 @@ mod tests {
             engine.runtime.set_arm(id, "tm-1", ArmState::armed());
         }
 
-        fake.say("pc-1", "ctx:63%
-");
+        fake.say(
+            "pc-1", "ctx:63%
+",
+        );
         engine.runtime.mark_dirty("pc-1");
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
 
-        assert_eq!(times_sent(&fake, "once only"), 1, "the runs-once rule never fired");
-        assert_eq!(times_sent(&fake, "every time"), 1, "the control never fired");
+        assert_eq!(
+            times_sent(&fake, "once only"),
+            1,
+            "the runs-once rule never fired"
+        );
+        assert_eq!(
+            times_sent(&fake, "every time"),
+            1,
+            "the control never fired"
+        );
         assert_eq!(
             fake.announced(),
             vec!["au-once".to_string()],
@@ -3345,7 +4298,11 @@ mod tests {
             !engine.is_live("au-once"),
             "a failed stamp took the in-memory retirement with it, so the rule can fire again now"
         );
-        assert_eq!(fake.announced(), vec!["au-once".to_string()], "the windows were not told");
+        assert_eq!(
+            fake.announced(),
+            vec!["au-once".to_string()],
+            "the windows were not told"
+        );
         let log = log_details(&fake.store);
         assert!(
             log.iter().any(|(kind, detail)| kind == "Failed"
@@ -3379,7 +4336,10 @@ mod tests {
             // exactly that window.
             evaluate_tick(&engine, &host, 0, 1_000).await;
             if restarted {
-                fake.leaves.lock().unwrap().insert("tm-1".into(), "pc-2".into());
+                fake.leaves
+                    .lock()
+                    .unwrap()
+                    .insert("tm-1".into(), "pc-2".into());
             }
             tokio::time::sleep(Duration::from_millis(2_000)).await;
 
@@ -3409,17 +4369,30 @@ mod tests {
 
         // Before any tick, and inside the grace window, nothing is reported missing — §4.5: at t=0 the
         // live set is empty and session restore has not run.
-        assert!(!is_missing(&engine, "au-1", "tm-gone"), "reported before the grace elapsed");
+        assert!(
+            !is_missing(&engine, "au-1", "tm-gone"),
+            "reported before the grace elapsed"
+        );
         targeting_tick(&engine, &host, 1_000);
-        assert!(!is_missing(&engine, "au-1", "tm-gone"), "the grace window did not hold");
+        assert!(
+            !is_missing(&engine, "au-1", "tm-gone"),
+            "the grace window did not hold"
+        );
 
         // Past the grace, the pinned id is not in the roster and is reported — through the payload
         // first paint actually calls, not through the tick's return value.
         targeting_tick(&engine, &host, 120_000);
-        assert!(is_missing(&engine, "au-1", "tm-gone"), "first paint cannot see what the tick found");
+        assert!(
+            is_missing(&engine, "au-1", "tm-gone"),
+            "first paint cannot see what the tick found"
+        );
 
         // And it is retracted the moment the terminal comes back, rather than latching.
-        _fake.leaves.lock().unwrap().insert("tm-gone".into(), "pc-9".into());
+        _fake
+            .leaves
+            .lock()
+            .unwrap()
+            .insert("tm-gone".into(), "pc-9".into());
         _fake.roster.lock().unwrap().push(RosterRow {
             terminal_id: Some("tm-gone".into()),
             process_id: "pc-9".into(),
@@ -3431,7 +4404,10 @@ mod tests {
             command_lines: Vec::new(),
         });
         targeting_tick(&engine, &host, 130_000);
-        assert!(!is_missing(&engine, "au-1", "tm-gone"), "dormant, never dead — it came back");
+        assert!(
+            !is_missing(&engine, "au-1", "tm-gone"),
+            "dormant, never dead — it came back"
+        );
     }
 
     fn is_missing(engine: &Arc<AutomationEngine>, rule_id: &str, tm: &str) -> bool {
@@ -3469,7 +4445,11 @@ mod tests {
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(2_000)).await;
-        assert_eq!(times_sent(&fake, "bravo speaking"), 1, "the premise: B has fired once");
+        assert_eq!(
+            times_sent(&fake, "bravo speaking"),
+            1,
+            "the premise: B has fired once"
+        );
 
         // The user flips A off. Nothing about B changed.
         let mut off = ctx_rule_saying("au-a", "alpha speaking", 1);
@@ -3499,7 +4479,10 @@ mod tests {
             "the decision must be `held`, and be visible as one: {:?}",
             log_kinds(&fake.store)
         );
-        assert!(!engine.is_live("au-a"), "the premise: A really did leave the live set");
+        assert!(
+            !engine.is_live("au-a"),
+            "the premise: A really did leave the live set"
+        );
     }
 
     // =============================================================================================
@@ -3516,7 +4499,7 @@ mod tests {
         // The decision has been made and carried; NOW the terminal goes away completely.
         fake.close("tm-1");
 
-        run_send(engine.clone(), host.clone(), send).await;
+        run_crossing(engine.clone(), host.clone(), send).await;
 
         let rows = log_rows(&fake.store);
         assert_eq!(rows.len(), 1, "{:?}", rows);
@@ -3534,7 +4517,7 @@ mod tests {
         let (engine, fake, host) = wired();
         let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
 
-        run_send(engine.clone(), host.clone(), send).await;
+        run_crossing(engine.clone(), host.clone(), send).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
         let rows = log_rows(&fake.store);
@@ -3552,7 +4535,9 @@ mod tests {
     async fn a_row_that_sent_nothing_carries_the_name_as_well() {
         let (engine, fake, host) = wired();
         // Fired and still true: `held`, which is a Decision-class row and so not verbose-gated.
-        engine.runtime.set_arm("au-1", "tm-1", ArmState::Fired { at_ms: 500 });
+        engine
+            .runtime
+            .set_arm("au-1", "tm-1", ArmState::Fired { at_ms: 500 });
         fake.say("pc-1", "ctx:63%\n");
         engine.runtime.mark_dirty("pc-1");
 
@@ -3560,7 +4545,11 @@ mod tests {
 
         let rows = log_rows(&fake.store);
         assert_eq!(rows.len(), 1, "{:?}", rows);
-        assert_ne!(rows[0].0, "Sent", "the premise: nothing was sent — {:?}", rows);
+        assert_ne!(
+            rows[0].0, "Sent",
+            "the premise: nothing was sent — {:?}",
+            rows
+        );
         assert_eq!(rows[0].2.as_deref(), Some("codex · core"), "{:?}", rows);
         assert!(fake.written().is_empty());
     }
@@ -3585,12 +4574,17 @@ mod tests {
             cwd: None,
             command_lines: Vec::new(),
         });
-        fake.leaves.lock().unwrap().insert("tm-2".into(), "pc-2".into());
+        fake.leaves
+            .lock()
+            .unwrap()
+            .insert("tm-2".into(), "pc-2".into());
 
         // Both terminals match `All terminals`, and both have fired.
         targeting_tick(&engine, &host, 1_000);
         for tm in ["tm-1", "tm-2"] {
-            engine.runtime.set_arm("au-1", tm, ArmState::Fired { at_ms: 500 });
+            engine
+                .runtime
+                .set_arm("au-1", tm, ArmState::Fired { at_ms: 500 });
             engine.runtime.set_last_eval("au-1", tm, 500);
             engine.runtime.record_fire("au-1", tm, 500);
         }
@@ -3599,7 +4593,11 @@ mod tests {
         fake.close("tm-2");
         targeting_tick(&engine, &host, 3_000);
 
-        assert_eq!(engine.runtime.arm_state("au-1", "tm-2"), ArmState::Unseen, "the stale key survived");
+        assert_eq!(
+            engine.runtime.arm_state("au-1", "tm-2"),
+            ArmState::Unseen,
+            "the stale key survived"
+        );
         assert_eq!(engine.runtime.last_eval("au-1", "tm-2"), None);
         assert_eq!(
             engine.runtime.fire_record("au-1", "tm-2"),
@@ -3635,7 +4633,7 @@ mod tests {
                 engine.stop();
             }
 
-            run_send(engine.clone(), host.clone(), send).await;
+            run_crossing(engine.clone(), host.clone(), send).await;
 
             assert_eq!(
                 engine.runtime.arm_state("au-1", "tm-1"),
@@ -3659,7 +4657,7 @@ mod tests {
                 *fake.write_err.lock().unwrap() = Some("no writer".into());
             }
 
-            run_send(engine.clone(), host.clone(), send).await;
+            run_crossing(engine.clone(), host.clone(), send).await;
 
             assert_eq!(
                 engine.runtime.arm_state("au-1", "tm-1"),
@@ -3685,23 +4683,34 @@ mod tests {
         // mutation to `tokio::spawn` survived it. `ends_with` can only be satisfied by the characters
         // immediately before the call — by the call itself.
         let engine = strip_comments(include_str!("../automation_engine.rs"));
-        let start = engine.find("pub fn spawn<R: tauri::Runtime>").expect("spawn must exist");
+        let start = engine
+            .find("pub fn spawn<R: tauri::Runtime>")
+            .expect("spawn must exist");
         let body = &engine[start..];
         let outer = body.find("spawn({").expect("it must spawn something");
         assert!(
             body[..outer].ends_with("tauri::async_runtime::"),
             "the OUTER spawn runs from `.setup()`, where no runtime is entered, so it must go \
              through Tauri's wrapper; the call reads `{}spawn({{`",
-            body[..outer].rsplit('\n').next().unwrap_or_default().trim_start()
+            body[..outer]
+                .rsplit('\n')
+                .next()
+                .unwrap_or_default()
+                .trim_start()
         );
 
         let lib = strip_comments(include_str!("../lib.rs"));
-        let setup_start =
-            lib.find("spawn_history_flush_task(state.clone());").expect("the setup site");
+        let setup_start = lib
+            .find("spawn_history_flush_task(state.clone());")
+            .expect("the setup site");
         // Windowed by LINES rather than bytes: `strip_comments` drops comment-only lines and leaves
         // trailing ones, so a multi-byte character landing inside a fixed byte window panics with a
         // slice error instead of failing with this test's own message.
-        let setup = lib[setup_start..].lines().take(12).collect::<Vec<_>>().join("\n");
+        let setup = lib[setup_start..]
+            .lines()
+            .take(12)
+            .collect::<Vec<_>>()
+            .join("\n");
         let setup = setup.as_str();
         assert!(
             !setup.contains("tokio::spawn"),
@@ -3729,7 +4738,9 @@ mod tests {
         once.runs_once = true;
         let (engine, fake, host) = wire(vec![once]);
         open_second_terminal(&fake);
-        engine.runtime.set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
         for tm in ["tm-1", "tm-2"] {
             engine.runtime.set_arm("au-once", tm, ArmState::armed());
         }
@@ -3748,7 +4759,10 @@ mod tests {
             fake.written()
         );
         assert_eq!(
-            log_rows(&fake.store).iter().filter(|(k, _, _)| k == "Sent").count(),
+            log_rows(&fake.store)
+                .iter()
+                .filter(|(k, _, _)| k == "Sent")
+                .count(),
             1,
             "and it logged every one of them"
         );
@@ -3771,7 +4785,9 @@ mod tests {
         once.runs_once = true;
         let (engine, fake, host) = wire(vec![once]);
         open_second_terminal(&fake);
-        engine.runtime.set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-once", ["tm-1".to_string(), "tm-2".to_string()].into());
         for tm in ["tm-1", "tm-2"] {
             engine.runtime.set_arm("au-once", tm, ArmState::armed());
         }
@@ -3797,7 +4813,10 @@ mod tests {
             fake.written()
         );
         assert_eq!(
-            log_rows(&fake.store).iter().filter(|(k, _, _)| k == "Sent").count(),
+            log_rows(&fake.store)
+                .iter()
+                .filter(|(k, _, _)| k == "Sent")
+                .count(),
             1,
             "and logged both of them"
         );
@@ -3815,7 +4834,9 @@ mod tests {
         let mut once = ctx_rule_saying("au-once", "once only", 1);
         once.runs_once = true;
         let (engine, fake, host) = wire(vec![once]);
-        engine.runtime.set_watched("au-once", ["tm-1".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-once", ["tm-1".to_string()].into());
         engine.runtime.set_arm("au-once", "tm-1", ArmState::armed());
         *fake.write_err.lock().unwrap() = Some("no writer".into());
 
@@ -3828,10 +4849,16 @@ mod tests {
         // so `written()` shows the attempt either way. A `Sent` row is only written after `deliver`
         // returns `Ok`.
         let sent_rows = |f: &FakeHost| {
-            log_rows(&f.store).iter().filter(|(k, _, _)| k == "Sent").count()
+            log_rows(&f.store)
+                .iter()
+                .filter(|(k, _, _)| k == "Sent")
+                .count()
         };
         assert_eq!(sent_rows(&fake), 0, "the premise: the write was refused");
-        assert!(engine.is_live("au-once"), "a failed send must not complete the rule");
+        assert!(
+            engine.is_live("au-once"),
+            "a failed send must not complete the rule"
+        );
         assert_eq!(
             engine.runtime.arm_state("au-once", "tm-1"),
             ArmState::armed(),
@@ -3875,12 +4902,18 @@ mod tests {
             "the premise: nothing was evaluated, so no arm state moved"
         );
         assert!(log_rows(&fake.store).is_empty(), "§4.5: no read, no row");
-        assert!(engine.runtime.is_dirty("pc-1"), "the tick spent a signal no pair could read");
+        assert!(
+            engine.runtime.is_dirty("pc-1"),
+            "the tick spent a signal no pair could read"
+        );
 
         // The paired positive, so this is not satisfied by never clearing anything.
         fake.say("pc-1", "ctx:18%\n");
         evaluate_tick(&engine, &host, 0, 2_000).await;
-        assert!(!engine.runtime.is_dirty("pc-1"), "an ordinary read must still spend the signal");
+        assert!(
+            !engine.runtime.is_dirty("pc-1"),
+            "an ordinary read must still spend the signal"
+        );
     }
 
     /// The other half of B-2's fix, and it had no oracle: **only a `runs_once` rule is deduped.**
@@ -3894,7 +4927,9 @@ mod tests {
     async fn a_repeating_rule_still_sends_to_every_terminal_it_watches() {
         let (engine, fake, host) = wire(vec![ctx_rule_saying("au-many", "every one", 1)]);
         open_second_terminal(&fake);
-        engine.runtime.set_watched("au-many", ["tm-1".to_string(), "tm-2".to_string()].into());
+        engine
+            .runtime
+            .set_watched("au-many", ["tm-1".to_string(), "tm-2".to_string()].into());
         for tm in ["tm-1", "tm-2"] {
             engine.runtime.set_arm("au-many", tm, ArmState::armed());
         }
@@ -3930,7 +4965,10 @@ mod tests {
         // The first pass adopts tm-1 and says so. Drained here, so what is asserted below is the
         // SECOND change and not this one.
         tokio::time::sleep(Duration::from_millis(TARGETING_TICK_MS / 2)).await;
-        assert!(engine.take_state_emit(1_000), "the first pass must announce the rule's first leaf");
+        assert!(
+            engine.take_state_emit(1_000),
+            "the first pass must announce the rule's first leaf"
+        );
         assert!(engine.runtime.watches("au-1", "tm-1"));
 
         // A second terminal opens. `All terminals` + `follow_new` adopts it.
@@ -3938,7 +4976,10 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(TARGETING_TICK_MS * 2)).await;
         engine.stop();
 
-        assert!(engine.runtime.watches("au-1", "tm-2"), "the premise: it was adopted");
+        assert!(
+            engine.runtime.watches("au-1", "tm-2"),
+            "the premise: it was adopted"
+        );
         assert!(
             engine.take_state_emit(10_000),
             "the watch set grew and no window was told; only `missing` was being diffed"
@@ -3952,7 +4993,10 @@ mod tests {
         let (engine, _fake, host) = wired();
         let quiet = tokio::spawn(run_targeting(engine.clone(), host.clone()));
         tokio::time::sleep(Duration::from_millis(TARGETING_TICK_MS / 2)).await;
-        assert!(engine.take_state_emit(1_000), "the premise: the first pass adopted tm-1");
+        assert!(
+            engine.take_state_emit(1_000),
+            "the premise: the first pass adopted tm-1"
+        );
         tokio::time::sleep(Duration::from_millis(TARGETING_TICK_MS * 3)).await;
         engine.stop();
         assert!(
@@ -3993,7 +5037,11 @@ mod tests {
             Some(1_000),
             "the premise: A was due and ran"
         );
-        assert_eq!(engine.runtime.last_eval("au-b", "tm-1"), Some(900), "and B did not");
+        assert_eq!(
+            engine.runtime.last_eval("au-b", "tm-1"),
+            Some(900),
+            "and B did not"
+        );
         assert!(
             engine.runtime.is_dirty("pc-1"),
             "A spent the flag on B's behalf, and B never sees this output again"
@@ -4004,7 +5052,10 @@ mod tests {
         // for A instead; that is the rule working, not a second bug.)
         evaluate_tick(&engine, &host, 0, 1_300).await;
         assert_eq!(engine.runtime.last_eval("au-b", "tm-1"), Some(1_300));
-        assert!(!engine.runtime.is_dirty("pc-1"), "and now the flag is genuinely spent");
+        assert!(
+            !engine.runtime.is_dirty("pc-1"),
+            "and now the flag is genuinely spent"
+        );
     }
 
     /// **M-5: `touch_target` had no production caller**, so `automation_targets` held rows only for
@@ -4023,8 +5074,14 @@ mod tests {
         targeting_tick(&engine, &host, 1_000);
 
         let rows = fake.store.targets_for("au-1").unwrap();
-        let row = rows.iter().find(|r| r.0 == "tm-1").unwrap_or_else(|| panic!("{:?}", rows));
-        assert_eq!(row.1, "matched", "a criterion match is never pinned, so nothing else writes it");
+        let row = rows
+            .iter()
+            .find(|r| r.0 == "tm-1")
+            .unwrap_or_else(|| panic!("{:?}", rows));
+        assert_eq!(
+            row.1, "matched",
+            "a criterion match is never pinned, so nothing else writes it"
+        );
         assert_eq!(row.2.as_deref(), Some("codex · core"));
         assert_eq!(row.3.as_deref(), Some("D:/sources/work"));
     }
@@ -4037,12 +5094,22 @@ mod tests {
     #[test]
     fn the_exit_arm_stops_the_engine_before_anything_slow() {
         let lib = strip_comments(include_str!("../lib.rs"));
-        let start = lib.find("if let RunEvent::Exit = event {").expect("the Exit arm");
+        let start = lib
+            .find("if let RunEvent::Exit = event {")
+            .expect("the Exit arm");
         let arm = lib[start..].lines().take(25).collect::<Vec<_>>().join("\n");
         let arm = arm.as_str();
-        let stop = arm.find("automations.stop()").expect("Exit must stop the engine");
-        for slow in ["flush_all_history(", "shutdown_mcp_server(", "shutdown_fabric("] {
-            let at = arm.find(slow).unwrap_or_else(|| panic!("{} left the Exit arm", slow));
+        let stop = arm
+            .find("automations.stop()")
+            .expect("Exit must stop the engine");
+        for slow in [
+            "flush_all_history(",
+            "shutdown_mcp_server(",
+            "shutdown_fabric(",
+        ] {
+            let at = arm
+                .find(slow)
+                .unwrap_or_else(|| panic!("{} left the Exit arm", slow));
             assert!(stop < at, "the loops keep deciding across {}", slow);
         }
     }
@@ -4078,7 +5145,10 @@ mod tests {
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
 
-        assert!(lookups.load(Ordering::Relaxed) >= 2, "the premise: both pairs resolved their leaf");
+        assert!(
+            lookups.load(Ordering::Relaxed) >= 2,
+            "the premise: both pairs resolved their leaf"
+        );
         assert!(
             engine.runtime.is_dirty("pc-1"),
             "the tick cleared a signal that arrived after it had finished reading"
@@ -4098,8 +5168,13 @@ mod tests {
 
         targeting_tick(&engine, &host, 1_000);
 
-        let ids: Vec<String> =
-            fake.store.targets_for("au-1").unwrap().into_iter().map(|r| r.0).collect();
+        let ids: Vec<String> = fake
+            .store
+            .targets_for("au-1")
+            .unwrap()
+            .into_iter()
+            .map(|r| r.0)
+            .collect();
         assert_eq!(
             ids,
             vec!["tm-1".to_string()],
@@ -4107,6 +5182,36 @@ mod tests {
         );
     }
 
+    /// An exception is a criterion the roster must answer too. The fake deliberately exposes its
+    /// process-derived command lines only when `roster` was asked for `CommandContains`, mirroring
+    /// the production scan gate. Reverting the exclusion half of the criteria collection leaves the
+    /// line empty, so `tm-1` incorrectly remains watched and this test fails.
+    #[test]
+    fn targeting_requests_and_uses_command_lines_for_an_exclusion_criterion() {
+        let mut rule = ctx_rule("au-exclude-claude");
+        rule.criterion = Criterion::AllTerminals;
+        rule.exclude_criterion = Some(Criterion::CommandContains);
+        rule.exclude_criterion_value = "claude".into();
+        let (engine, fake, host) = wire(vec![rule]);
+        fake.scanned_command_lines
+            .lock()
+            .unwrap()
+            .insert("tm-1".into(), vec!["pwsh.exe -Command claude".into()]);
+
+        let pass = targeting_tick(&engine, &host, 1_000);
+
+        assert!(
+            fake.last_roster_criteria()
+                .contains(&Criterion::CommandContains),
+            "the exclusion must request the process scan that populates command lines"
+        );
+        assert_eq!(
+            pass.watched.get("au-exclude-claude"),
+            Some(&HashSet::new()),
+            "the populated command line must make the exception remove tm-1"
+        );
+    }
+
     /// **`if report.emit` written as `if false` changed nothing any test could see**, in either of
     /// the two places it was written. The decision now has one implementation, out where a test can
     /// reach it.
@@ -4135,14 +5240,24 @@ mod tests {
         // inside the very loop that fills `skipped` — so this row pins THIS FUNCTION's contract, that
         // `emit` is the gate and the list is not consulted when it is closed, rather than a state the
         // engine reaches.
-        assert_eq!(refusals_to_announce(&ReloadReport { emit: false, ..refused }), None);
+        assert_eq!(
+            refusals_to_announce(&ReloadReport {
+                emit: false,
+                ..refused
+            }),
+            None
+        );
 
         // An empty `skipped` with `emit` set: also unreachable from `reload`, and also this function's
         // contract — an empty list is not `None`, because a caller with a reason to emit and no ids to
         // name still emits. *(This comment used to justify the row with "a row written by something
         // else in the same load"; `reload` has no such mechanism.)*
         assert_eq!(
-            refusals_to_announce(&ReloadReport { live: 3, skipped: vec![], emit: true }),
+            refusals_to_announce(&ReloadReport {
+                live: 3,
+                skipped: vec![],
+                emit: true
+            }),
             Some(vec![])
         );
     }
@@ -4162,8 +5277,10 @@ mod tests {
             engine.runtime.set_arm(id, "tm-1", ArmState::armed());
         }
         engine.runtime.set_last_eval("au-timer", "tm-1", 900);
-        fake.say("pc-1", "ctx:18%
-");
+        fake.say(
+            "pc-1", "ctx:18%
+",
+        );
         engine.runtime.mark_dirty("pc-1");
 
         evaluate_tick(&engine, &host, 0, 1_000).await;
@@ -4207,7 +5324,11 @@ mod tests {
         evaluate_tick(&engine, &host, 0, 1_000).await;
         tokio::time::sleep(Duration::from_millis(4_000)).await;
 
-        assert_eq!(times_sent(&fake, "first message"), 1, "the premise: both sent");
+        assert_eq!(
+            times_sent(&fake, "first message"),
+            1,
+            "the premise: both sent"
+        );
         assert_eq!(times_sent(&fake, "second message"), 1);
 
         // The first send lands one paste-to-submit gap after the decision; the second waits for the
@@ -4215,10 +5336,14 @@ mod tests {
         let gap = crate::automation::send::PASTE_SUBMIT_GAP_MS as i64;
         let second_landed = 1_000 + gap * 2;
         assert!(
-            engine.runtime.is_settling("tm-1", second_landed + ECHO_SETTLE_MS - 1),
+            engine
+                .runtime
+                .is_settling("tm-1", second_landed + ECHO_SETTLE_MS - 1),
             "the queued send's window had already been running for the length of its wait"
         );
-        assert!(!engine.runtime.is_settling("tm-1", second_landed + ECHO_SETTLE_MS + 1));
+        assert!(!engine
+            .runtime
+            .is_settling("tm-1", second_landed + ECHO_SETTLE_MS + 1));
     }
 
     /// A second live terminal, with ids that share no substring with the first (§7.4).
@@ -4260,7 +5385,10 @@ mod tests {
             tokio::time::sleep(Duration::from_millis(2_000)).await;
         }
 
-        let kinds: Vec<String> = log_rows(&fake.store).into_iter().map(|(k, _, _)| k).collect();
+        let kinds: Vec<String> = log_rows(&fake.store)
+            .into_iter()
+            .map(|(k, _, _)| k)
+            .collect();
         assert_eq!(
             kinds.iter().filter(|k| *k == "Sent").count(),
             1,
@@ -4274,7 +5402,12 @@ mod tests {
              again, and they evict the `sent` row: {:?}",
             kinds
         );
-        assert_eq!(kinds.len(), 2, "and nothing else was written at all: {:?}", kinds);
+        assert_eq!(
+            kinds.len(),
+            2,
+            "and nothing else was written at all: {:?}",
+            kinds
+        );
     }
 
     /// **H-2: `automation:state` is an ARM TRANSITION event** (§7.2), and it fired only from a
@@ -4306,18 +5439,29 @@ mod tests {
         fake.say("pc-1", "ctx:18%\n");
         engine.runtime.mark_dirty("pc-1");
         evaluate_tick(&engine, &host, 0, 2_500).await;
-        assert_eq!(fake.states.load(Ordering::Relaxed), 2, "a refused emit was dropped, not deferred");
+        assert_eq!(
+            fake.states.load(Ordering::Relaxed),
+            2,
+            "a refused emit was dropped, not deferred"
+        );
 
         // Out of the settle window: Fired + false is a real transition, so it is announced.
         engine.runtime.mark_dirty("pc-1");
         evaluate_tick(&engine, &host, 0, 9_000).await;
-        assert_eq!(engine.runtime.arm_state("au-1", "tm-1"), ArmState::re_armed());
+        assert_eq!(
+            engine.runtime.arm_state("au-1", "tm-1"),
+            ArmState::re_armed()
+        );
         assert_eq!(fake.states.load(Ordering::Relaxed), 3);
 
         // And still 18%: no transition at all now, so nothing to say however long we wait.
         engine.runtime.mark_dirty("pc-1");
         evaluate_tick(&engine, &host, 0, 20_000).await;
-        assert_eq!(fake.states.load(Ordering::Relaxed), 3, "a repeat is not a transition");
+        assert_eq!(
+            fake.states.load(Ordering::Relaxed),
+            3,
+            "a repeat is not a transition"
+        );
     }
 
     /// **H-6: the rule can go away during the queue wait too.** The wait is up to ten seconds; a user
@@ -4329,7 +5473,7 @@ mod tests {
         let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
         engine.complete_rule("au-1");
 
-        run_send(engine.clone(), host.clone(), send).await;
+        run_crossing(engine.clone(), host.clone(), send).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
         assert!(fake.written().is_empty(), "{:?}", fake.written());
@@ -4348,12 +5492,15 @@ mod tests {
         let (engine, fake, host) = wired();
         let send = pending(&engine, &host, "au-1", ArmState::armed(), 1_000);
 
-        run_send(engine.clone(), host.clone(), send).await;
+        run_crossing(engine.clone(), host.clone(), send).await;
         tokio::time::sleep(Duration::from_millis(1_500)).await;
 
         let ids = fake.written_to();
         assert!(!ids.is_empty(), "the premise: something was written");
-        assert!(ids.iter().all(|id| id == "pc-1"), "a write was addressed by leaf id: {:?}", ids);
+        assert!(
+            ids.iter().all(|id| id == "pc-1"),
+            "a write was addressed by leaf id: {:?}",
+            ids
+        );
     }
-
 }
diff --git a/src-tauri/src/automation_engine/test_host.rs b/src-tauri/src/automation_engine/test_host.rs
index 55e164ae..aa701e4f 100644
--- a/src-tauri/src/automation_engine/test_host.rs
+++ b/src-tauri/src/automation_engine/test_host.rs
@@ -31,6 +31,11 @@ pub(crate) struct FakeHost {
     pub(crate) store: Arc<AutomationStore>,
     pub(crate) leaves: Mutex<HashMap<String, String>>,
     pub(crate) roster: Mutex<Vec<RosterRow>>,
+    /// Process-derived command lines, made visible only when the caller asks the roster for the
+    /// criterion that requires a process scan. This gives targeting tests the same request/populate
+    /// seam as `AppState::roster` without taking a real machine snapshot.
+    pub(crate) scanned_command_lines: Mutex<HashMap<String, Vec<String>>>,
+    pub(crate) roster_criteria: Mutex<Vec<Vec<Criterion>>>,
     pub(crate) text: Mutex<HashMap<String, String>>,
     /// Every `tail` the engine asked for, in order — **the screen reads, recorded**.
     ///
@@ -67,6 +72,8 @@ impl FakeHost {
             store: Arc::new(AutomationStore::new_in_memory()),
             leaves: Mutex::new(HashMap::new()),
             roster: Mutex::new(Vec::new()),
+            scanned_command_lines: Mutex::new(HashMap::new()),
+            roster_criteria: Mutex::new(Vec::new()),
             text: Mutex::new(HashMap::new()),
             tails: Mutex::new(Vec::new()),
             writes: Mutex::new(Vec::new()),
@@ -136,6 +143,10 @@ impl FakeHost {
     pub(crate) fn announced(&self) -> Vec<String> {
         self.changed.lock().unwrap().iter().flatten().cloned().collect()
     }
+
+    pub(crate) fn last_roster_criteria(&self) -> Vec<Criterion> {
+        self.roster_criteria.lock().unwrap().last().cloned().unwrap_or_default()
+    }
 }
 
 impl EngineHost for FakeHost {
@@ -146,13 +157,27 @@ impl EngineHost for FakeHost {
         }
         self.leaves.lock().unwrap().get(tm).cloned()
     }
-    fn roster(&self, _criteria: &[Criterion]) -> Vec<RosterRow> {
-        self.roster.lock().unwrap().clone()
+    fn roster(&self, criteria: &[Criterion]) -> Vec<RosterRow> {
+        self.roster_criteria.lock().unwrap().push(criteria.to_vec());
+        let mut rows = self.roster.lock().unwrap().clone();
+        if criteria.contains(&Criterion::CommandContains) {
+            let scanned = self.scanned_command_lines.lock().unwrap();
+            for row in &mut rows {
+                if let Some(lines) = row
+                    .terminal_id
+                    .as_deref()
+                    .and_then(|terminal_id| scanned.get(terminal_id))
+                {
+                    row.command_lines = lines.clone();
+                }
+            }
+        }
+        rows
     }
     fn live_processes(&self) -> Vec<String> {
         self.leaves.lock().unwrap().values().cloned().collect()
     }
-    fn tail(&self, pc: &str, _depth: ReadDepth) -> Option<String> {
+    fn tail(&self, pc: &str, _depth: ReadDepth, _skip_typed_line: bool) -> Option<String> {
         // Recorded BEFORE the lookup, so a process with no text still counts as a read attempt —
         // §4.5's dormant terminal is a `None` here, and a path that reaches this port has read.
         self.tails.lock().unwrap().push(pc.to_string());
@@ -205,6 +230,9 @@ pub(crate) fn ctx_rule(id: &str) -> AutomationRule {
         criterion_value: String::new(),
         follow_new: true,
         target_ids: vec![],
+        excluded_ids: vec![],
+        exclude_criterion: None,
+        exclude_criterion_value: String::new(),
         completed_at: None,
         verbose_until: None,
         sort_order: 1,
@@ -212,7 +240,7 @@ pub(crate) fn ctx_rule(id: &str) -> AutomationRule {
         graph: AutomationGraph {
             layout: None,
             timer: None,
-            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0 }),
+            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0, skip_typed_line: false }),
             parse: Some(ParseStep {
                 preset: ParsePreset::Custom,
                 literal: None,
@@ -220,13 +248,14 @@ pub(crate) fn ctx_rule(id: &str) -> AutomationRule {
                 keep: Keep::Brackets,
             }),
             cond: Some(CondStep { finds: Finds::Reading, op: Some(CompareOp::Gt), threshold: Some(25.0), ..Default::default() }),
-            action: ActionStep {
+            action: Some(ActionStep {
                 message: "prepare to do context-hand-off".into(),
                 send_to: SendTo::Matched,
                 submit: true,
                 cli_type: "claude".into(),
                 substitute: false,
-            },
+            }),
+            webhook: None,
         },
         created_at: 1_000,
         updated_at: 1_000,
@@ -310,7 +339,7 @@ pub(crate) fn log_kinds(store: &AutomationStore) -> Vec<String> {
 /// the write log by their contents rather than by the order they happen to arrive in.
 pub(crate) fn ctx_rule_saying(id: &str, message: &str, sort_order: i64) -> AutomationRule {
     let mut rule = ctx_rule(id);
-    rule.graph.action.message = message.into();
+    rule.graph.action_mut().message = message.into();
     rule.sort_order = sort_order;
     rule
 }
@@ -331,7 +360,7 @@ pub(crate) fn schedule_only_rule(id: &str) -> AutomationRule {
     rule.graph.timer = Some(TimerStep {
         mode: TimerMode::DailyAt { minute_of_day: 9 * 60, days: 0b0001_1111 },
     });
-    rule.graph.action.message = "stand-up notes?".into();
+    rule.graph.action_mut().message = "stand-up notes?".into();
     rule
 }
 
diff --git a/src-tauri/src/automation_store.rs b/src-tauri/src/automation_store.rs
index a963ca2f..b463932c 100644
--- a/src-tauri/src/automation_store.rs
+++ b/src-tauri/src/automation_store.rs
@@ -28,9 +28,9 @@ use rusqlite::Connection;
 /// silently reinterpreting a graph we do not understand is how a rule starts typing the wrong thing
 /// into a terminal. `reload` logs exactly one entry per skipped rule per load. Plan §7.3.
 ///
-/// `2` as of plan 032 §3.2 (task 27): a rule is stamped `2` only when [`schema_version_for`] finds it
-/// actually uses a v2 feature, never merely because this build can write one.
-pub const SUPPORTED_SCHEMA_VERSION: i64 = 2;
+/// `3` as of the webhook milestone: a rule is stamped only for the newest feature it actually uses,
+/// never merely because this build can write one.
+pub const SUPPORTED_SCHEMA_VERSION: i64 = 3;
 
 // ---------------------------------------------------------------------------------------------
 // The DTO. These serde names are THE AUTHORITY for the whole feature (plan §7.7): the renderer's
@@ -270,6 +270,28 @@ pub struct MonitorStep {
     pub cadence: Cadence,
     /// Only meaningful for `Cadence::Timer`.
     pub every_ms: i64,
+    /// Drop the logical line the cursor sits on, so a command still being TYPED cannot fire the
+    /// rule. Reported: a rule matching `deploy` fired the moment the word appeared under the
+    /// user's fingers, before Enter — the screen genuinely contains the text either way, and the
+    /// engine has no other signal that separates an echoed keystroke from output.
+    ///
+    /// **Opt-in, and it has to be.** The cursor's line is real output for plenty of terminals — a
+    /// full-screen TUI parks the cursor wherever it likes, and a rule reading the row it happens
+    /// to rest on would silently lose its match. Off is what every rule written before this field
+    /// did, and what every rule that never ticks the box keeps doing.
+    ///
+    /// **Only that one logical line**, never "the cursor's line and everything below": the
+    /// reported use is an agentic CLI whose status line sits UNDER the input box, which is the
+    /// text the rule is watching for. Dropping the tail of the screen would take the value with
+    /// the noise.
+    #[serde(default, skip_serializing_if = "is_off")]
+    pub skip_typed_line: bool,
+}
+
+/// Off is the default, so it is not written — a rule that never ticks the box keeps a blob an
+/// older build decodes byte for byte. Same reason as `is_default_join`.
+fn is_off(flag: &bool) -> bool {
+    !*flag
 }
 
 /// Step 2 — "Read a value". Plan §2.2b, §6.4b.
@@ -358,6 +380,29 @@ pub struct ActionStep {
     pub substitute: bool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum WebhookProvider { Discord, Teams, Slack, Custom }
+
+/// An optional destination outside the terminal. Its URL is persisted and sent over IPC in the
+/// clear by design, but is never displayed, logged, exported, or put in an error.
+#[derive(Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebhookStep {
+    pub provider: WebhookProvider,
+    pub url: String,
+    pub body: String,
+    #[serde(default)]
+    pub substitute: bool,
+}
+
+impl std::fmt::Debug for WebhookStep {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WebhookStep").field("provider", &self.provider).field("url", &"<redacted>")
+            .field("body", &self.body).field("substitute", &self.substitute).finish()
+    }
+}
+
 fn default_send_to() -> SendTo {
     SendTo::Matched
 }
@@ -468,7 +513,10 @@ pub struct AutomationGraph {
     /// shape and this attribute becomes load-bearing rather than decorative.
     #[serde(default)]
     pub timer: Option<TimerStep>,
-    pub action: ActionStep,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<ActionStep>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub webhook: Option<WebhookStep>,
     /// Where the editor's four cards sit on its canvas.
     ///
     /// **View state, deliberately inside the rule's blob.** The plan originally kept the layout out
@@ -503,14 +551,22 @@ pub struct AutomationGraph {
 /// opposite (monotonic, "once v2 always v2") is the more obvious thing to write by accident, which
 /// is why `schema_version_is_stamped_from_what_the_rule_actually_uses` pins the non-sticky case
 /// explicitly rather than leaving it to be implied by the others (task 27 ruling R4).
-pub fn schema_version_for(graph: &AutomationGraph) -> i64 {
+pub fn schema_version_for(rule: &AutomationRule) -> i64 {
+    let graph = &rule.graph;
     let uses_a_v2_feature = graph.timer.is_some()
         || graph.monitor.is_none()
         || graph.parse.is_none()
         || graph.cond.is_none()
         || graph.cond.as_ref().is_some_and(|c| !c.clauses.is_empty())
-        || graph.action.substitute;
-    if uses_a_v2_feature {
+        || graph.action.as_ref().is_some_and(|action| action.substitute);
+    let uses_a_v3_feature = graph.webhook.is_some() || graph.action.is_none()
+        || !rule.excluded_ids.is_empty() || rule.exclude_criterion.is_some()
+        || !rule.exclude_criterion_value.is_empty()
+        // Ships in this same milestone. An older build decodes the rule fine and ignores the key,
+        // which is the case the stamp exists to signal: it would read the line the user is still
+        // typing and fire on it — the exact behaviour the box was ticked to stop.
+        || graph.monitor.as_ref().is_some_and(|monitor| monitor.skip_typed_line);
+    if uses_a_v3_feature { 3 } else if uses_a_v2_feature {
         2
     } else {
         1
@@ -542,6 +598,10 @@ impl AutomationGraph {
         self.cond.as_mut().expect("this fixture's rule has a cond step")
     }
     #[track_caller]
+    pub fn action_mut(&mut self) -> &mut ActionStep {
+        self.action.as_mut().expect("this fixture's rule has an action step")
+    }
+    #[track_caller]
     pub fn monitor_ref(&self) -> &MonitorStep {
         self.monitor.as_ref().expect("this fixture's rule has a monitor step")
     }
@@ -592,6 +652,12 @@ pub struct AutomationRule {
     /// a rule saved across a restart would point at nothing. Plan §7.4.
     #[serde(default)]
     pub target_ids: Vec<String>,
+    #[serde(default)]
+    pub excluded_ids: Vec<String>,
+    #[serde(default)]
+    pub exclude_criterion: Option<Criterion>,
+    #[serde(default)]
+    pub exclude_criterion_value: String,
 
     // --- runtime flags that outlive a process ---
     /// Set when a `runs_once` rule fires. `None` means it can still run.
@@ -744,8 +810,12 @@ const LAST_SEEN_THROTTLE_MS: i64 = 5 * 60 * 1000;
 const PINNED_TARGET_IDS_SQL: &str = "SELECT terminal_id FROM automation_targets \
      WHERE rule_id = ?1 AND source = 'pinned' ORDER BY added_at, terminal_id";
 
+const EXCLUDED_TARGET_IDS_SQL: &str = "SELECT terminal_id FROM automation_exclusions \
+     WHERE rule_id = ?1 ORDER BY added_at, terminal_id";
+
 const RULE_COLUMNS: &str ="id, name, enabled, runs_once, target_mode, criterion, criterion_value, \
-     follow_new, completed_at, verbose_until, sort_order, schema_version, graph, created_at, updated_at";
+     exclude_criterion, exclude_criterion_value, follow_new, completed_at, verbose_until, sort_order, \
+     schema_version, graph, created_at, updated_at";
 
 /// Whether an entry is subject to the verbose gate. **Derived from `kind` inside `append`, never
 /// passed in.** A caller that could label its own entry could gate a `Sent` behind the verbose flag
@@ -812,6 +882,8 @@ struct RawRule {
     target_mode: String,
     criterion: String,
     criterion_value: String,
+    exclude_criterion: Option<String>,
+    exclude_criterion_value: Option<String>,
     follow_new: bool,
     completed_at: Option<i64>,
     verbose_until: Option<i64>,
@@ -831,24 +903,29 @@ fn read_rule_row(r: &rusqlite::Row<'_>) -> rusqlite::Result<RawRule> {
         target_mode: r.get(4)?,
         criterion: r.get(5)?,
         criterion_value: r.get(6)?,
-        follow_new: r.get(7)?,
-        completed_at: r.get(8)?,
-        verbose_until: r.get(9)?,
-        sort_order: r.get(10)?,
-        schema_version: r.get(11)?,
-        graph: r.get(12)?,
-        created_at: r.get(13)?,
-        updated_at: r.get(14)?,
+        exclude_criterion: r.get(7)?,
+        exclude_criterion_value: r.get(8)?,
+        follow_new: r.get(9)?,
+        completed_at: r.get(10)?,
+        verbose_until: r.get(11)?,
+        sort_order: r.get(12)?,
+        schema_version: r.get(13)?,
+        graph: r.get(14)?,
+        created_at: r.get(15)?,
+        updated_at: r.get(16)?,
     })
 }
 
 fn hydrate_rule(raw: RawRule) -> Result<AutomationRule, AutomationStoreError> {
     Ok(AutomationRule {
-        graph: serde_json::from_str(&raw.graph).map_err(|e| {
-            AutomationStoreError::Invalid(format!("rule {}: bad graph blob: {e}", raw.id))
-        })?,
+        // Serde can quote the malformed value in its error, and a graph contains the webhook URL.
+        // Keep the decode boundary opaque: list_rules turns this into a skipped-row reason and
+        // reload persists that reason to the activity log.
+        graph: serde_json::from_str(&raw.graph)
+            .map_err(|_| AutomationStoreError::Invalid(format!("rule {}: bad graph blob", raw.id)))?,
         target_mode: enum_from_db(&raw.target_mode)?,
         criterion: enum_from_db(&raw.criterion)?,
+        exclude_criterion: raw.exclude_criterion.as_deref().map(enum_from_db).transpose()?,
         id: raw.id,
         name: raw.name,
         enabled: raw.enabled,
@@ -856,6 +933,8 @@ fn hydrate_rule(raw: RawRule) -> Result<AutomationRule, AutomationStoreError> {
         criterion_value: raw.criterion_value,
         follow_new: raw.follow_new,
         target_ids: Vec::new(),
+        excluded_ids: Vec::new(),
+        exclude_criterion_value: raw.exclude_criterion_value.unwrap_or_default(),
         completed_at: raw.completed_at,
         verbose_until: raw.verbose_until,
         sort_order: raw.sort_order,
@@ -986,6 +1065,25 @@ impl AutomationStore {
         store
     }
 
+    /// Insert a graph which could only have arrived from an older or corrupt store.
+    ///
+    /// This bypasses serialisation deliberately: tests need the real decode path to see whether a
+    /// malformed value reaches a user-facing skipped-row reason.
+    #[cfg(test)]
+    pub(crate) fn insert_raw_graph_for_test(&self, id: &str, graph: &str) {
+        let guard = self.conn.lock().unwrap();
+        let conn = guard.as_ref().expect("in-memory store is connected");
+        conn.execute(
+            "INSERT INTO automation_rules
+               (id, name, enabled, runs_once, target_mode, criterion, criterion_value,
+                follow_new, completed_at, verbose_until, sort_order, schema_version,
+                graph, created_at, updated_at)
+             VALUES (?1, 'bad', 1, 0, 'rule', 'allTerminals', '', 1, NULL, NULL, 2, 1, ?2, 1000, 1000)",
+            rusqlite::params![id, graph],
+        )
+        .expect("insert raw graph");
+    }
+
     fn schema(conn: &Connection) -> rusqlite::Result<()> {
         conn.execute(
             "CREATE TABLE IF NOT EXISTS automation_rules (
@@ -996,6 +1094,8 @@ impl AutomationStore {
                 target_mode     TEXT NOT NULL,
                 criterion       TEXT NOT NULL,
                 criterion_value TEXT NOT NULL,
+                exclude_criterion TEXT,
+                exclude_criterion_value TEXT,
                 follow_new      INTEGER NOT NULL,
                 completed_at    INTEGER,
                 verbose_until   INTEGER,
@@ -1025,6 +1125,15 @@ impl AutomationStore {
             )",
             [],
         )?;
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS automation_exclusions (
+                rule_id     TEXT NOT NULL,
+                terminal_id TEXT NOT NULL,
+                added_at    INTEGER NOT NULL,
+                PRIMARY KEY (rule_id, terminal_id)
+            )",
+            [],
+        )?;
         // Ordered by `id`, never by `at`: two entries can share a millisecond (verbose mode writes
         // several terminals per tick) and the wall clock can move backwards after an NTP correction or
         // a resume, which this app already handles as an event. AUTOINCREMENT rather than a bare
@@ -1052,6 +1161,8 @@ impl AutomationStore {
         // build of this branch keeps its old `automation_targets` and every SELECT naming `folder`
         // fails against it. Plan §3.4.
         Self::ensure_column(conn, "automation_targets", "folder", "TEXT")?;
+        Self::ensure_column(conn, "automation_rules", "exclude_criterion", "TEXT")?;
+        Self::ensure_column(conn, "automation_rules", "exclude_criterion_value", "TEXT")?;
         Ok(())
     }
 
@@ -1113,6 +1224,19 @@ impl AutomationStore {
             }
         }
 
+        let mut exclusions: HashMap<String, Vec<String>> = HashMap::new();
+        {
+            let mut stmt = conn.prepare(
+                "SELECT rule_id, terminal_id FROM automation_exclusions ORDER BY added_at, terminal_id",
+            )?;
+            let rows =
+                stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?;
+            for row in rows {
+                let (rule_id, terminal_id) = row?;
+                exclusions.entry(rule_id).or_default().push(terminal_id);
+            }
+        }
+
         let mut stmt = conn.prepare(&format!(
             "SELECT {RULE_COLUMNS} FROM automation_rules ORDER BY sort_order, id"
         ))?;
@@ -1124,6 +1248,7 @@ impl AutomationStore {
             match hydrate_rule(raw) {
                 Ok(mut rule) => {
                     rule.target_ids = targets.remove(&rule.id).unwrap_or_default();
+                    rule.excluded_ids = exclusions.remove(&rule.id).unwrap_or_default();
                     out.push(rule);
                 }
                 // §3.3: a row this build cannot decode is ONE rule that does not run, never
@@ -1497,6 +1622,13 @@ impl AutomationStore {
                     ids.push(row?);
                 }
                 rule.target_ids = ids;
+                let mut stmt = conn.prepare(EXCLUDED_TARGET_IDS_SQL)?;
+                let rows = stmt.query_map([id], |r| r.get::<_, String>(0))?;
+                let mut ids = Vec::new();
+                for row in rows {
+                    ids.push(row?);
+                }
+                rule.excluded_ids = ids;
                 Ok(Some(rule))
             }
         }
@@ -1600,8 +1732,9 @@ impl AutomationStore {
             .map_err(|e| AutomationStoreError::Invalid(format!("graph is not serialisable: {e}")))?;
         let target_mode = enum_to_db(&rule.target_mode)?;
         let criterion = enum_to_db(&rule.criterion)?;
+        let exclude_criterion = rule.exclude_criterion.as_ref().map(enum_to_db).transpose()?;
         let schema_version = if rule.schema_version <= SUPPORTED_SCHEMA_VERSION {
-            schema_version_for(&rule.graph)
+            schema_version_for(rule)
         } else {
             rule.schema_version
         };
@@ -1614,9 +1747,10 @@ impl AutomationStore {
 
         tx.execute(
             "INSERT INTO automation_rules (
-                 id, name, enabled, runs_once, target_mode, criterion, criterion_value, follow_new,
-                 completed_at, verbose_until, sort_order, schema_version, graph, created_at, updated_at)
-             VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15)
+                 id, name, enabled, runs_once, target_mode, criterion, criterion_value,
+                 exclude_criterion, exclude_criterion_value, follow_new, completed_at, verbose_until,
+                 sort_order, schema_version, graph, created_at, updated_at)
+             VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15,?16,?17)
              ON CONFLICT(id) DO UPDATE SET
                  name            = excluded.name,
                  enabled         = excluded.enabled,
@@ -1624,6 +1758,8 @@ impl AutomationStore {
                  target_mode     = excluded.target_mode,
                  criterion       = excluded.criterion,
                  criterion_value = excluded.criterion_value,
+                 exclude_criterion = excluded.exclude_criterion,
+                 exclude_criterion_value = excluded.exclude_criterion_value,
                  follow_new      = excluded.follow_new,
                  completed_at    = excluded.completed_at,
                  verbose_until   = excluded.verbose_until,
@@ -1639,6 +1775,8 @@ impl AutomationStore {
                 target_mode,
                 criterion,
                 rule.criterion_value,
+                exclude_criterion,
+                rule.exclude_criterion_value,
                 rule.follow_new,
                 rule.completed_at,
                 rule.verbose_until,
@@ -1693,6 +1831,17 @@ impl AutomationStore {
                 rusqlite::params![rule.id, id],
             )?;
         }
+        tx.execute(
+            "DELETE FROM automation_exclusions WHERE rule_id = ?1",
+            [&rule.id],
+        )?;
+        for id in &rule.excluded_ids {
+            tx.execute(
+                "INSERT OR IGNORE INTO automation_exclusions (rule_id, terminal_id, added_at)
+                 VALUES (?1, ?2, ?3)",
+                rusqlite::params![rule.id, id, rule.updated_at],
+            )?;
+        }
         Ok(previous)
     }
 
@@ -1703,6 +1852,7 @@ impl AutomationStore {
             let conn = guard.as_mut().ok_or(AutomationStoreError::Disabled)?;
             let tx = conn.transaction()?;
             tx.execute("DELETE FROM automation_targets WHERE rule_id = ?1", [id])?;
+            tx.execute("DELETE FROM automation_exclusions WHERE rule_id = ?1", [id])?;
             tx.execute("DELETE FROM automation_log WHERE rule_id = ?1", [id])?;
             let n = tx.execute("DELETE FROM automation_rules WHERE id = ?1", [id])?;
             tx.commit()?;
@@ -2294,6 +2444,7 @@ mod tests {
                 read: ReadMode::NewOutput,
                 cadence: Cadence::OnOutput,
                 every_ms: 30_000,
+                skip_typed_line: false,
             }),
             parse: Some(ParseStep {
                 preset: ParsePreset::Percentage,
@@ -2307,13 +2458,14 @@ mod tests {
                 threshold: Some(25.0),
                 ..Default::default()
             }),
-            action: ActionStep {
+            action: Some(ActionStep {
                 message: "prepare to do context-hand-off".to_string(),
                 send_to: SendTo::Matched,
                 submit: true,
                 cli_type: "claude".to_string(),
                 substitute: false,
-            },
+            }),
+            webhook: None,
         }
     }
 
@@ -2330,6 +2482,9 @@ mod tests {
             // A PINNED rule with no targets is one the enable gate refuses, so a fixture that had
             // none was every store test arranging a row the product cannot produce.
             target_ids: vec!["tm-1".to_string()],
+            excluded_ids: vec![],
+            exclude_criterion: None,
+            exclude_criterion_value: String::new(),
             completed_at: None,
             verbose_until: None,
             sort_order: 1,
@@ -2340,20 +2495,69 @@ mod tests {
         }
     }
 
+    #[test]
+    fn exclusions_round_trip_through_save_and_list() {
+        let store = AutomationStore::new_in_memory();
+        let mut r = rule("au-x");
+        r.target_mode = TargetMode::Rule;
+        r.criterion = Criterion::CommandContains;
+        r.criterion_value = "claude".into();
+        r.excluded_ids = vec!["tm-b".into(), "tm-c".into()];
+        r.exclude_criterion = Some(Criterion::WorkingFolderUnder);
+        r.exclude_criterion_value = "~/scratch".into();
+        store.save_rule(&r).unwrap();
+
+        let back = store.list_rules().unwrap().into_iter().find(|x| x.id == "au-x").unwrap();
+        assert_eq!(back.excluded_ids, vec!["tm-b".to_string(), "tm-c".to_string()]);
+        assert_eq!(back.exclude_criterion, Some(Criterion::WorkingFolderUnder));
+        assert_eq!(back.exclude_criterion_value, "~/scratch");
+    }
+
+    /// A terminal can be BOTH a pick and an exclusion, and one must not erase the other. This is the
+    /// test that fails if exclusions are squeezed into `automation_targets.source`, whose primary key
+    /// (`:1024`) has no room for two memberships of one pair.
+    #[test]
+    fn a_terminal_can_be_both_pinned_and_excluded_without_either_erasing_the_other() {
+        let store = AutomationStore::new_in_memory();
+        let mut r = rule("au-x");
+        r.target_ids = vec!["tm-a".into(), "tm-b".into()];   // picks
+        r.excluded_ids = vec!["tm-b".into()];                // and tm-b is also excluded
+        store.save_rule(&r).unwrap();
+
+        let back = store.list_rules().unwrap().into_iter().find(|x| x.id == "au-x").unwrap();
+        assert_eq!(back.target_ids, vec!["tm-a".to_string(), "tm-b".to_string()]);
+        assert_eq!(back.excluded_ids, vec!["tm-b".to_string()]);
+    }
+
+    /// BOTH loaders, not just the bulk one. `read_rule_on` is the path get_rule, duplicate, enable and
+    /// every target mutation take; if only `list_rules` learns exclusions, a duplicate silently drops
+    /// them and a target edit writes the rule back without them.
+    #[test]
+    fn the_single_rule_loader_returns_exclusions_too() {
+        let store = AutomationStore::new_in_memory();
+        let mut r = rule("au-x");
+        r.excluded_ids = vec!["tm-b".into()];
+        store.save_rule(&r).unwrap();
+
+        let one = store.get_rule("au-x").unwrap().unwrap();
+        assert_eq!(one.excluded_ids, vec!["tm-b".to_string()], "get_rule must agree with list_rules");
+    }
+
+    /// Exclusions must survive a mutation that rewrites the rule for an unrelated reason.
+    #[test]
+    fn a_target_mutation_preserves_exclusions() {
+        let store = AutomationStore::new_in_memory();
+        let mut r = rule("au-x");
+        r.excluded_ids = vec!["tm-b".into()];
+        store.save_rule(&r).unwrap();
+        store.add_target_to_rule("au-x", "tm-z", 2_000).unwrap();
+        assert_eq!(store.get_rule("au-x").unwrap().unwrap().excluded_ids, vec!["tm-b".to_string()]);
+    }
+
     /// Insert a row whose `graph` column is arbitrary text, bypassing `save_rule`'s
     /// serialisation. There is no other way to author a row this build cannot decode.
     fn write_raw_graph(store: &AutomationStore, id: &str, graph: &str) {
-        let guard = store.conn.lock().unwrap();
-        let conn = guard.as_ref().unwrap();
-        conn.execute(
-            "INSERT INTO automation_rules
-               (id, name, enabled, runs_once, target_mode, criterion, criterion_value,
-                follow_new, completed_at, verbose_until, sort_order, schema_version,
-                graph, created_at, updated_at)
-             VALUES (?1, 'bad', 1, 0, 'rule', 'allTerminals', '', 1, NULL, NULL, 2, 1, ?2, 1000, 1000)",
-            rusqlite::params![id, graph],
-        )
-        .unwrap();
+        store.insert_raw_graph_for_test(id, graph);
     }
 
     fn rule_named(name: &str) -> AutomationRule {
@@ -2588,38 +2792,76 @@ mod tests {
 
     fn graph_with_substitute() -> AutomationGraph {
         let mut g = graph();
-        g.action.substitute = true;
+        g.action_mut().substitute = true;
         g
     }
 
+    fn graph_with_skip_typed_line() -> AutomationGraph {
+        let mut g = graph();
+        g.monitor_mut().skip_typed_line = true;
+        g
+    }
+
+    fn stamped(graph: AutomationGraph) -> i64 {
+        let mut rule = rule("au-stamp");
+        rule.graph = graph;
+        schema_version_for(&rule)
+    }
+
     /// One row per term of the predicate, plus the plain rule that must STAY v1. A single row would
     /// leave the other six silently wrong — `schema_version_for` folds seven conditions into one
     /// bool, and a table is the only shape that shows a wrong term rather than just a wrong result.
     #[test]
     fn schema_version_is_stamped_from_what_the_rule_actually_uses() {
         assert_eq!(
-            schema_version_for(&graph()),
+            stamped(graph()),
             1,
             "a plain four-step rule must still load on an older build"
         );
-        assert_eq!(schema_version_for(&graph_with_timer()), 2);
-        assert_eq!(schema_version_for(&graph_with_no_monitor()), 2);
-        assert_eq!(schema_version_for(&graph_with_no_parse()), 2);
-        assert_eq!(schema_version_for(&graph_with_no_cond()), 2);
-        assert_eq!(schema_version_for(&graph_with_one_clause()), 2);
-        assert_eq!(schema_version_for(&graph_with_substitute()), 2);
+        assert_eq!(stamped(graph_with_timer()), 2);
+        assert_eq!(stamped(graph_with_no_monitor()), 2);
+        assert_eq!(stamped(graph_with_no_parse()), 2);
+        assert_eq!(stamped(graph_with_no_cond()), 2);
+        assert_eq!(stamped(graph_with_one_clause()), 2);
+        assert_eq!(stamped(graph_with_substitute()), 2);
+        let mut webhook = graph();
+        webhook.webhook = Some(WebhookStep { provider: WebhookProvider::Discord, url: "https://example.invalid/hook".into(), body: "build failed".into(), substitute: false });
+        assert_eq!(stamped(webhook.clone()), 3);
+        webhook.webhook = None;
+        assert_eq!(stamped(webhook), 1, "removing the last webhook drops the stamp back");
+        let mut no_action = graph();
+        no_action.action = None;
+        assert_eq!(stamped(no_action), 3);
+        // Ships in the same milestone as the two above. An older build decodes such a rule
+        // perfectly and ignores the key — it reads the line the user is still typing and fires on
+        // it, which is precisely what ticking the box was meant to stop.
+        assert_eq!(stamped(graph_with_skip_typed_line()), 3);
 
         // R4: not sticky. Dropping the last clause must not leave the rule permanently v2 — the
         // opposite (monotonic) behaviour is the more obvious thing to write by accident.
         let mut g = graph_with_one_clause();
         g.cond.as_mut().unwrap().clauses.clear();
         assert_eq!(
-            schema_version_for(&g),
+            stamped(g),
             1,
             "dropping the last clause makes the rule v1-compatible again"
         );
     }
 
+    #[test]
+    fn a_rule_with_exclusions_is_stamped_v3_even_on_a_v1_graph() {
+        let mut excluded = rule("au-excluded");
+        excluded.schema_version = 1;
+        excluded.excluded_ids = vec!["tm-secret".into()];
+        assert_eq!(schema_version_for(&excluded), 3);
+        excluded.excluded_ids.clear();
+        assert_eq!(schema_version_for(&excluded), 1);
+        excluded.exclude_criterion_value = "scratch".into();
+        assert_eq!(schema_version_for(&excluded), 3);
+        excluded.exclude_criterion_value.clear();
+        assert_eq!(schema_version_for(&excluded), 1);
+    }
+
     /// §3.2's whole point: merely loading and re-saving an old rule must not brick it for a
     /// downgrade. The in-memory fold (§5.4, `fold_v1_clauses`) gives a v1 numeric rule one clause
     /// at LOAD, in the engine, on a copy that is never written back — so the row this test reads
@@ -2658,7 +2900,26 @@ mod tests {
         }"#;
         let decoded: AutomationGraph =
             serde_json::from_str(raw).expect("a graph missing only a newer optional field must still decode");
-        assert!(!decoded.action.substitute, "a rule from before this field existed must load with it off");
+        assert!(!decoded.action.as_ref().unwrap().substitute, "a rule from before this field existed must load with it off");
+    }
+
+    #[test]
+    fn a_webhook_only_rule_writes_no_action_key() {
+        let mut graph = graph();
+        graph.action = None;
+        graph.webhook = Some(WebhookStep { provider: WebhookProvider::Slack, url: "https://example.invalid/hook".into(), body: "build failed".into(), substitute: false });
+        assert!(!serde_json::to_string(&graph).unwrap().contains("\"action\""));
+    }
+
+    #[test]
+    fn a_graph_with_no_webhook_writes_no_webhook_key() {
+        assert!(!serde_json::to_string(&graph()).unwrap().contains("\"webhook\""));
+    }
+
+    #[test]
+    fn a_v1_rule_still_round_trips_byte_for_byte() {
+        let v1 = r#"{"monitor":{"read":"newOutput","cadence":"onOutput","everyMs":0},"parse":{"preset":"custom","literal":null,"find":"ctx:(\\d+)%","keep":"brackets"},"cond":{"kind":"number","op":"gt","threshold":25.0},"timer":null,"action":{"message":"prepare to do context-hand-off","sendTo":"matched","submit":true,"cliType":"default","substitute":false}}"#;
+        assert_eq!(serde_json::to_string(&serde_json::from_str::<AutomationGraph>(v1).unwrap()).unwrap(), v1);
     }
 
     // -- §10.14b ------------------------------------------------------------------------------
@@ -2977,7 +3238,7 @@ mod tests {
         let store = AutomationStore::new_in_memory();
         let mut bad = rule("au-1");
         bad.enabled = true;
-        bad.graph.action.message = String::new();
+        bad.graph.action_mut().message = String::new();
 
         assert!(store.save_rule_as_of(&bad, 1_000).is_err(), "an enabled rule with no message");
         assert!(store.get_rule("au-1").unwrap().is_none(), "and nothing was written");
@@ -3090,6 +3351,27 @@ mod tests {
         assert!(store.get_rule("au-2").unwrap().is_some());
     }
 
+    /// Reusing an id is the observable regression: without `DELETE FROM automation_exclusions`, a
+    /// newly saved rule silently inherits the deleted rule's exception rows.
+    #[test]
+    fn deleting_then_reusing_a_rule_id_does_not_restore_old_exclusions() {
+        let store = AutomationStore::new_in_memory();
+        let mut original = rule("au-x");
+        original.excluded_ids = vec!["tm-excluded-before-delete".into()];
+        store.save_rule(&original).unwrap();
+
+        assert!(store.delete_rule("au-x").unwrap());
+
+        let replacement = rule("au-x");
+        store.save_rule(&replacement).unwrap();
+        let saved = store.get_rule("au-x").unwrap().unwrap();
+        assert!(
+            saved.excluded_ids.is_empty(),
+            "the replacement must not inherit exclusions from the deleted rule: {:?}",
+            saved.excluded_ids
+        );
+    }
+
     #[test]
     fn mark_completed_stamps_the_rule_and_reports_a_missing_one() {
         let store = AutomationStore::new_in_memory();
@@ -3422,7 +3704,7 @@ mod tests {
         let mut rule = enableable("au-bad");
         rule.enabled = false;
         rule.target_ids.clear();
-        rule.graph.action.message = String::new();
+        rule.graph.action_mut().message = String::new();
         store.save_rule(&rule).unwrap();
 
         let refused = store.set_enabled_checked("au-bad", true);
@@ -3463,7 +3745,7 @@ mod tests {
         let mut empty = enableable("au-empty");
         empty.enabled = false;
         empty.target_ids.clear();
-        empty.graph.action.message = String::new();
+        empty.graph.action_mut().message = String::new();
         store.save_rule(&empty).unwrap();
 
         store.set_enabled_checked("au-empty", false).unwrap();
@@ -3484,7 +3766,7 @@ mod tests {
 
         let mut broken = enableable("au-1");
         broken.enabled = true;
-        broken.graph.action.message = String::new();
+        broken.graph.action_mut().message = String::new();
         let refused = store.save_rule(&broken);
         assert!(matches!(refused, Err(AutomationStoreError::Invalid(_))), "{:?}", refused);
         assert!(store.get_rule("au-1").unwrap().is_none(), "refused, and yet the row was written");
@@ -4108,6 +4390,46 @@ mod tests {
         );
     }
 
+    #[test]
+    fn malformed_webhook_values_never_escape_decode_or_save_errors() {
+        let secret = "https://hooks.example.invalid/credential-token";
+        let malformed = format!(
+            r#"{{"webhook":{{"provider":"{secret}","url":"{secret}","body":"done"}}}}"#
+        );
+
+        // This is the producer, not a hand-written error: serde really does quote the malformed
+        // provider value, which is why forwarding its Display would leak the URL.
+        let raw = serde_json::from_str::<AutomationGraph>(&malformed)
+            .expect_err("a URL is not a webhook provider")
+            .to_string();
+        assert!(raw.contains(secret), "premise: serde produced the secret: {raw}");
+
+        let store = AutomationStore::new_in_memory();
+        write_raw_graph(&store, "au-malformed", &malformed);
+        assert!(store.list_rules().unwrap().is_empty());
+        let skipped = store.take_skipped_rows();
+        assert_eq!(skipped.len(), 1);
+        assert!(!skipped[0].1.contains(secret), "skipped row leaked: {:?}", skipped[0]);
+        assert!(skipped[0].1.contains("bad graph blob"));
+
+        // Save errors also carry the store's Display through the command layer. Exercise the real
+        // enable/save validation with a well-typed, secret-bearing webhook rule rather than
+        // inventing an error text.
+        let mut invalid = rule("au-save");
+        invalid.graph.webhook = Some(WebhookStep {
+            provider: WebhookProvider::Custom,
+            url: secret.to_string(),
+            body: r#"{\"result\": ${value}}"#.to_string(),
+            substitute: true,
+        });
+        invalid.graph.parse.as_mut().expect("parse fixture").find = r"(?<value>\\w+)".to_string();
+        let error = store
+            .save_rule(&invalid)
+            .expect_err("post-substitution custom JSON is refused")
+            .to_string();
+        assert!(!error.contains(secret), "save error leaked: {error}");
+    }
+
     // -----------------------------------------------------------------------------------------
     // Plan 032 §5.2/§5.3 — `finds` (read depth) split from the per-clause `Test` (comparison).
     // -----------------------------------------------------------------------------------------
@@ -4291,6 +4613,28 @@ mod tests {
         }
     }
 
+    /// `skipTypedLine` behaves the way every other added field on this wire has to: absent decodes
+    /// off, off writes nothing, and on survives a round trip.
+    ///
+    /// The middle one is the load-bearing clause and the reason this field is
+    /// `skip_serializing_if` where `substitute` is not. `MonitorStep` is on EVERY watching rule, so
+    /// a field that always serialised would rewrite every stored blob the first time this build
+    /// touched it — `a_v1_rule_still_round_trips_byte_for_byte` is the same claim from the other
+    /// end, and would have caught it as a failure rather than as a decision.
+    #[test]
+    fn skip_typed_line_defaults_off_writes_nothing_off_and_round_trips_on() {
+        let older = r#"{"read":"newOutput","cadence":"onOutput","everyMs":0}"#;
+        let decoded: MonitorStep = serde_json::from_str(older)
+            .expect("a monitor step written before this field existed must still decode");
+        assert!(!decoded.skip_typed_line, "an older rule must not acquire the opt-in from a default");
+        assert_eq!(serde_json::to_string(&decoded).unwrap(), older, "and must not gain the key");
+
+        let on = MonitorStep { skip_typed_line: true, ..decoded };
+        let s = serde_json::to_string(&on).unwrap();
+        assert!(s.contains(r#""skipTypedLine":true"#), "written when it is actually used: {s}");
+        assert_eq!(serde_json::from_str::<MonitorStep>(&s).unwrap(), on, "round trip of {s}");
+    }
+
     /// The whole reason `timer` is `#[serde(default)]`: a rule saved by a build before this
     /// milestone has no `timer` key in its graph blob at all, and that older JSON must still
     /// decode — with `timer: None`, not a decode failure. Mirrors
@@ -4327,13 +4671,14 @@ mod tests {
             timer: Some(TimerStep {
                 mode: TimerMode::DailyAt { minute_of_day: 9 * 60, days: 0b0001_1111 },
             }),
-            action: ActionStep {
+            action: Some(ActionStep {
                 message: "stand-up notes?".to_string(),
                 send_to: SendTo::Matched,
                 submit: true,
                 cli_type: "default".to_string(),
                 substitute: false,
-            },
+            }),
+            webhook: None,
             layout: None,
         };
 
diff --git a/src-tauri/src/automation_validation.rs b/src-tauri/src/automation_validation.rs
index 1bfa2e11..5ca35fc7 100644
--- a/src-tauri/src/automation_validation.rs
+++ b/src-tauri/src/automation_validation.rs
@@ -22,12 +22,15 @@
 //! about the parse step alone and need nothing but the graph. **M3 lands the whole-rule rules** (no
 //! terminals, empty message, the echo warning) with the enable path, and **M5 the shared fixture**.
 
+use std::collections::BTreeMap;
+
 use regex::{Regex, RegexBuilder};
+use reqwest::Url;
 
-use crate::automation_engine::subst;
+use crate::automation_engine::{eval, subst};
 use crate::automation_store::{
     AutomationGraph, AutomationRule, Cadence, Criterion, Finds, Keep, ParseStep, Source, TargetMode,
-    Test, TextOp, TimerMode, TimerStep, MINUTES_PER_DAY, WEEKDAY_BITS_MASK,
+    Test, TextOp, TimerMode, TimerStep, WebhookProvider, MINUTES_PER_DAY, WEEKDAY_BITS_MASK,
 };
 
 /// Whether a problem stops the rule running, or merely tells the user something.
@@ -129,6 +132,34 @@ fn token_supplied(compiled: &Regex, group: Option<usize>, name: Option<&str>) ->
     }
 }
 
+fn sample_webhook_captures(compiled: &Regex) -> eval::Captures {
+    let groups = (0..compiled.captures_len())
+        .map(|index| Some(format!("[g{index}]")))
+        .collect();
+    let named = compiled
+        .capture_names()
+        .filter_map(|name| name.map(|name| (name.to_string(), Some(format!("[{name}]")))))
+        .collect::<BTreeMap<_, _>>();
+
+    eval::Captures { groups, named }
+}
+
+fn rendered_webhook_body(webhook: &crate::automation_store::WebhookStep, parse: Option<&ParseStep>) -> String {
+    if !webhook.substitute {
+        return webhook.body.clone();
+    }
+    let Some(parse) = parse else {
+        return webhook.body.clone();
+    };
+    let Ok(compiled) = compile(&parse.find) else {
+        return webhook.body.clone();
+    };
+    match subst::substitute(&webhook.body, Some(&sample_webhook_captures(&compiled))) {
+        Ok(body) => body,
+        Err(_) => webhook.body.clone(),
+    }
+}
+
 /// `$0` / `$2` / `${name}`, for a clause's own problem message.
 ///
 /// `pub(crate)` rather than a second copy: `dry.rs`'s Test-pane wording for a clause list needs the
@@ -298,6 +329,17 @@ pub const MAX_DELAY_MS: i64 = 10 * 60 * 1_000;
 /// keep them apart: this fires only when `scheduled` is false, and that code fires only when it is
 /// true. One graph can never trip both with contradictory remedies.
 ///
+/// **A webhook is a DESTINATION, and it used to be read here as a trigger.** The guard exempted
+/// any graph carrying one, which does nothing for a webhook-only rule — that shape is already
+/// exempt for having no terminal message — and silently exempted the shapes that matter: a rule
+/// with a webhook and nothing to start it reported NO problem at all, so it saved, enabled, and
+/// never fired. Reachable through the REST API and an import from the day the step existed, and
+/// reachable from the editor the moment a card could be deleted: take the three reading steps
+/// off a webhook rule with no wait and this is exactly what is left. The two questions are asked
+/// separately now — *can anything trigger it* (`has_input_steps || scheduled`) and *is there
+/// anything to do* (`has_destination`) — which is what the message underneath has always
+/// claimed to be about.
+///
 /// The remedy differs by shape, and saying so honestly is the whole reason this is not
 /// `timer.delayWithoutMonitor`: with a Wait step already on the canvas the fix is either add a
 /// Watch step or switch that Wait to a schedule; with no Wait step at all there is no "switch it" to
@@ -316,7 +358,11 @@ pub const MAX_DELAY_MS: i64 = 10 * 60 * 1_000;
 fn never_runs_problem(graph: &AutomationGraph) -> Option<Problem> {
     let has_input_steps = graph.monitor.is_some() && graph.parse.is_some() && graph.cond.is_some();
     let scheduled = matches!(graph.timer, Some(TimerStep { mode: TimerMode::DailyAt { .. } }));
-    if has_input_steps || scheduled || graph.action.message.trim().is_empty() {
+    let has_terminal_destination = graph.action.as_ref().is_some_and(|action| !action.message.trim().is_empty());
+    // **A webhook is a DESTINATION, not a trigger**, and conflating the two is what let an
+    // unrunnable rule report nothing at all — see this function's own doc.
+    let has_destination = has_terminal_destination || graph.webhook.is_some();
+    if has_input_steps || scheduled || !has_destination {
         return None;
     }
     let message = if graph.timer.is_some() {
@@ -517,6 +563,14 @@ in the message, as $2, $3 and so on.",
 /// worse than one that says so.
 pub const MIN_TIMER_MS: i64 = crate::automation_engine::due::EVENT_MIN_INTERVAL_MS;
 
+/// Which terminal criteria have a companion value field to fill in.
+///
+/// `AllTerminals` is the one selector that deliberately needs no value. Both the watched-set
+/// criterion and its optional exclusion use this same predicate so the two controls cannot drift.
+fn criterion_needs_value(criterion: Criterion) -> bool {
+    !matches!(criterion, Criterion::AllTerminals)
+}
+
 /// Everything wrong with a WHOLE rule — §6.5's five categories: **target, interval, pattern,
 /// threshold, message**.
 ///
@@ -547,8 +601,7 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
             }
         }
         TargetMode::Rule => {
-            let needs_value = !matches!(rule.criterion, Criterion::AllTerminals);
-            if needs_value && rule.criterion_value.trim().is_empty() {
+            if criterion_needs_value(rule.criterion) && rule.criterion_value.trim().is_empty() {
                 out.push(Problem::new(
                     Severity::Blocks,
                     "targets",
@@ -556,6 +609,19 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
                     "Fill in what the terminals must match, or watch all terminals instead.",
                 ));
             }
+
+            if rule
+                .exclude_criterion
+                .is_some_and(criterion_needs_value)
+                && rule.exclude_criterion_value.trim().is_empty()
+            {
+                out.push(Problem::new(
+                    Severity::Blocks,
+                    "targets",
+                    "targets.excludeValueEmpty",
+                    "Fill in what the exclusion must match, or exclude all terminals instead.",
+                ));
+            }
         }
     }
 
@@ -622,14 +688,26 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
     out.extend(timer_problems(&rule.graph));
 
     // --- message --------------------------------------------------------------------------------
-    if rule.graph.action.message.trim().is_empty() {
+    if rule.graph.action.is_none() && rule.graph.webhook.is_none() {
+        out.push(Problem::new(
+            Severity::Blocks,
+            "action",
+            "rule.noDestination",
+            "Add a terminal message or a webhook destination.",
+        ));
+    } else if rule
+        .graph
+        .action
+        .as_ref()
+        .is_some_and(|action| action.message.trim().is_empty())
+    {
         out.push(Problem::new(
             Severity::Blocks,
             "action",
             "action.empty",
             "Enter the message this rule should type.",
         ));
-    } else if let Some(parse) = parse_step(&rule.graph) {
+    } else if let (Some(action), Some(parse)) = (rule.graph.action.as_ref(), parse_step(&rule.graph)) {
         // §2.6's failure, told to the user before it happens: a rule whose own message matches its
         // own pattern reads its own echo. The needle guard handles it, which is why this WARNS —
         // but the guard has a TTL and a cap, and a user who can see the collision can avoid it.
@@ -647,7 +725,7 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
         // message `HANDOFF now` — was warned about as an echo of itself. Both mirrors had the same
         // bug, so the shared fixture agreed with itself and could not see it.
         if let Ok(re) = compile(&parse.find) {
-            if re.is_match(&rule.graph.action.message) {
+            if re.is_match(&action.message) {
                 out.push(Problem::new(
                     Severity::Warns,
                     "action",
@@ -672,22 +750,41 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
     // toggle claims the message inserts a capture, and a rule with no parse step at all captures
     // nothing, exactly like one whose pattern is still empty. `parse_step` is what makes the two
     // spellings indistinguishable to this check.
-    if rule.graph.action.substitute {
+    for (field, message) in [
+        rule.graph
+            .action
+            .as_ref()
+            .filter(|action| action.substitute)
+            .map(|action| ("action", action.message.as_str())),
+        rule.graph
+            .webhook
+            .as_ref()
+            .filter(|webhook| webhook.substitute)
+            .map(|webhook| ("webhook", webhook.body.as_str())),
+    ]
+    .into_iter()
+    .flatten()
+    {
         match parse_step(&rule.graph) {
-            // The toggle itself claims the message inserts a capture, which nothing can be true
-            // of before a pattern exists — asked regardless of whether a token has actually been
-            // typed yet, the same way the threshold check above is asked regardless of what a
-            // clause would compare against.
-            None => out.push(Problem::new(
+            // **The TOKEN is what claims a capture, not the flag** — and that is a correction.
+            // This used to fire for a flag-on message whatever it contained, on the ground that
+            // *"the toggle itself claims the message inserts a capture"*. True while the flag was
+            // an explicit opt-in a user had to reach for; false the day it became the default, at
+            // which point every schedule rule — which has no parse step by construction (§6.3) —
+            // would have opened blocked by a switch nobody touched. A message naming no token
+            // substitutes to itself: `subst::substitute` returns it unchanged for a `None` capture
+            // set, so there is nothing to report.
+            None if !subst::tokens_used(message).is_empty() => out.push(Problem::new(
                 Severity::Blocks,
-                "action",
+                field,
                 "action.tokenWithoutParse",
                 "This message inserts captured values, but the rule has no pattern to capture them from.",
             )),
+            None => {},
             Some(parse) => {
                 if let Ok(compiled) = compile(&parse.find) {
                     let count = compiled.captures_len().saturating_sub(1);
-                    for token in subst::tokens_used(&rule.graph.action.message) {
+                    for token in subst::tokens_used(message) {
                         let bad = match &token {
                             subst::Token::Whole => false,
                             subst::Token::Group(n) => !token_supplied(&compiled, Some(*n), None),
@@ -700,7 +797,7 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
                         }
                         out.push(Problem::new(
                             Severity::Blocks,
-                            "action",
+                            field,
                             "action.unknownToken",
                             format!(
                                 "{token} has nothing to stand for. The pattern in Read a value has \
@@ -714,6 +811,53 @@ pub fn problems(rule: &AutomationRule) -> Vec<Problem> {
         }
     }
 
+    // --- webhook ---------------------------------------------------------------------------------
+    if let Some(webhook) = rule.graph.webhook.as_ref() {
+        if webhook.url.trim().is_empty() {
+            out.push(Problem::new(
+                Severity::Blocks,
+                "webhook",
+                "webhook.urlEmpty",
+                "Provide a webhook URL.",
+            ));
+        } else if let Ok(url) = Url::parse(webhook.url.trim()) {
+            if url.scheme() != "https" {
+                out.push(Problem::new(
+                    Severity::Blocks,
+                    "webhook",
+                    "webhook.urlNotHttps",
+                    "Provide an https webhook URL.",
+                ));
+            }
+        } else {
+            out.push(Problem::new(
+                Severity::Blocks,
+                "webhook",
+                "webhook.urlMalformed",
+                "Provide a well-formed webhook URL.",
+            ));
+        }
+
+        if webhook.body.trim().is_empty() {
+            out.push(Problem::new(
+                Severity::Blocks,
+                "webhook",
+                "webhook.bodyEmpty",
+                "Enter a webhook body.",
+            ));
+        } else if webhook.provider == WebhookProvider::Custom {
+            let rendered_body = rendered_webhook_body(webhook, parse_step(&rule.graph));
+            if serde_json::from_str::<serde_json::Value>(&rendered_body).is_err() {
+                out.push(Problem::new(
+                    Severity::Blocks,
+                    "webhook",
+                    "webhook.bodyNotJson",
+                    "The webhook body must be valid JSON.",
+                ));
+            }
+        }
+    }
+
     // STABLE, so within each severity the problems stay in step order — targets, monitor, parse,
     // cond, timer, action — which is the order the inspector's problem list draws them in.
     out.sort_by_key(|p| !p.blocks());
@@ -745,16 +889,17 @@ mod tests {
         AutomationGraph {
             layout: None,
             timer: None,
-            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0 }),
+            monitor: Some(MonitorStep { read: ReadMode::NewOutput, cadence: Cadence::OnOutput, every_ms: 0, skip_typed_line: false }),
             parse: Some(ParseStep { preset: ParsePreset::Custom, literal: None, find: find.into(), keep }),
             cond: Some(CondStep { finds: Finds::Reading, op: Some(CompareOp::Gt), threshold: Some(25.0), ..Default::default() }),
-            action: ActionStep {
+            action: Some(ActionStep {
                 message: "m".into(),
                 send_to: SendTo::Matched,
                 submit: true,
                 cli_type: "default".into(),
                 substitute: false,
-            },
+            }),
+            webhook: None,
         }
     }
 
@@ -869,6 +1014,9 @@ mod tests {
             criterion_value: String::new(),
             follow_new: true,
             target_ids: vec!["tm-1".into()],
+            excluded_ids: vec![],
+            exclude_criterion: None,
+            exclude_criterion_value: String::new(),
             completed_at: None,
             verbose_until: None,
             sort_order: 1,
@@ -934,7 +1082,7 @@ mod tests {
             ),
             (
                 "nothing to type",
-                Box::new(|r: &mut AutomationRule| r.graph.action.message = "   ".into()),
+                Box::new(|r: &mut AutomationRule| r.graph.action_mut().message = "   ".into()),
                 "action",
             ),
         ];
@@ -982,7 +1130,7 @@ mod tests {
         let mut rule = valid_rule();
         rule.graph.parse_mut().find = "HANDOFF".into();
         rule.graph.cond = Some(CondStep { finds: Finds::Event, ..Default::default() });
-        rule.graph.action.message = "HANDOFF now".into();
+        rule.graph.action_mut().message = "HANDOFF now".into();
 
         let found = problems(&rule);
         assert_eq!(found.len(), 1, "{:?}", found);
@@ -1002,7 +1150,7 @@ mod tests {
     fn blocking_problems_come_before_warnings() {
         let mut rule = valid_rule();
         rule.graph.parse_mut().find = r"ctx:(\d+)(%)".into();
-        rule.graph.action.message = String::new();
+        rule.graph.action_mut().message = String::new();
 
         let found = problems(&rule);
         assert_eq!(found.len(), 2, "{:?}", found);
@@ -1055,7 +1203,7 @@ mod tests {
         // about. The count is a floor, not the exact number, so adding a case is not a two-file
         // edit.
         assert!(
-            fixture.cases.len() >= 20,
+            fixture.cases.len() >= 66,
             "the shared fixture has shrunk to {} cases",
             fixture.cases.len()
         );
@@ -1089,6 +1237,7 @@ mod tests {
         for code in [
             "targets.empty",
             "targets.criterion",
+            "targets.excludeValueEmpty",
             "monitor.interval",
             "parse.empty",
             "parse.uncompilable",
@@ -1109,6 +1258,12 @@ mod tests {
             "action.echo",
             "action.tokenWithoutParse",
             "action.unknownToken",
+            "rule.noDestination",
+            "webhook.urlEmpty",
+            "webhook.urlMalformed",
+            "webhook.urlNotHttps",
+            "webhook.bodyEmpty",
+            "webhook.bodyNotJson",
         ] {
             assert!(codes.contains(code), "no fixture case produces `{code}`");
         }
@@ -1248,7 +1403,7 @@ mod tests {
         rule.graph.parse = None;
         rule.graph.cond = None;
         rule.graph.timer = Some(TimerStep { mode: TimerMode::AfterMatch { delay_ms: 30_000 } });
-        rule.graph.action.message = "resume".into();
+        rule.graph.action_mut().message = "resume".into();
 
         let found = problems(&rule);
         assert_eq!(
@@ -1440,6 +1595,9 @@ mod tests {
             criterion_value: String::new(),
             follow_new: true,
             target_ids: vec![],
+            excluded_ids: vec![],
+            exclude_criterion: None,
+            exclude_criterion_value: String::new(),
             completed_at: None,
             verbose_until: None,
             sort_order: 0,
@@ -1449,7 +1607,7 @@ mod tests {
             updated_at: 0,
         };
         rule.graph.cond = Some(CondStep { finds: Finds::Event, ..Default::default() });
-        rule.graph.action.message = "anything at all".into();
+        rule.graph.action_mut().message = "anything at all".into();
 
         let found = problems(&rule);
         assert_eq!(found.len(), 1, "only the empty pattern, no echo warning: {found:?}");
diff --git a/src-tauri/src/automation_webhook.rs b/src-tauri/src/automation_webhook.rs
new file mode 100644
index 00000000..dbf4b600
--- /dev/null
+++ b/src-tauri/src/automation_webhook.rs
@@ -0,0 +1,367 @@
+//! Sending an automation's webhook destination.
+//!
+//! The webhook URL is deliberately confined to the request builder. In particular, no error type
+//! in this module retains a `reqwest::Error`: its `Display` and `Debug` implementations can contain
+//! the request URL, which may itself contain a credential.
+
+use std::time::Duration;
+
+use crate::automation_store::{WebhookProvider, WebhookStep};
+
+/// Bound one webhook attempt. A webhook send is dispatched by the engine; this timeout prevents a
+/// peer that accepts a connection but never replies from holding that dispatch indefinitely.
+const WEBHOOK_TIMEOUT: Duration = Duration::from_secs(10);
+
+/// The safe-to-render class of a transport failure.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WebhookTransportClass {
+    Connect,
+    Timeout,
+    Request,
+}
+
+impl std::fmt::Display for WebhookTransportClass {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Connect => f.write_str("connect"),
+            Self::Timeout => f.write_str("timeout"),
+            Self::Request => f.write_str("request"),
+        }
+    }
+}
+
+/// A webhook failure that is safe to put in an automation activity entry.
+///
+/// This intentionally stores only an HTTP status or a coarse transport class. Do not add a
+/// `reqwest::Error`, request URL, or response body here: all of those can carry the user's secret
+/// endpoint into a display or log surface.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WebhookError {
+    Transport(WebhookTransportClass),
+    Status(reqwest::StatusCode),
+}
+
+impl WebhookError {
+    fn from_transport(error: reqwest::Error) -> Self {
+        let class = if error.is_timeout() {
+            WebhookTransportClass::Timeout
+        } else if error.is_connect() {
+            WebhookTransportClass::Connect
+        } else {
+            WebhookTransportClass::Request
+        };
+        Self::Transport(class)
+    }
+}
+
+impl std::fmt::Display for WebhookError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Transport(class) => write!(f, "webhook transport failed ({class})"),
+            Self::Status(status) => write!(f, "webhook returned status {status}"),
+        }
+    }
+}
+
+impl std::error::Error for WebhookError {}
+
+/// Send a configured webhook body to its destination.
+pub async fn send(webhook: &WebhookStep) -> Result<(), WebhookError> {
+    send_body(webhook, &webhook.body).await
+}
+
+/// Send a resolved webhook body to its destination.
+///
+/// Preset providers always receive a newly-created JSON wrapper. `message` is encoded as a JSON
+/// value, never interpolated into a JSON string. A Custom endpoint instead receives `message`'s
+/// bytes unchanged, including whitespace and duplicate JSON object keys. The engine uses this only
+/// after resolving an opted-in capture substitution; normal callers should use [`send`].
+pub async fn send_body(webhook: &WebhookStep, message: &str) -> Result<(), WebhookError> {
+    let body = payload(webhook.provider, message);
+    let client = reqwest::Client::builder()
+        .timeout(WEBHOOK_TIMEOUT)
+        .build()
+        .map_err(WebhookError::from_transport)?;
+    let response = client
+        .post(&webhook.url)
+        .header(reqwest::header::CONTENT_TYPE, "application/json")
+        .body(body)
+        .send()
+        .await
+        .map_err(WebhookError::from_transport)?;
+
+    if response.status().is_success() {
+        Ok(())
+    } else {
+        Err(WebhookError::Status(response.status()))
+    }
+}
+
+pub(crate) fn payload(provider: WebhookProvider, message: &str) -> Vec<u8> {
+    match provider {
+        WebhookProvider::Discord => serde_json::to_vec(&serde_json::json!({ "content": message }))
+            .expect("a string is always serializable as JSON"),
+        WebhookProvider::Slack => serde_json::to_vec(&serde_json::json!({ "text": message }))
+            .expect("a string is always serializable as JSON"),
+        WebhookProvider::Teams => serde_json::to_vec(&serde_json::json!({
+            "@type": "MessageCard",
+            "@context": "http://schema.org/extensions",
+            "text": message,
+        }))
+        .expect("a string is always serializable as JSON"),
+        WebhookProvider::Custom => message.as_bytes().to_vec(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::automation_store::AutomationGraph;
+    use std::io::{Read, Write};
+    use std::net::{TcpListener, TcpStream};
+    use std::sync::mpsc::{self, Receiver};
+
+    fn webhook(provider: WebhookProvider, url: String, body: &str) -> WebhookStep {
+        WebhookStep {
+            provider,
+            url,
+            body: body.to_string(),
+            substitute: false,
+        }
+    }
+
+    /// A one-request loopback server. It is deliberately a local listener rather than a mock so
+    /// the assertions cover the actual reqwest request bytes without contacting any real network.
+    fn capture_endpoint() -> (String, Receiver<Vec<u8>>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind loopback capture listener");
+        let url = format!(
+            "http://{}",
+            listener.local_addr().expect("listener address")
+        );
+        let (sent, received) = mpsc::channel();
+        std::thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept webhook request");
+            let request = read_request(&mut stream);
+            stream
+                .write_all(
+                    b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+                )
+                .expect("reply to webhook request");
+            sent.send(request).expect("return captured request");
+        });
+        (url, received)
+    }
+
+    fn read_request(stream: &mut TcpStream) -> Vec<u8> {
+        stream
+            .set_read_timeout(Some(Duration::from_secs(3)))
+            .expect("set capture read timeout");
+        let mut request = Vec::new();
+        let mut buffer = [0_u8; 1024];
+        let mut expected = None;
+        loop {
+            let read = stream.read(&mut buffer).expect("read webhook request");
+            assert_ne!(read, 0, "client closed before completing request");
+            request.extend_from_slice(&buffer[..read]);
+            if expected.is_none() {
+                expected = content_length(&request).map(|length| {
+                    request
+                        .windows(4)
+                        .position(|bytes| bytes == b"\r\n\r\n")
+                        .expect("headers terminate")
+                        + 4
+                        + length
+                });
+            }
+            if expected.is_some_and(|length| request.len() >= length) {
+                return request;
+            }
+        }
+    }
+
+    fn content_length(request: &[u8]) -> Option<usize> {
+        let header_end = request.windows(4).position(|bytes| bytes == b"\r\n\r\n")?;
+        let headers =
+            std::str::from_utf8(&request[..header_end]).expect("request headers are text");
+        headers.lines().find_map(|line| {
+            let (name, value) = line.split_once(':')?;
+            name.eq_ignore_ascii_case("content-length")
+                .then(|| value.trim().parse().expect("numeric content length"))
+        })
+    }
+
+    fn captured_body(request: Vec<u8>) -> Vec<u8> {
+        let header_end = request
+            .windows(4)
+            .position(|bytes| bytes == b"\r\n\r\n")
+            .expect("headers terminate");
+        request[header_end + 4..].to_vec()
+    }
+
+    fn receive_body(receiver: Receiver<Vec<u8>>) -> Vec<u8> {
+        captured_body(
+            receiver
+                .recv_timeout(Duration::from_secs(3))
+                .expect("webhook capture completed"),
+        )
+    }
+
+    #[tokio::test]
+    async fn discord_wraps_the_message_in_content() {
+        let (url, captured) = capture_endpoint();
+        send(&webhook(WebhookProvider::Discord, url, "build failed"))
+            .await
+            .expect("discord webhook succeeds");
+        assert_eq!(receive_body(captured), br#"{"content":"build failed"}"#);
+    }
+
+    #[tokio::test]
+    async fn slack_wraps_the_message_in_text() {
+        let (url, captured) = capture_endpoint();
+        send(&webhook(WebhookProvider::Slack, url, "build failed"))
+            .await
+            .expect("slack webhook succeeds");
+        assert_eq!(receive_body(captured), br#"{"text":"build failed"}"#);
+    }
+
+    #[tokio::test]
+    async fn teams_uses_a_message_card() {
+        let (url, captured) = capture_endpoint();
+        send(&webhook(WebhookProvider::Teams, url, "build failed"))
+            .await
+            .expect("teams webhook succeeds");
+        let body: serde_json::Value =
+            serde_json::from_slice(&receive_body(captured)).expect("teams payload is JSON");
+        assert_eq!(body["@type"], "MessageCard");
+        assert_eq!(body["text"], "build failed");
+    }
+
+    #[tokio::test]
+    async fn a_custom_endpoint_posts_the_body_verbatim() {
+        let (url, captured) = capture_endpoint();
+        let raw = "{ \"z\" : 1, \"a\" : 2, \"a\" : 3 }\n";
+        send(&webhook(WebhookProvider::Custom, url, raw))
+            .await
+            .expect("custom webhook succeeds");
+        assert_eq!(receive_body(captured), raw.as_bytes());
+    }
+
+    /// The renderer preview has its own implementation, so the exact bytes for every provider live
+    /// in one fixture both sides read. The sender and dry-run producer share `payload`, so they
+    /// cannot drift on payload bytes either.
+    #[test]
+    fn payload_matches_the_shared_fixture() {
+        #[derive(serde::Deserialize)]
+        struct Fixture {
+            cases: Vec<Case>,
+        }
+        #[derive(serde::Deserialize)]
+        struct Case {
+            name: String,
+            provider: WebhookProvider,
+            message: String,
+            expected: String,
+        }
+
+        let raw = include_str!(
+            "../../src/renderer/components/Automation/__fixtures__/webhookPayloadCases.json"
+        );
+        let fixture: Fixture = serde_json::from_str(raw).expect("the shared payload fixture parses");
+        assert_eq!(fixture.cases.len(), 7, "all provider and escaping cases stay covered");
+
+        for case in fixture.cases {
+            let actual = String::from_utf8(payload(case.provider, &case.message))
+                .expect("every payload fixture body is UTF-8");
+            assert_eq!(actual, case.expected, "payload fixture case: {}", case.name);
+        }
+    }
+
+    #[tokio::test]
+    async fn a_capture_containing_json_syntax_cannot_break_a_preset_payload() {
+        let (url, captured) = capture_endpoint();
+        let capture = "quote: \"; slash: \\; newline:\n{\"injected\":true}";
+        send(&webhook(WebhookProvider::Discord, url, capture))
+            .await
+            .expect("discord webhook succeeds");
+        let body: serde_json::Value =
+            serde_json::from_slice(&receive_body(captured)).expect("preset payload remains JSON");
+        assert_eq!(body, serde_json::json!({ "content": capture }));
+        assert_eq!(body.as_object().expect("object payload").len(), 1);
+    }
+
+    #[tokio::test]
+    async fn a_real_transport_error_never_renders_the_url() {
+        // Reserving then dropping a loopback port makes a genuine connection failure without any
+        // traffic leaving this machine. The request URL deliberately contains all three values that
+        // must not reach a display surface.
+        let reserved = TcpListener::bind("127.0.0.1:0").expect("reserve an unused loopback port");
+        let port = reserved.local_addr().expect("reserved address").port();
+        drop(reserved);
+        let url = format!("http://127.0.0.1:{port}/url-leak-path/credential-token");
+        let graph = AutomationGraph {
+            monitor: None,
+            parse: None,
+            cond: None,
+            timer: None,
+            action: None,
+            webhook: Some(webhook(
+                WebhookProvider::Discord,
+                url.clone(),
+                "build failed",
+            )),
+            layout: None,
+        };
+        let graph_debug = format!("{graph:?}");
+        assert!(graph_debug.contains("url: \"<redacted>\""));
+        assert!(!graph_debug.contains(&url));
+        let raw = reqwest::Client::builder()
+            // Do not let a machine-wide proxy turn this local refusal into a real network request.
+            .no_proxy()
+            .timeout(Duration::from_secs(1))
+            .build()
+            .expect("build client")
+            .post(&url)
+            .send()
+            .await
+            .expect_err("dropped loopback port refuses the request");
+
+        assert_eq!(
+            raw.url()
+                .expect("reqwest attaches the request URL to this transport error")
+                .as_str(),
+            url,
+            "this must be a real URL-bearing reqwest error before conversion"
+        );
+        let rendered = WebhookError::from_transport(raw).to_string();
+        for secret in [&url, "127.0.0.1", "url-leak-path"] {
+            assert!(
+                !rendered.contains(secret),
+                "safe webhook error leaked {secret:?}: {rendered:?}"
+            );
+        }
+        assert!(
+            rendered.starts_with("webhook transport failed ("),
+            "the error renders only its coarse class: {rendered:?}"
+        );
+    }
+
+    #[test]
+    fn webhook_and_graph_debug_never_render_the_endpoint() {
+        let secret = "https://hooks.example.invalid/debug-credential";
+        let step = webhook(WebhookProvider::Discord, secret.to_string(), "done");
+        let graph = AutomationGraph {
+            monitor: None,
+            parse: None,
+            cond: None,
+            timer: None,
+            action: None,
+            webhook: Some(step.clone()),
+            layout: None,
+        };
+
+        for rendered in [format!("{step:?}"), format!("{graph:?}")] {
+            assert!(rendered.contains("<redacted>"), "debug did not mark the field: {rendered}");
+            assert!(!rendered.contains(secret), "debug leaked the endpoint: {rendered}");
+        }
+    }
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 3122cbeb..80919d3e 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -20,6 +20,7 @@ pub mod automation_commands;
 pub mod automation_engine;
 pub mod automation_store;
 pub mod automation_validation;
+pub mod automation_webhook;
 pub mod canvas_endpoints;
 pub mod network_commands;
 pub mod pty_manager;
@@ -1499,6 +1500,7 @@ pub fn run() {
         automation_commands::get_automation_runtime,
         automation_commands::load_automation_log,
         automation_commands::list_watchable_terminals,
+        automation_commands::preview_automation_targets,
         automation_commands::dry_run_automation,
         automation_commands::save_automation,
         automation_commands::add_automation_target,
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index 66524858..fb665d07 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -985,6 +985,7 @@ impl<R: Runtime> AppState<R> {
         &self,
         process_id: &str,
         depth: crate::automation_engine::eval::ReadDepth,
+        skip_typed_line: bool,
     ) -> Option<String> {
         use crate::automation_engine::eval::ReadDepth;
         let entry = self.terminal_screens.get(process_id)?;
@@ -1000,7 +1001,7 @@ impl<R: Runtime> AppState<R> {
             ReadDepth::Window(n) => n,
             ReadDepth::VisibleScreen => screen.size().0 as usize,
         };
-        tail_text_with(screen, |sc| render_tail_lines(sc, max_lines))
+        tail_text_with(screen, |sc| render_tail_lines(sc, max_lines, skip_typed_line))
     }
 
     /// Escape sequences restoring the terminal's live input modes, appended to
@@ -2125,6 +2126,49 @@ pub(crate) fn tail_windows(
     plan
 }
 
+/// Which records of a tail walk make up the LOGICAL line the cursor sits on, inclusive.
+///
+/// The reported problem this answers: a rule watching for `deploy` fired the instant the word
+/// appeared under the user's fingers, before Enter. The screen genuinely contains that text, and
+/// nothing else distinguishes an echoed keystroke from output — so the rule that opted in says
+/// *the line the cursor is parked on is not output yet*.
+///
+/// **The cursor's line only, never "and everything below".** The reported use is an agentic CLI
+/// whose status line sits UNDER its input box, and that status line is the text such a rule is
+/// watching for: dropping the rest of the screen would take the value along with the noise.
+///
+/// **Both ends of a soft wrap.** One typed line can occupy several records, and it is one line to
+/// the user. The backward walk is the one a long shell command needs; the forward walk is for a
+/// cursor that is not on the last of those records — press Home on a wrapped command and the
+/// cursor sits on its FIRST row — where dropping only from there down would leave the beginning of
+/// the command behind for the pattern to match on.
+///
+/// Pure, and separate from the walk, because that is what makes the span checkable as arithmetic
+/// rather than through a parser: the walk's last `rows` records are the visible screen, so visible
+/// row `cursor_row` is record `recs.len() - rows + cursor_row`. `None` when that lands outside the
+/// walk, which is a terminal with more rows than the read's own `max_lines` — the top of its screen
+/// was never in the records to begin with.
+fn typed_line_span(
+    recs: &[(String, bool)],
+    rows: usize,
+    cursor_row: usize,
+) -> Option<(usize, usize)> {
+    let at = recs.len().checked_add(cursor_row)?.checked_sub(rows)?;
+    if at >= recs.len() {
+        return None;
+    }
+
+    let mut start = at;
+    while start > 0 && recs.get(start - 1).is_some_and(|(_, wrapped)| *wrapped) {
+        start -= 1;
+    }
+    let mut end = at;
+    while end + 1 < recs.len() && recs.get(end).is_some_and(|(_, wrapped)| *wrapped) {
+        end += 1;
+    }
+    Some((start, end))
+}
+
 /// The last `max_lines` rows of a screen's buffer as PLAIN TEXT, soft-wrapped rows joined.
 ///
 /// **Joining wrapped rows is not optional**: a `ctx:63%` straddling column 120 otherwise never
@@ -2146,10 +2190,18 @@ pub(crate) fn tail_windows(
 /// Bounded at `max_lines` because the walk holds the per-terminal parser mutex that `feed_screen`
 /// contends on, and this file's own note above `full_scrollback_snapshot` says holding it across an
 /// O(scrollback) render stalls output delivery for EVERY terminal.
-pub fn render_tail_lines(screen: &mut vt100::Screen, max_lines: usize) -> String {
+///
+/// `skip_typed_line` drops the logical line under the cursor — the rule's own opt-in, so that a
+/// command still being typed is not read as output. See `typed_line_span`.
+pub fn render_tail_lines(screen: &mut vt100::Screen, max_lines: usize, skip_typed_line: bool) -> String {
     let (rows, cols) = screen.size();
     let saved = screen.scrollback();
 
+    // Read BEFORE the walk moves the offset. The cursor belongs to the LIVE screen, and the row it
+    // reports is an index into the visible rows at offset 0 — asking part-way through the paging
+    // would be asking about whichever window happened to be showing.
+    let cursor_row = screen.cursor_position().0 as usize;
+
     screen.set_scrollback(usize::MAX);
     let total_sb = screen.scrollback();
 
@@ -2168,6 +2220,22 @@ pub fn render_tail_lines(screen: &mut vt100::Screen, max_lines: usize) -> String
     // own scrollback view.
     screen.set_scrollback(saved);
 
+    // BEFORE the trailing blanks go, because the span is addressed by position in the full walk: at
+    // a shell prompt the typed line IS the last non-blank record, and popping first would leave the
+    // arithmetic pointing at whatever survived.
+    if skip_typed_line {
+        if let Some((start, end)) = typed_line_span(&recs, rows as usize, cursor_row) {
+            // `retain` with a counter rather than `drain(start..=end)`: constraint 2 above is that
+            // nothing in this walk may panic, and a range index is exactly the shape that can.
+            let mut i = 0usize;
+            recs.retain(|_| {
+                let keep = i < start || i > end;
+                i += 1;
+                keep
+            });
+        }
+    }
+
     while recs.last().is_some_and(|(t, _)| t.trim().is_empty()) {
         recs.pop();
     }
@@ -2273,8 +2341,9 @@ impl<R: tauri::Runtime> crate::automation_engine::host::EngineHost for AppState<
         &self,
         pc: &str,
         depth: crate::automation_engine::eval::ReadDepth,
+        skip_typed_line: bool,
     ) -> Option<String> {
-        self.screen_tail_text(pc, depth)
+        self.screen_tail_text(pc, depth, skip_typed_line)
     }
 
     fn write(&self, pc: &str, bytes: &[u8]) -> Result<(), String> {
@@ -2338,14 +2407,15 @@ impl<R: tauri::Runtime> crate::automation_engine::eval::ScreenSource for AppStat
         &self,
         process_id: &str,
         depth: crate::automation_engine::eval::ReadDepth,
+        skip_typed_line: bool,
     ) -> Option<String> {
-        self.screen_tail_text(process_id, depth)
+        self.screen_tail_text(process_id, depth, skip_typed_line)
     }
 }
 
 #[cfg(test)]
 mod tail_read_tests {
-    use super::{render_tail_lines, tail_text_with, tail_windows};
+    use super::{render_tail_lines, tail_text_with, tail_windows, typed_line_span};
     use std::sync::Mutex;
 
     fn parser(rows: u16, cols: u16) -> vt100::Parser {
@@ -2362,7 +2432,7 @@ mod tail_read_tests {
         let body: Vec<String> = (1..=500).map(|i| format!("line {}", i)).collect();
         p.process(body.join("\r\n").as_bytes());
 
-        let text = render_tail_lines(p.screen_mut(), 200);
+        let text = render_tail_lines(p.screen_mut(), 200, false);
         let got: Vec<&str> = text.lines().collect();
         assert_eq!(got.len(), 200, "exactly `max_lines` rows");
         assert_eq!(got.first().copied(), Some("line 301"));
@@ -2377,7 +2447,7 @@ mod tail_read_tests {
     fn a_short_buffer_returns_only_what_it_holds() {
         let mut p = parser(24, 80);
         p.process(b"alpha\r\nbeta\r\ngamma");
-        let text = render_tail_lines(p.screen_mut(), 200);
+        let text = render_tail_lines(p.screen_mut(), 200, false);
         assert_eq!(text.lines().collect::<Vec<_>>(), vec!["alpha", "beta", "gamma"]);
     }
 
@@ -2386,7 +2456,7 @@ mod tail_read_tests {
     fn trailing_blank_rows_are_dropped() {
         let mut p = parser(24, 80);
         p.process(b"only line\r\n");
-        let text = render_tail_lines(p.screen_mut(), 200);
+        let text = render_tail_lines(p.screen_mut(), 200, false);
         assert_eq!(text, "only line\n");
     }
 
@@ -2397,7 +2467,7 @@ mod tail_read_tests {
         let mut p = parser(10, 20);
         // 18 characters, then `ctx:63%` - the value straddles column 20.
         p.process(b"..................ctx:63%");
-        let joined = render_tail_lines(p.screen_mut(), 200);
+        let joined = render_tail_lines(p.screen_mut(), 200, false);
         assert!(joined.contains("ctx:63%"), "wrapped rows must be joined: {:?}", joined);
         assert_eq!(joined.lines().count(), 1, "one logical line, not two physical rows");
     }
@@ -2408,7 +2478,7 @@ mod tail_read_tests {
     fn a_hard_line_break_is_not_joined() {
         let mut p = parser(10, 20);
         p.process(b"..................ct\r\nx:63%");
-        let text = render_tail_lines(p.screen_mut(), 200);
+        let text = render_tail_lines(p.screen_mut(), 200, false);
         assert!(!text.contains("ctx:63%"), "a hard break is a real line end: {:?}", text);
         assert_eq!(text.lines().count(), 2);
     }
@@ -2423,7 +2493,7 @@ mod tail_read_tests {
         p.screen_mut().set_scrollback(37);
         let before = p.screen().scrollback();
         assert_eq!(before, 37, "premise: the view is scrolled");
-        let _ = render_tail_lines(p.screen_mut(), 50);
+        let _ = render_tail_lines(p.screen_mut(), 50, false);
         assert_eq!(p.screen().scrollback(), 37, "the walk moved the user's view");
     }
 
@@ -2510,6 +2580,115 @@ mod tail_read_tests {
         assert!(tail_windows(0, 0, 200).is_empty());
         assert!(tail_windows(500, 24, 0).is_empty());
     }
+
+    // -----------------------------------------------------------------------------------------
+    // "Ignore the line being typed" — `monitor.skip_typed_line`
+    // -----------------------------------------------------------------------------------------
+
+    /// Park the cursor on a 1-based `(row, col)`, the way a shell or a TUI leaves it.
+    fn park(p: &mut vt100::Parser, row: u16, col: u16) {
+        p.process(format!("\x1b[{};{}H", row, col).as_bytes());
+    }
+
+    /// The span, as arithmetic over a walk's records — no parser, no screen.
+    ///
+    /// A table over both dimensions that can be wrong independently: WHERE the cursor is among the
+    /// records, and how far the soft wrap around it reaches. Varying one at a time is how an
+    /// implementation that ignores `rows` passes (every row of a buffer with no scrollback) or one
+    /// that only walks backwards passes (every cursor already at the end of its logical line).
+    #[test]
+    fn typed_line_span_is_a_table_over_position_and_wrapping() {
+        let plain = |n: usize| vec![(String::new(), false); n];
+        // `true` means "this record soft-wraps into the next", so b/c/d are ONE logical line.
+        let wrapped = vec![
+            (String::new(), false), // a
+            (String::new(), true),  // b
+            (String::new(), true),  // c
+            (String::new(), false), // d
+            (String::new(), false), // e
+        ];
+
+        // No scrollback: record index and visible row coincide.
+        for row in 0..5 {
+            assert_eq!(typed_line_span(&plain(5), 5, row), Some((row, row)), "row {}", row);
+        }
+        // With scrollback ahead of it, the visible screen is the LAST `rows` records.
+        assert_eq!(typed_line_span(&plain(8), 5, 2), Some((5, 5)));
+        assert_eq!(typed_line_span(&plain(8), 5, 0), Some((3, 3)));
+
+        // Anywhere inside a wrapped run yields the WHOLE run, from either end of it.
+        assert_eq!(typed_line_span(&wrapped, 5, 1), Some((1, 3)), "from its first row");
+        assert_eq!(typed_line_span(&wrapped, 5, 2), Some((1, 3)), "from its middle");
+        assert_eq!(typed_line_span(&wrapped, 5, 3), Some((1, 3)), "from its last row");
+        // Its neighbours are untouched by it.
+        assert_eq!(typed_line_span(&wrapped, 5, 0), Some((0, 0)));
+        assert_eq!(typed_line_span(&wrapped, 5, 4), Some((4, 4)));
+
+        // A screen taller than the read: its top rows were never in the walk, so a cursor up there
+        // addresses nothing. Nothing is dropped rather than something arbitrary.
+        assert_eq!(typed_line_span(&plain(3), 24, 0), None);
+        assert_eq!(typed_line_span(&plain(3), 24, 20), None);
+        assert_eq!(typed_line_span(&plain(3), 24, 23), Some((2, 2)), "the bottom row still lands");
+        assert_eq!(typed_line_span(&[], 24, 3), None, "an empty walk has no line to drop");
+    }
+
+    /// The reported bug: a command still being typed at a prompt fired the rule before Enter.
+    ///
+    /// Both directions in one test, because the flag is the only difference between them — an
+    /// implementation that ignores it passes either half alone.
+    #[test]
+    fn the_line_being_typed_is_dropped_only_when_the_rule_asks() {
+        let mut p = parser(6, 40);
+        p.process(b"build ok\r\n$ deploy now");
+
+        let read = render_tail_lines(p.screen_mut(), 200, false);
+        assert!(read.contains("deploy now"), "off, the screen is the screen: {:?}", read);
+
+        let skipped = render_tail_lines(p.screen_mut(), 200, true);
+        assert!(!skipped.contains("deploy"), "the typed line survived: {:?}", skipped);
+        assert_eq!(skipped, "build ok\n", "and nothing above it went with it");
+    }
+
+    /// Tam's own qualifier, and the half a naive implementation fails: an agentic CLI draws its
+    /// status line UNDER the input box, and that status line is what the rule is watching for.
+    /// "The cursor's line and everything below" would take the value along with the noise.
+    #[test]
+    fn a_status_line_below_the_cursor_is_still_read() {
+        let mut p = parser(6, 40);
+        p.process(b"build ok\r\n> deploy now\r\nctx:63% . idle");
+        park(&mut p, 2, 13); // back onto `> deploy now`, where a TUI leaves it
+
+        let text = render_tail_lines(p.screen_mut(), 200, true);
+        // Whole-output equality, not three `contains` calls: what makes this test worth writing is
+        // exactly WHICH lines survived, and a `contains` oracle cannot tell "kept the status line"
+        // from "kept the status line and half of something else".
+        assert_eq!(text, "build ok\nctx:63% . idle\n");
+    }
+
+    /// A typed line long enough to wrap is still ONE line to the user, and the cursor may sit on
+    /// any of its rows — press Home on a long command and it sits on the FIRST. Dropping from the
+    /// cursor down would leave the beginning of that command behind for the pattern to match.
+    #[test]
+    fn a_soft_wrapped_typed_line_goes_whole() {
+        let mut p = parser(6, 20);
+        p.process(b"before\r\n$ deploy the whole cluster now");
+        p.process(b"\x1b[5;1Hctx:63%");
+        park(&mut p, 2, 3); // the first physical row of the wrapped command
+
+        let text = render_tail_lines(p.screen_mut(), 200, true);
+        // Whole-output equality, and a mutation run is why. The wrap falls mid-word — the rows are
+        // `$ deploy the whole c` and `luster now` — so `!text.contains("cluster")` was true even
+        // with the continuation row still there, and a backward-only walk passed this test.
+        assert_eq!(text, "before\n\nctx:63%\n");
+    }
+
+    /// A cursor resting on a blank row drops a blank row — never the nearest text above it.
+    #[test]
+    fn a_cursor_on_an_empty_row_costs_nothing() {
+        let mut p = parser(6, 40);
+        p.process(b"ctx:63%\r\n");
+        assert_eq!(render_tail_lines(p.screen_mut(), 200, true), "ctx:63%\n");
+    }
 }
 
 /// §10.4c — the half of the restart guard that only a Linux CI run could otherwise check.
diff --git a/src/renderer/__tests__/globalScrollbars.test.ts b/src/renderer/__tests__/globalScrollbars.test.ts
new file mode 100644
index 00000000..54c29069
--- /dev/null
+++ b/src/renderer/__tests__/globalScrollbars.test.ts
@@ -0,0 +1,69 @@
+/**
+ * Scrollbars are styled ONCE, globally, and the rule must stay unscoped.
+ *
+ * Ten stylesheets had each grown their own copy, so a scrollable surface was styled if and only if
+ * someone remembered it. The reported failure shows why a per-component rule is not enough on its
+ * own: `.au-editor ::-webkit-scrollbar` covers everything inside the automation editor, and that
+ * editor's dropdown portals to `body` precisely so a clipping ancestor cannot cut it off — which
+ * puts it outside the selector, and drew a bare Win32 scrollbar in the middle of a dark modal.
+ *
+ * jsdom has no cascade and no scrollbars at all, so the stylesheet is the only place this can be
+ * asked. The assertion that carries the weight is the SCOPE: a rule written as
+ * `.something ::-webkit-scrollbar` in this file would pass a naive "is it styled" check while
+ * leaving every portalled surface bare again.
+ */
+import fs from 'fs';
+import path from 'path';
+
+const CSS = fs.readFileSync(
+    path.join(__dirname, '..', 'styles', 'index.css'),
+    'utf8',
+);
+
+/**
+ * Comments stripped FIRST. A block comment contains no braces, so without this every prose
+ * paragraph above a rule is swallowed into that rule's "selector" — which made the scope
+ * assertion below fail on the very file it was written to pass.
+ */
+const RULES = CSS.replace(/\/\*[\s\S]*?\*\//g, '');
+
+/** Every selector in the file that mentions a scrollbar pseudo-element. */
+const scrollbarSelectors = [...RULES.matchAll(/([^{}]*::-webkit-scrollbar[^{}]*)\{/g)]
+    .map((m) => m[1].trim());
+
+describe('global scrollbar styling', () => {
+    it('styles the track, the thumb, its hover and the corner', () => {
+        for (const part of ['', '-track', '-thumb', '-corner']) {
+            expect(scrollbarSelectors).toContain(`::-webkit-scrollbar${part}`);
+        }
+        expect(scrollbarSelectors).toContain('::-webkit-scrollbar-thumb:hover');
+    });
+
+    it('leaves every rule unscoped, so a portalled surface is covered too', () => {
+        // A selector with anything before the pseudo-element is a descendant rule, and a descendant
+        // rule cannot follow a `createPortal` out to `body`.
+        for (const selector of scrollbarSelectors) {
+            expect(selector.startsWith('::-webkit-scrollbar')).toBe(true);
+        }
+    });
+
+    it('states the standard properties as well as the WebKit ones', () => {
+        // WebKit ignores `scrollbar-width`/`scrollbar-color` and uses the pseudo-elements; other
+        // engines do the reverse. Either alone leaves one of them on the default chrome.
+        expect(CSS).toMatch(/scrollbar-width:\s*thin/);
+        expect(CSS).toMatch(/scrollbar-color:\s*#[0-9a-f]{6}\s+transparent/i);
+    });
+
+    /**
+     * The thumb's inset comes from a transparent border clipped to the padding box, NOT from a
+     * background colour matching one panel. The editor's own copy hard-coded `#17181c` — its
+     * modal's ground — and lifting that verbatim would have drawn a dark-grey halo around the
+     * thumb on every surface with a different background.
+     */
+    it('insets the thumb without pinning one panel background app-wide', () => {
+        const thumb = RULES.slice(RULES.indexOf('::-webkit-scrollbar-thumb {'));
+        const body = thumb.slice(thumb.indexOf('{') + 1, thumb.indexOf('}'));
+        expect(body).toMatch(/border:\s*2px solid transparent/);
+        expect(body).toMatch(/background-clip:\s*padding-box/);
+    });
+});
diff --git a/src/renderer/api/tauri-bridge.ts b/src/renderer/api/tauri-bridge.ts
index 7b8382be..891b452c 100644
--- a/src/renderer/api/tauri-bridge.ts
+++ b/src/renderer/api/tauri-bridge.ts
@@ -3,7 +3,7 @@ import { listen } from '@tauri-apps/api/event';
 import type { UnlistenFn } from '@tauri-apps/api/event';
 import { getCurrentWindow } from '@tauri-apps/api/window';
 import { open as openFileDialog, save as saveFileDialog } from '@tauri-apps/plugin-dialog';
-import type { TerminalSnapshot, ActiveProcess, PeerInfo, PeerRequestInfo, PairingCode, FabricStatus, GrantLevel, AutomationRule, AutomationLogEntry, AutomationSaveResult, WatchableTerminal, DryRunReport } from '../types/electron';
+import type { TerminalSnapshot, ActiveProcess, PeerInfo, PeerRequestInfo, PairingCode, FabricStatus, GrantLevel, AutomationCriterion, AutomationRule, AutomationLogEntry, AutomationSaveResult, WatchableTerminal, AutomationTargetPreview, DryRunReport } from '../types/electron';
 import type { AutomationStatePayload } from '../services/automationEvents';
 import { shouldHandleForWindow } from './windowRouting';
 import { emitPtyInput } from '../utils/ptyInputSignal';
@@ -221,7 +221,8 @@ interface ElectronAPI {
   listAutomations: () => Promise<AutomationRule[]>;
   getAutomationRuntime: () => Promise<AutomationStatePayload>;
   loadAutomationLog: (ruleId: string | null, newestFirst: boolean, limit: number) => Promise<AutomationLogEntry[]>;
-  listWatchableTerminals: (ruleId: string | null, includeIds: string[] | null) => Promise<WatchableTerminal[]>;
+  listWatchableTerminals: (ruleId: string | null, includeIds: string[] | null, criteria: AutomationCriterion[]) => Promise<WatchableTerminal[]>;
+  previewAutomationTargets: (rule: AutomationRule, terminals: WatchableTerminal[]) => Promise<AutomationTargetPreview>;
   dryRunAutomation: (rule: AutomationRule, terminalId: string) => Promise<DryRunReport>;
   saveAutomation: (rule: AutomationRule, origin: string) => Promise<AutomationSaveResult>;
   deleteAutomation: (id: string, origin: string) => Promise<boolean>;
@@ -893,7 +894,7 @@ const tauriBridge: ElectronAPI = {
   // --- Terminal Automations (Plan 028) ---
   //
   // Thin `invoke` wrappers over `automation_commands.rs`, one per command. The first
-  // eleven follow that file's declaration order; the three id-only writers that replaced a
+  // twelve follow that file's declaration order; the three id-only writers that replaced a
   // whole-rule `saveAutomation` are appended last here as the newest of them, wherever
   // they sit in the Rust module. Every argument name
   // here is the camelCase form Tauri derives from the Rust parameter — `rule_id` on the
@@ -904,8 +905,10 @@ const tauriBridge: ElectronAPI = {
   getAutomationRuntime: async () => invoke<AutomationStatePayload>('get_automation_runtime'),
   loadAutomationLog: async (ruleId, newestFirst, limit) =>
     invoke<AutomationLogEntry[]>('load_automation_log', { ruleId, newestFirst, limit }),
-  listWatchableTerminals: async (ruleId, includeIds) =>
-    invoke<WatchableTerminal[]>('list_watchable_terminals', { ruleId, includeIds }),
+  listWatchableTerminals: async (ruleId, includeIds, criteria) =>
+    invoke<WatchableTerminal[]>('list_watchable_terminals', { ruleId, includeIds, criteria }),
+  previewAutomationTargets: async (rule, terminals) =>
+    invoke<AutomationTargetPreview>('preview_automation_targets', { rule, terminals }),
   dryRunAutomation: async (rule, terminalId) =>
     invoke<DryRunReport>('dry_run_automation', { rule, terminalId }),
   saveAutomation: async (rule, origin) =>
diff --git a/src/renderer/components/Automation/AuActivityPane.tsx b/src/renderer/components/Automation/AuActivityPane.tsx
index b5866ec4..9403a742 100644
--- a/src/renderer/components/Automation/AuActivityPane.tsx
+++ b/src/renderer/components/Automation/AuActivityPane.tsx
@@ -18,6 +18,7 @@
 import React from 'react';
 import type { AutomationLogEntry } from '../../types/electron';
 import { LOG_KIND_CLASS, LOG_KIND_LABEL, clockTime } from '../Settings/Automations/activityLog';
+import { redactWebhookLogEntry } from './webhookRedaction';
 
 export interface AuActivityPaneProps {
     entries: AutomationLogEntry[];
@@ -32,7 +33,11 @@ export const AuActivityPane: React.FC<AuActivityPaneProps> = ({
     error,
     saved,
     onOpenFullLog,
-}) => (
+}) => {
+    // Keep this drawer independent of the Settings log's fetch path while applying the same
+    // last-resort redaction to every field it renders.
+    const redactedEntries = entries.map(redactWebhookLogEntry);
+    return (
     <div className="au-dpane" role="tabpanel" aria-label="Activity">
         {error !== null && (
             <div className="au-logempty au-logfailed" role="alert">
@@ -43,7 +48,7 @@ export const AuActivityPane: React.FC<AuActivityPaneProps> = ({
             </div>
         )}
 
-        {error === null && entries.length === 0 && (
+        {error === null && redactedEntries.length === 0 && (
             <div className="au-logempty">
                 <b>No activity yet.</b>
                 <br />
@@ -53,10 +58,10 @@ export const AuActivityPane: React.FC<AuActivityPaneProps> = ({
             </div>
         )}
 
-        {error === null && entries.length > 0 && (
+        {error === null && redactedEntries.length > 0 && (
             <>
                 <div className="au-logrows">
-                    {entries.map((entry) => (
+                    {redactedEntries.map((entry) => (
                         <div key={entry.id} className={`au-logrow ${LOG_KIND_CLASS[entry.kind]}`}>
                             <span className="au-lgt">{clockTime(entry.at)}</span>
                             <span className="au-lgi">
@@ -78,4 +83,5 @@ export const AuActivityPane: React.FC<AuActivityPaneProps> = ({
             </>
         )}
     </div>
-);
+    );
+};
diff --git a/src/renderer/components/Automation/AuCanvas.tsx b/src/renderer/components/Automation/AuCanvas.tsx
index 325bf2d2..36d21902 100644
--- a/src/renderer/components/Automation/AuCanvas.tsx
+++ b/src/renderer/components/Automation/AuCanvas.tsx
@@ -21,7 +21,9 @@ import type { AutomationDraft, NodePos } from './automationDraft';
 import { AU_NODE_H, AU_NODE_W, portSides } from './automationDraft';
 import type { NodeFace, NodeState } from './automationDerive';
 import type { PortRef, StepKind, Wire } from './automationSteps';
+import { removalGroup } from './automationSteps';
 import { AuNode } from './AuNode';
+import { AuNodeMenu } from './AuNodeMenu';
 import { AuWires } from './AuWires';
 import { useAuNodeDrag } from './useAuNodeDrag';
 import { useAuWireDrag } from './useAuWireDrag';
@@ -38,6 +40,12 @@ export interface AuCanvasProps {
     onMove: (step: StepKind, pos: NodePos) => void;
     onConnect: (wire: Wire) => void;
     onDisconnect: (wire: Wire) => void;
+    /**
+     * Take a step off the canvas. **The step the gesture was aimed at**, not the set that will go:
+     * the editor asks `removalGroup` for that, so the reducer, the menu's label and the toast are
+     * all reading one answer rather than three.
+     */
+    onRemove: (step: StepKind) => void;
     onRefuse: (reason: string) => void;
     /** The palette drag needs screen → world too, and only this component knows the transform. */
     onViewportReady: (toWorld: (x: number, y: number) => NodePos | null) => void;
@@ -53,6 +61,7 @@ export const AuCanvas: React.FC<AuCanvasProps> = ({
     onMove,
     onConnect,
     onDisconnect,
+    onRemove,
     onRefuse,
     onViewportReady,
     children,
@@ -63,6 +72,8 @@ export const AuCanvas: React.FC<AuCanvasProps> = ({
     const dpr = typeof window === 'undefined' ? 1 : (window.devicePixelRatio || 1);
     const [vp, setVp] = useState<Viewport>({ x: 0, y: 0, z: 1 });
     const [spacePan, setSpacePan] = useState(false);
+    // Where the right-click menu is, and which card it was aimed at. `null` is closed.
+    const [menu, setMenu] = useState<{ step: StepKind; x: number; y: number } | null>(null);
     const panning = useRef<{ x: number; y: number } | null>(null);
 
     const toWorldOrNull = useCallback((clientX: number, clientY: number): NodePos | null => {
@@ -289,6 +300,17 @@ export const AuCanvas: React.FC<AuCanvasProps> = ({
                         dropPorts={dropPorts[step]}
                         sides={sides}
                         onSelect={() => onSelect(step)}
+                        onDelete={() => onRemove(step)}
+                        onContextMenu={(e) => {
+                            e.preventDefault();
+                            // Or the canvas beneath opens a second menu on the same press.
+                            e.stopPropagation();
+                            // A right-click SELECTS as well, so the inspector is showing the card
+                            // the menu is about — a menu offering to delete one step over a panel
+                            // describing another is the same drift the label rule above avoids.
+                            onSelect(step);
+                            setMenu({ step, x: e.clientX, y: e.clientY });
+                        }}
                         // Space-pan wins over a node drag. React's bubble handler on the node runs
                         // BEFORE the canvas's own, so without this a space+drag that happened to
                         // start on a card moved the card AND the viewport, by the same delta, in
@@ -327,6 +349,16 @@ export const AuCanvas: React.FC<AuCanvasProps> = ({
                 </button>
             </div>
 
+            {menu && (
+                <AuNodeMenu
+                    group={removalGroup(draft.present, menu.step)}
+                    x={menu.x}
+                    y={menu.y}
+                    onClose={() => setMenu(null)}
+                    onDelete={() => onRemove(menu.step)}
+                />
+            )}
+
             {children}
         </div>
     );
diff --git a/src/renderer/components/Automation/AuInfo.tsx b/src/renderer/components/Automation/AuInfo.tsx
new file mode 100644
index 00000000..66aa7615
--- /dev/null
+++ b/src/renderer/components/Automation/AuInfo.tsx
@@ -0,0 +1,146 @@
+/**
+ * An **ⓘ** beside a field label, and the styled panel it opens.
+ *
+ * **Why not `title`.** A native tooltip is the browser's: one size, one colour, no markup, a delay
+ * before it appears and a timeout that takes it away mid-sentence. What belongs behind this icon is
+ * a few worked examples — several lines, a `<code>` run per example, a heading per case — which is
+ * not something a `title` string can hold at all. It also has to be reachable by keyboard and by
+ * touch, and a hover tooltip is neither.
+ *
+ * **Click, not hover**, for the same reason: the panel is content to read, and content that
+ * vanishes when the pointer travels toward it cannot be read.
+ *
+ * **Portalled and `fixed`, like `AuSelect` and `AuTerminalHoverCard`.** The inspector column is
+ * `overflow-y: auto` and the editor's `.au-modal` is `overflow: hidden`, so a panel rendered in
+ * flow is clipped twice over. Every placement decision therefore has to be made against the
+ * trigger's `getBoundingClientRect()` — see `infoPopPosition`, which is a pure function for the
+ * same reason the rest of this folder's geometry is: jsdom lays nothing out, and a placement that
+ * can only be checked by eye is a placement nobody checks.
+ */
+import React, { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+
+/** The panel's box. Needed as NUMBERS, not only as CSS — `infoPopPosition` reasons about them. */
+export const AU_INFO_W = 320;
+/**
+ * The tallest it may get, and the height the clamp assumes. Measuring the rendered element instead
+ * would be exact and would cost a second render pass; a `max-height` the CSS also enforces cannot
+ * be wrong in the direction that matters — the panel can be shorter and still fit, never taller.
+ */
+export const AU_INFO_MAX_H = 300;
+/** Air between the panel and its icon. */
+const GAP = 6;
+/** Air between the panel and the window edge, on every side. */
+const MARGIN = 8;
+
+/**
+ * Where the panel goes, given the icon it belongs to and the window it has to stay inside.
+ *
+ * **Below unless it does not fit, then above** — the icon sits in a label at the top of a field, so
+ * below is where there is normally room and where the eye already is. Horizontally the panel hangs
+ * from the icon's LEFT edge, because these labels are left-aligned and a panel that grew leftwards
+ * from a left-hand icon would sit over the margin.
+ *
+ * Both clamps end with the low edge, deliberately: on a window smaller than the panel the top-left
+ * is the corner that wins, so it is never pushed off the side or the top you read from.
+ */
+export function infoPopPosition(
+    anchor: { top: number; bottom: number; left: number },
+    view: { width: number; height: number },
+): { left: number; top: number } {
+    let left = anchor.left;
+    if (left + AU_INFO_W > view.width - MARGIN) left = view.width - MARGIN - AU_INFO_W;
+    if (left < MARGIN) left = MARGIN;
+
+    const below = anchor.bottom + GAP;
+    // Above only when below genuinely cannot hold it, so the panel does not jump sides as the
+    // inspector scrolls a few pixels.
+    const top = below + AU_INFO_MAX_H <= view.height - MARGIN
+        ? below
+        : Math.max(MARGIN, anchor.top - GAP - AU_INFO_MAX_H);
+    return { left, top };
+}
+
+export interface AuInfoProps {
+    /** Names the button AND the panel: a screen reader meets the panel with no icon to look at. */
+    label: string;
+    children: React.ReactNode;
+}
+
+export const AuInfo: React.FC<AuInfoProps> = ({ label, children }) => {
+    const [open, setOpen] = useState(false);
+    const [at, setAt] = useState<{ left: number; top: number } | null>(null);
+    const triggerRef = useRef<HTMLButtonElement>(null);
+    const popRef = useRef<HTMLDivElement>(null);
+
+    const place = useCallback(() => {
+        const el = triggerRef.current;
+        if (!el) return;
+        const r = el.getBoundingClientRect();
+        setAt(infoPopPosition(r, { width: window.innerWidth, height: window.innerHeight }));
+    }, []);
+
+    useLayoutEffect(() => {
+        if (!open) return;
+        place();
+        // Capture, so a scroll of the inspector column repositions too and not only one of the
+        // window itself — the same reason `AuSelect` gives.
+        window.addEventListener('resize', place);
+        window.addEventListener('scroll', place, true);
+        return () => {
+            window.removeEventListener('resize', place);
+            window.removeEventListener('scroll', place, true);
+        };
+    }, [open, place]);
+
+    useEffect(() => {
+        if (!open) return;
+        const onDown = (e: MouseEvent) => {
+            const target = e.target as Node;
+            // The panel itself is exempt: it holds text people select and links they may click.
+            if (popRef.current?.contains(target) || triggerRef.current?.contains(target)) return;
+            setOpen(false);
+        };
+        const onKey = (e: KeyboardEvent) => {
+            if (e.key !== 'Escape') return;
+            // Stopped here so the editor's own Escape does not ALSO close the whole dialog behind
+            // it: dismissing a panel and discarding an unsaved rule are not the same gesture.
+            e.stopPropagation();
+            setOpen(false);
+            triggerRef.current?.focus();
+        };
+        document.addEventListener('mousedown', onDown);
+        document.addEventListener('keydown', onKey, true);
+        return () => {
+            document.removeEventListener('mousedown', onDown);
+            document.removeEventListener('keydown', onKey, true);
+        };
+    }, [open]);
+
+    return (
+        <>
+            <button
+                ref={triggerRef}
+                type="button"
+                className={`au-info${open ? ' on' : ''}`}
+                aria-label={label}
+                aria-expanded={open}
+                onClick={() => setOpen((was) => !was)}
+            >
+                <span aria-hidden="true">i</span>
+            </button>
+            {open && at && createPortal(
+                <div
+                    ref={popRef}
+                    className="au-infopop"
+                    role="dialog"
+                    aria-label={label}
+                    style={{ left: at.left, top: at.top }}
+                >
+                    {children}
+                </div>,
+                document.body,
+            )}
+        </>
+    );
+};
diff --git a/src/renderer/components/Automation/AuInspector.tsx b/src/renderer/components/Automation/AuInspector.tsx
index 9fb2ffff..3a89b90e 100644
--- a/src/renderer/components/Automation/AuInspector.tsx
+++ b/src/renderer/components/Automation/AuInspector.tsx
@@ -21,6 +21,8 @@ import { ParsePanel } from './panels/ParsePanel';
 import { CondPanel } from './panels/CondPanel';
 import { TimerPanel } from './panels/TimerPanel';
 import { ActionPanel } from './panels/ActionPanel';
+import { WebhookPanel } from './panels/WebhookPanel';
+import { redactWebhookText } from './webhookRedaction';
 
 export interface AuInspectorProps {
     draft: AutomationDraft;
@@ -61,6 +63,7 @@ const FIELD_STEPS: Record<ProblemField, StepKind> = {
     cond: 'cond',
     timer: 'timer',
     action: 'action',
+    webhook: 'webhook',
 };
 
 export const AuInspector: React.FC<AuInspectorProps> = (props) => {
@@ -133,9 +136,12 @@ export const AuInspector: React.FC<AuInspectorProps> = (props) => {
                 {step === 'timer' && (
                     <TimerPanel draft={draft} model={model} dispatch={props.dispatch} />
                 )}
-                {step === 'action' && (
+                {step === 'action' && draft.rule.graph.action && (
                     <ActionPanel draft={draft} model={model} dispatch={props.dispatch} />
                 )}
+                {step === 'webhook' && draft.rule.graph.webhook && (
+                    <WebhookPanel key={draft.rule.id} draft={draft} dispatch={props.dispatch} />
+                )}
             </div>
         </aside>
     );
@@ -158,9 +164,9 @@ const ProblemList: React.FC<{ problems: Problem[]; onFocusStep: (step: StepKind)
             </div>
             <ul>
                 {problems.map((p) => (
-                    <li key={`${p.code}-${p.message}`} className={p.severity}>
+                    <li key={`${p.field}-${p.code}-${p.message}`} className={p.severity}>
                         <button type="button" onClick={() => onFocusStep(FIELD_STEPS[p.field])}>
-                            <b>{STEP_LABELS[FIELD_STEPS[p.field]]}</b> — {p.message}
+                            <b>{STEP_LABELS[FIELD_STEPS[p.field]]}</b> — {redactWebhookText(p.message)}
                         </button>
                     </li>
                 ))}
diff --git a/src/renderer/components/Automation/AuInspectorDock.tsx b/src/renderer/components/Automation/AuInspectorDock.tsx
new file mode 100644
index 00000000..32621927
--- /dev/null
+++ b/src/renderer/components/Automation/AuInspectorDock.tsx
@@ -0,0 +1,129 @@
+/**
+ * The right-hand column's chrome: **how wide it is, and whether it is there at all.**
+ *
+ * The inspector itself stays exactly what it was — a pure projection of the draft — and this wraps
+ * it rather than growing it two more responsibilities. That also keeps `AuInspector`'s signature
+ * unchanged, so the six test call sites that mount it directly are unaffected.
+ *
+ * **The dock is the grid child now, not the `<aside>`.** `.au-mbody`'s third track became `auto`
+ * and the width is an inline style here, so one number drives the column: a CSS variable and a
+ * grid track would be two places for it to be wrong.
+ *
+ * **Collapsed is a RAIL, never zero.** A zero-width column has no affordance to bring it back, and
+ * the panel holds the only editor for whichever step is selected — a user who collapsed it and then
+ * clicked a card would be looking at a card they cannot edit. The rail keeps the reopen button, and
+ * `AutomationEditor` opens the dock on any card selection besides.
+ */
+import React, { useCallback, useEffect, useRef } from 'react';
+
+/** Narrow enough that a long value still wraps rather than ellipsing, at the smallest useful size. */
+export const AU_INSPECT_MIN = 300;
+/**
+ * Past this the panel is winning an argument with the canvas it is describing. The editor is a
+ * 95vh dialog, so a 640px column already leaves the canvas the larger half at any usable size.
+ */
+export const AU_INSPECT_MAX = 640;
+/**
+ * Wider than the 340px it was. That number clipped the comparison row — a source select, an
+ * operator select and a value field on one line — which is what put a `con...` ellipsis on an
+ * operator whose whole job is to be read.
+ */
+export const AU_INSPECT_DEFAULT = 400;
+/** The collapsed rail: the reopen button and nothing else. */
+export const AU_INSPECT_RAIL = 30;
+
+/** How far one arrow-key press moves the edge. Big enough to be worth pressing, small enough to aim. */
+const STEP = 16;
+
+export const clampInspectWidth = (w: number): number =>
+    Math.max(AU_INSPECT_MIN, Math.min(AU_INSPECT_MAX, Math.round(w)));
+
+export interface AuInspectorDockProps {
+    width: number;
+    collapsed: boolean;
+    onWidth: (width: number) => void;
+    onToggle: () => void;
+    children: React.ReactNode;
+}
+
+export const AuInspectorDock: React.FC<AuInspectorDockProps> = ({
+    width,
+    collapsed,
+    onWidth,
+    onToggle,
+    children,
+}) => {
+    const dragging = useRef(false);
+    // Through a ref so the window listeners below can be attached ONCE. Keyed on `onWidth`, they
+    // would tear down and re-arm on every frame of a drag, which is the same trap `CanvasMenu`
+    // documents for its own dismissal listener.
+    const onWidthRef = useRef(onWidth);
+    onWidthRef.current = onWidth;
+
+    useEffect(() => {
+        const move = (e: PointerEvent) => {
+            if (!dragging.current) return;
+            // A button that is no longer down ended this gesture, whatever the browser told us:
+            // releasing outside the window never delivers `pointerup`. The canvas's own pan uses
+            // the same guard for the same reason.
+            if (e.buttons === 0) {
+                dragging.current = false;
+                return;
+            }
+            // The edge is on the LEFT of the panel, so dragging left makes it wider: the width is
+            // the distance from the pointer to the window's right edge, not a delta to accumulate.
+            // Measured absolutely, so a drag that outruns the clamp and comes back tracks the
+            // pointer again instead of staying stuck at the bound.
+            onWidthRef.current(clampInspectWidth(window.innerWidth - e.clientX));
+        };
+        const up = () => { dragging.current = false; };
+        window.addEventListener('pointermove', move);
+        window.addEventListener('pointerup', up, true);
+        return () => {
+            window.removeEventListener('pointermove', move);
+            window.removeEventListener('pointerup', up, true);
+        };
+    }, []);
+
+    const onKeyDown = useCallback((e: React.KeyboardEvent) => {
+        if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;
+        e.preventDefault();
+        // Left widens, matching the drag: the handle is the panel's left edge in both gestures.
+        onWidthRef.current(clampInspectWidth(width + (e.key === 'ArrowLeft' ? STEP : -STEP)));
+    }, [width]);
+
+    return (
+        <div
+            className={`au-idock${collapsed ? ' collapsed' : ''}`}
+            style={{ width: collapsed ? AU_INSPECT_RAIL : width }}
+        >
+            {!collapsed && (
+                <div
+                    className="au-igrip"
+                    role="separator"
+                    aria-orientation="vertical"
+                    aria-label="Resize the settings panel"
+                    aria-valuenow={width}
+                    aria-valuemin={AU_INSPECT_MIN}
+                    aria-valuemax={AU_INSPECT_MAX}
+                    tabIndex={0}
+                    onKeyDown={onKeyDown}
+                    onPointerDown={(e) => {
+                        e.preventDefault();
+                        dragging.current = true;
+                    }}
+                />
+            )}
+            <button
+                type="button"
+                className="au-icollapse"
+                aria-label={collapsed ? 'Show the settings panel' : 'Hide the settings panel'}
+                aria-expanded={!collapsed}
+                onClick={onToggle}
+            >
+                <span aria-hidden="true">{collapsed ? '‹' : '›'}</span>
+            </button>
+            {!collapsed && children}
+        </div>
+    );
+};
diff --git a/src/renderer/components/Automation/AuNode.tsx b/src/renderer/components/Automation/AuNode.tsx
index 143d4456..1f07d06d 100644
--- a/src/renderer/components/Automation/AuNode.tsx
+++ b/src/renderer/components/Automation/AuNode.tsx
@@ -16,7 +16,7 @@ import { STEP_PORTS } from './automationSteps';
 import { AU_NODE_H, AU_NODE_W, sideOf } from './automationDraft';
 import type { PortSide } from './automationDraft';
 
-/** The five accents, from the mockup's own palette. */
+/** The step glyphs, from the mockup's own palette. */
 export const STEP_GLYPHS: Record<StepKind, string> = {
     monitor: '◉',
     parse: '⌥',
@@ -25,6 +25,7 @@ export const STEP_GLYPHS: Record<StepKind, string> = {
     // both a delay and a time of day, and a stopwatch is the one of the three that reads as either.
     timer: '⏱',
     action: '▶',
+    webhook: '↗',
 };
 
 export interface AuNodeProps {
@@ -42,6 +43,19 @@ export interface AuNodeProps {
      */
     sides: Record<string, PortSide>;
     onSelect: () => void;
+    /**
+     * Take this card off the canvas — the Delete key, aimed by FOCUS rather than by selection.
+     *
+     * The canvas has a `window` keydown listener already (Space arms panning) and this deliberately
+     * is not a second one. Selection outlives the pointer: a user selects a card, clicks into the
+     * inspector's message box and types — and a window-level Delete would then have to guess, from
+     * the event target, whether the user meant the character in front of the caret or the card
+     * still drawn as selected. Handled on the card, the question never arises, because a text field
+     * that has the caret also has the focus.
+     */
+    onDelete: () => void;
+    /** Right-click: `AuCanvas` opens the one-item menu at the pointer. */
+    onContextMenu: (e: React.MouseEvent) => void;
     onPointerDown: (e: React.PointerEvent) => void;
     onPortPointerDown: (port: PortRef, e: React.PointerEvent) => void;
     onPortPointerUp: (port: PortRef, e: React.PointerEvent) => void;
@@ -57,6 +71,8 @@ export const AuNode: React.FC<AuNodeProps> = ({
     selected,
     dropPorts,
     onSelect,
+    onDelete,
+    onContextMenu,
     onPointerDown,
     onPortPointerDown,
     onPortPointerUp,
@@ -67,6 +83,22 @@ export const AuNode: React.FC<AuNodeProps> = ({
         data-step={step}
         role="group"
         aria-label={`${face.title} step`}
+        // Focusable, which is what makes the Delete key aimable at all — and it is a plain
+        // improvement besides: until now the only tab stops on a card were its port buttons, so the
+        // cards themselves were unreachable by keyboard. Nothing here calls `preventDefault` on
+        // pointerdown, so a click focuses the card the same press that selects and drags it.
+        tabIndex={0}
+        onKeyDown={(e) => {
+            if (e.key !== 'Delete' && e.key !== 'Backspace') return;
+            // Backspace on a non-editable element is a history-back gesture in some browsers, and
+            // this one is a webview with a single document to go back from.
+            e.preventDefault();
+            // The editor listens for keys too. A Delete that has already removed a card must not
+            // also reach whatever else is listening for one.
+            e.stopPropagation();
+            onDelete();
+        }}
+        onContextMenu={onContextMenu}
         onPointerDown={onPointerDown}
         onClick={onSelect}
     >
diff --git a/src/renderer/components/Automation/AuNodeMenu.tsx b/src/renderer/components/Automation/AuNodeMenu.tsx
new file mode 100644
index 00000000..202a1691
--- /dev/null
+++ b/src/renderer/components/Automation/AuNodeMenu.tsx
@@ -0,0 +1,61 @@
+/**
+ * The right-click menu on a card of the editor's canvas — one item, and it is *Delete*.
+ *
+ * **`CanvasMenu` is borrowed, not copied.** Its own header says it is "deliberately not trying to
+ * be" a generic menu component, and that is a statement about its ITEMS, not its shell: what it
+ * owns is the portal out of a transformed ancestor, the rAF before it starts listening for the
+ * click that dismisses it, and the `onClose` ref that survives a re-render on every frame of a pan.
+ * All three are exactly as true on this canvas, and a second implementation of them here would be
+ * three chances to get the same subtleties wrong — the flickering menu in particular, which looks
+ * like nothing in the code.
+ *
+ * What it does NOT bring is a z-index that works here: `pane-context-menu` sits at 1000 and this
+ * editor is a 9990 modal, so `.au-nodemenu` lifts it in `AutomationEditor.css` alongside
+ * `.au-selmenu`, which had to solve the same problem for the same reason.
+ *
+ * **The item names what will actually go.** `removalGroup` answers with the three reading steps
+ * when any one of them is aimed at, so an item reading *Delete “Read a value”* over a gesture that
+ * removes three cards would be the menu lying about its own effect. The label is computed from
+ * that same list, never from the step the pointer happened to land on.
+ */
+import React from 'react';
+import { CanvasMenu, CanvasMenuItem } from '../Canvas/CanvasMenu';
+import type { StepKind } from './automationSteps';
+import { STEP_LABELS } from './automationSteps';
+
+export interface AuNodeMenuProps {
+    /** The cards this delete will take — `removalGroup`'s answer, never re-derived here. */
+    group: readonly StepKind[];
+    x: number;
+    y: number;
+    onClose: () => void;
+    onDelete: () => void;
+}
+
+/**
+ * *Watch output, Read a value and Compare it* — an Oxford-less English list.
+ *
+ * Exported for the toast, which reports the same set after the fact and must not word it a second
+ * way: the menu promising three cards and the toast naming two is the drift a duplicated join
+ * produces the day the group changes size.
+ */
+export function listSteps(steps: readonly StepKind[]): string {
+    const names = steps.map((step) => STEP_LABELS[step]);
+    if (names.length <= 1) return names[0] ?? '';
+    return `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+}
+
+export const AuNodeMenu: React.FC<AuNodeMenuProps> = ({ group, x, y, onClose, onDelete }) => (
+    <CanvasMenu x={x} y={y} onClose={onClose} className="au-nodemenu">
+        <CanvasMenuItem
+            icon="🗑"
+            danger
+            onClick={() => {
+                onDelete();
+                onClose();
+            }}
+        >
+            {group.length > 1 ? `Delete ${listSteps(group)}` : `Delete “${listSteps(group)}”`}
+        </CanvasMenuItem>
+    </CanvasMenu>
+);
diff --git a/src/renderer/components/Automation/AuSelect.tsx b/src/renderer/components/Automation/AuSelect.tsx
new file mode 100644
index 00000000..b957d011
--- /dev/null
+++ b/src/renderer/components/Automation/AuSelect.tsx
@@ -0,0 +1,270 @@
+/**
+ * A dropdown that cannot be clipped by the window.
+ *
+ * **Why not `<select>`.** TermFlow runs with `decorations: false`, so WebView2 composites the native
+ * option popup INSIDE the window surface instead of handing it to the OS. Chromium still chooses
+ * where to put it from screen geometry, so a select near the bottom of the window opens downward
+ * into space the compositor then clips — the list is cut off mid-row with no scrollbar and no way to
+ * reach the hidden options. The editor is a 95vh dialog whose inspector column scrolls, so ANY of
+ * its selects can be the bottom-most control; this is not a property of one field.
+ *
+ * Nothing in CSS reaches a native popup, so the list has to be ours. It is portalled to `body` and
+ * positioned `fixed`: the inspector column is `overflow-y: auto`, which would clip an absolutely
+ * positioned child of the trigger, and the editor's `.au-modal` is `overflow: hidden` besides.
+ *
+ * **It flips up when there is no room below**, and caps its height to the space it has, so the list
+ * is always whole and always scrollable to its end.
+ */
+import React, { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+
+export interface AuSelectOption {
+    value: string;
+    label: string;
+    /**
+     * The `<optgroup>` this row belongs to, if any. Rendered as a heading above the first row that
+     * carries it — the comparison list is *Text* and *Number*, and flattening those two into one
+     * list of fifteen verbs loses the only thing that makes it skimmable.
+     */
+    group?: string;
+    /** Shown greyed and unpickable — the test pane lists terminals that have since closed. */
+    disabled?: boolean;
+}
+
+export interface AuSelectProps {
+    value: string;
+    options: readonly AuSelectOption[];
+    /** Named the same as the `<select>` this replaces, so callers and tests address it unchanged. */
+    ariaLabel: string;
+    onChange: (value: string) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+
+/** Never draw a list shorter than this; below it, flipping is better than scrolling three rows. */
+const MIN_LIST_H = 96;
+/** Nor taller: a 20-option list that fills the window reads as a page, not a menu. */
+const MAX_LIST_H = 260;
+/** Between the trigger and the list, and between the list and the window edge. */
+const GAP = 4;
+const EDGE = 8;
+
+/**
+ * The list is **at least** as wide as its trigger and as wide as its content needs, bounded by the
+ * window.
+ *
+ * A fixed `width: trigger` was the trigger's width exactly, and `.au-selopt` ellipses what does not
+ * fit — so `does not equal` opened as `does not e…`, which is the one thing a list of options must
+ * never do. Growing rightwards is enough for every select here: they sit in the inspector column at
+ * the right of the window, and the whole width of that column is room the portalled list can use.
+ */
+type Span = { left: number; minWidth: number; maxWidth: number; maxHeight: number };
+type Placement = ({ side: 'below'; top: number } | { side: 'above'; bottom: number }) & Span;
+
+export const AuSelect: React.FC<AuSelectProps> = ({
+    value,
+    options,
+    ariaLabel,
+    onChange,
+    className,
+    style,
+}) => {
+    const [open, setOpen] = useState(false);
+    const [active, setActive] = useState(0);
+    const [placement, setPlacement] = useState<Placement | null>(null);
+    const triggerRef = useRef<HTMLButtonElement>(null);
+    const listRef = useRef<HTMLDivElement>(null);
+
+    const selectedIndex = options.findIndex((o) => o.value === value);
+    const current = selectedIndex >= 0 ? options[selectedIndex] : undefined;
+
+    const place = useCallback(() => {
+        const el = triggerRef.current;
+        if (!el) return;
+        const r = el.getBoundingClientRect();
+        const below = window.innerHeight - r.bottom - GAP - EDGE;
+        const above = r.top - GAP - EDGE;
+        // Below unless it cannot hold a usable list AND above is roomier. Preferring below keeps the
+        // common case where both fit reading the way every other menu in the app does.
+        const flip = below < MIN_LIST_H && above > below;
+        const room = Math.max(MIN_LIST_H, Math.min(MAX_LIST_H, flip ? above : below));
+        const span: Span = {
+            left: r.left,
+            // Never narrower than the control it belongs to, never wider than the window can show.
+            minWidth: r.width,
+            maxWidth: Math.max(r.width, window.innerWidth - r.left - EDGE),
+            maxHeight: room,
+        };
+        setPlacement(
+            flip
+                // Anchored by its BOTTOM, so a list shorter than the room available still sits
+                // against the trigger instead of floating above it.
+                ? { side: 'above', bottom: window.innerHeight - r.top + GAP, ...span }
+                : { side: 'below', top: r.bottom + GAP, ...span },
+        );
+    }, []);
+
+    useLayoutEffect(() => {
+        if (!open) return;
+        place();
+        // `true` — capture — so a scroll of the inspector column repositions too, not only one of
+        // the window itself. A menu that stays put while its trigger slides away is worse than one
+        // that closes.
+        window.addEventListener('resize', place);
+        window.addEventListener('scroll', place, true);
+        return () => {
+            window.removeEventListener('resize', place);
+            window.removeEventListener('scroll', place, true);
+        };
+    }, [open, place]);
+
+    useEffect(() => {
+        if (!open) return;
+        const onDown = (e: MouseEvent) => {
+            const target = e.target as Node;
+            if (listRef.current?.contains(target) || triggerRef.current?.contains(target)) return;
+            setOpen(false);
+        };
+        document.addEventListener('mousedown', onDown);
+        return () => document.removeEventListener('mousedown', onDown);
+    }, [open]);
+
+    /** The next pickable row in `step`'s direction, or `from` when there is none. */
+    const nextEnabled = (from: number, step: number): number => {
+        for (let i = from + step; i >= 0 && i < options.length; i += step) {
+            if (!options[i].disabled) return i;
+        }
+        return from;
+    };
+
+    const commit = (index: number) => {
+        const option = options[index];
+        // A disabled row is reachable by neither key nor click; guarding here as well means a future
+        // caller that opens one some third way still cannot choose it.
+        if (option && option.disabled) return;
+        if (option) onChange(option.value);
+        setOpen(false);
+        triggerRef.current?.focus();
+    };
+
+    const onKeyDown = (e: React.KeyboardEvent) => {
+        if (!open) {
+            if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Enter' || e.key === ' ') {
+                e.preventDefault();
+                setActive(selectedIndex >= 0 ? selectedIndex : 0);
+                setOpen(true);
+            }
+            return;
+        }
+        switch (e.key) {
+            case 'Escape':
+                // The editor closes on Escape too. Stop here, or picking a value would be
+                // indistinguishable from abandoning the whole dialog.
+                e.stopPropagation();
+                e.preventDefault();
+                setOpen(false);
+                triggerRef.current?.focus();
+                break;
+            case 'ArrowDown':
+                e.preventDefault();
+                setActive((i) => nextEnabled(i, 1));
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                setActive((i) => nextEnabled(i, -1));
+                break;
+            case 'Home':
+                e.preventDefault();
+                setActive(nextEnabled(-1, 1));
+                break;
+            case 'End':
+                e.preventDefault();
+                setActive(nextEnabled(options.length, -1));
+                break;
+            case 'Enter':
+            case ' ':
+                e.preventDefault();
+                commit(active);
+                break;
+            case 'Tab':
+                setOpen(false);
+                break;
+            default:
+                break;
+        }
+    };
+
+    return (
+        <>
+            <button
+                type="button"
+                ref={triggerRef}
+                className={`au-finput au-sel${className ? ` ${className}` : ''}`}
+                style={style}
+                aria-label={ariaLabel}
+                aria-haspopup="listbox"
+                aria-expanded={open}
+                onKeyDown={onKeyDown}
+                onClick={() => {
+                    setActive(selectedIndex >= 0 ? selectedIndex : 0);
+                    setOpen((was) => !was);
+                }}
+            >
+                <span className="au-seltext">{current?.label ?? ''}</span>
+                <span className="au-selchev" aria-hidden="true">▾</span>
+            </button>
+            {open && placement && createPortal(
+                <div
+                    ref={listRef}
+                    className="au-selmenu"
+                    role="listbox"
+                    aria-label={ariaLabel}
+                    tabIndex={-1}
+                    style={{
+                        left: placement.left,
+                        // No `width`: a fixed-position box with none shrink-wraps its content, so
+                        // these two bounds are what decide it.
+                        minWidth: placement.minWidth,
+                        maxWidth: placement.maxWidth,
+                        maxHeight: placement.maxHeight,
+                        ...(placement.side === 'below'
+                            ? { top: placement.top }
+                            : { bottom: placement.bottom }),
+                    }}
+                    onKeyDown={onKeyDown}
+                >
+                    {options.map((option, index) => (
+                        <React.Fragment key={option.value}>
+                            {option.group && option.group !== options[index - 1]?.group && (
+                                <div className="au-selgroup" role="presentation">{option.group}</div>
+                            )}
+                        <div
+                            role="option"
+                            // The value a row holds, readable from the DOM. A `<div>` has no
+                            // `value`, and a list whose rows can only be identified by their
+                            // rendered text cannot be asserted against the keys it round-trips.
+                            data-value={option.value}
+                            aria-selected={option.value === value}
+                            aria-disabled={option.disabled || undefined}
+                            className={`au-selopt${index === active && !option.disabled ? ' active' : ''}${
+                                option.value === value ? ' on' : ''
+                            }${option.disabled ? ' dead' : ''}`}
+                            onMouseEnter={() => { if (!option.disabled) setActive(index); }}
+                            onMouseDown={(e) => {
+                                // `mousedown`, not `click`: the outside-close listener above runs on
+                                // mousedown, and a click handler would fire after this menu had
+                                // already been torn down.
+                                e.preventDefault();
+                                commit(index);
+                            }}
+                        >
+                            {option.label}
+                        </div>
+                        </React.Fragment>
+                    ))}
+                </div>,
+                document.body,
+            )}
+        </>
+    );
+};
diff --git a/src/renderer/components/Automation/AuTestPane.tsx b/src/renderer/components/Automation/AuTestPane.tsx
index 8a4681c7..48576af0 100644
--- a/src/renderer/components/Automation/AuTestPane.tsx
+++ b/src/renderer/components/Automation/AuTestPane.tsx
@@ -17,6 +17,7 @@ import React from 'react';
 import type { DryRunReport, WatchableTerminal } from '../../types/electron';
 import { STEP_LABELS } from './automationSteps';
 import type { StepKind } from './automationSteps';
+import { AuSelect } from './AuSelect';
 
 const VERDICTS: Record<DryRunReport['verdict'], { label: string; tone: string }> = {
     'would-fire': { label: 'Would fire', tone: 'sim' },
@@ -39,8 +40,8 @@ const VERDICTS: Record<DryRunReport['verdict'], { label: string; tone: string }>
 function pillFor(report: DryRunReport): { label: string; tone: string } {
     const base = VERDICTS[report.verdict];
     if (report.verdict !== 'would-fire') return base;
-    const actionFailed = report.steps.find((s) => s.kind === 'action')?.status === 'failed';
-    if (!actionFailed) return base;
+    const destinationFailed = report.steps.find((s) => s.kind === 'action' || s.kind === 'webhook')?.status === 'failed';
+    if (!destinationFailed) return base;
     return { label: 'Would fire — but nothing would be sent', tone: base.tone };
 }
 
@@ -72,20 +73,19 @@ export const AuTestPane: React.FC<AuTestPaneProps> = ({
         <div className="au-dtestbar">
             <label className="au-dtestpick">
                 <span>Test against</span>
-                <select
-                    className="au-finput"
-                    aria-label="Terminal to test against"
+                <AuSelect
+                    ariaLabel="Terminal to test against"
                     value={chosen ?? ''}
-                    onChange={(e) => onChoose(e.target.value)}
-                >
-                    <option value="">choose a terminal…</option>
-                    {terminals.map((t) => (
-                        <option key={t.terminalId} value={t.terminalId} disabled={!t.alive}>
-                            {t.terminalId} — {t.label ?? 'unnamed'}
-                            {t.alive ? '' : ' (not open)'}
-                        </option>
-                    ))}
-                </select>
+                    options={[
+                        { value: '', label: 'choose a terminal…' },
+                        ...terminals.map((t) => ({
+                            value: t.terminalId,
+                            label: `${t.terminalId} — ${t.label ?? 'unnamed'}${t.alive ? '' : ' (not open)'}`,
+                            disabled: !t.alive,
+                        })),
+                    ]}
+                    onChange={onChoose}
+                />
             </label>
             <span className="au-grow" />
             {report && (
diff --git a/src/renderer/components/Automation/AutomationEditor.css b/src/renderer/components/Automation/AutomationEditor.css
index c1690052..719fe399 100644
--- a/src/renderer/components/Automation/AutomationEditor.css
+++ b/src/renderer/components/Automation/AutomationEditor.css
@@ -226,7 +226,9 @@
 
 .au-editor .au-mbody {
     display: grid;
-    grid-template-columns: 224px minmax(0, 1fr) 340px;
+    /* The third track is `auto` and the dock carries its own inline width: one number drives
+       the column, where a track plus a variable would be two places for it to disagree. */
+    grid-template-columns: 224px minmax(0, 1fr) auto;
     flex: 1;
     min-height: 0;
 }
@@ -236,7 +238,7 @@
    narrower than the query believes. */
 @container aumodal (max-width: 1180px) {
     .au-editor .au-mbody {
-        grid-template-columns: 180px minmax(0, 1fr) 280px;
+        grid-template-columns: 180px minmax(0, 1fr) auto;
     }
 }
 
@@ -342,6 +344,20 @@
     color: #5fa377;
 }
 
+/*
+ * The mockup predates webhooks — §015 still says "No webhooks" — so this hue is chosen rather than
+ * quoted, on the same three surfaces and in the same shape as the five above. Without it the glyph
+ * inherited the body colour and rendered near-black on the dark rail, which is what it looked like:
+ * an icon that had been switched off. A teal sits in the widest gap left between `action`'s green
+ * and `monitor`'s blue, so the outbound step does not read as either.
+ */
+.au-editor .au-palitem.webhook .au-palico,
+.au-editor .au-node.webhook .au-nico,
+.au-editor .au-gi.webhook {
+    background: rgba(79, 168, 148, 0.16);
+    color: #4fa894;
+}
+
 .au-editor .au-paltext {
     display: flex;
     flex-direction: column;
@@ -475,6 +491,17 @@
     border-color: #6e2b28;
 }
 
+/*
+ * The card is a tab stop now — that is what aims the Delete key — so it needs a ring that is not
+ * the selection border. `:focus-visible`, so a mouse click gets the `.on` border alone and only a
+ * keyboard arrival draws this; `outline-offset` puts it clear of the 10px radius rather than
+ * tracing it, and an outline rather than a box-shadow so `.on`'s own shadow still shows through.
+ */
+.au-editor .au-node:focus-visible {
+    outline: 2px solid #5aa9c9;
+    outline-offset: 3px;
+}
+
 .au-editor .au-nrail {
     position: absolute;
     left: 0;
@@ -760,19 +787,6 @@
     border-top: 1px solid #2b2d33;
 }
 
-.au-editor .au-drawertab {
-    position: absolute;
-    right: 12px;
-    bottom: 42px;
-    padding: 4px 10px;
-    font-size: 0.85rem;
-    color: #a9adb6;
-    background: #1c1d22;
-    border: 1px solid #33353c;
-    border-radius: 7px;
-    cursor: pointer;
-}
-
 .au-editor .au-dhead {
     display: flex;
     align-items: center;
@@ -903,14 +917,103 @@
 
 /* --------------------------------------------------------------- inspector --- */
 
-.au-editor .au-inspect {
+/*
+ * The DOCK is the grid child; the `<aside>` inside it scrolls. `min-height: 0` on both, or the
+ * aside's `overflow-y: auto` never engages inside a grid row and the whole editor grows a
+ * scrollbar instead of the panel.
+ */
+.au-editor .au-idock {
+    position: relative;
     display: flex;
     flex-direction: column;
+    min-height: 0;
     border-left: 1px solid #2b2d33;
     background: #191a1f;
+}
+
+/* The grip overhangs the border on both sides: a 1px edge is not a pointer target, and the panel
+   must not lose a pixel of content to make room for one. */
+.au-editor .au-igrip {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: -3px;
+    width: 7px;
+    z-index: 2;
+    cursor: col-resize;
+}
+
+.au-editor .au-igrip:hover,
+.au-editor .au-igrip:focus-visible {
+    background: rgba(90, 169, 201, 0.35);
+    outline: none;
+}
+
+/*
+ * The collapse button sits in the panel's top-RIGHT corner, where the header has room and the
+ * resize grip does not: the two used to share the left edge and needed a z-index to settle which
+ * got the press. In the collapsed rail it is the only thing there, which is the whole reason the
+ * rail exists — a zero-width column has nothing left to click.
+ *
+ * **12px, not 4.** `.au-inspect` is `overflow-y: auto` and its scrollbar runs down this same edge;
+ * at 4px the button would cover the top of it, and the scrollbar is the one thing that space is
+ * not empty of. The rail overrides it back, having no scrollbar and no room for the inset.
+ */
+.au-editor .au-icollapse {
+    position: absolute;
+    top: 8px;
+    right: 12px;
+    z-index: 3;
+    width: 22px;
+    height: 22px;
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #23252b;
+    border: 1px solid #33353c;
+    border-radius: 5px;
+    color: #9298a3;
+    font-size: 0.95rem;
+    line-height: 1;
+    cursor: pointer;
+}
+
+.au-editor .au-icollapse:hover {
+    background: #2c2f37;
+    color: #e6e6e8;
+}
+
+.au-editor .au-idock.collapsed .au-icollapse {
+    right: 3px;
+}
+
+.au-editor .au-inspect {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 0;
+    background: #191a1f;
     overflow-y: auto;
 }
 
+/*
+ * The gutter the collapse button sits in, reserved on WHATEVER is at the top of the panel.
+ *
+ * Written as `> :first-child` and not as a list of the classes that happen to go there: the button
+ * is absolutely positioned over the panel's top corner, so it collides with the first row of every
+ * state the inspector has. Naming `.au-ihead` covered the selected state and left the empty one —
+ * `.au-inspect-none`, a different element — with `Nothing selected` drawn under the button. A third
+ * state would have been the same bug a third time.
+ *
+ * On the RIGHT since the button moved there, and 36px against its own 12 + 22 + 2 of border.
+ * `auInspectorChromeGaps.test.tsx` derives that sum from the button's own rule rather than
+ * restating it — moving the button again without moving the gutter fails there.
+ */
+.au-editor .au-idock .au-inspect > :first-child {
+    padding-right: 36px;
+}
+
 .au-editor .au-inspect-none {
     padding: 16px 14px;
     font-size: 0.9rem;
@@ -1012,8 +1115,18 @@
     margin-bottom: 16px;
 }
 
+/*
+ * `flex`, not `block`, and only so that an `AuInfo` icon in the label lines up with the words.
+ *
+ * A 15px inline-flex box beside 0.8rem uppercase text is aligned on a baseline the two do not
+ * share — the icon's comes from its own glyph — and no `vertical-align` length is right for both
+ * font sizes at once, which is how it ended up sitting below the caps. `align-items: center`
+ * centres it against the line box instead and asks nothing of either font's metrics. A label with
+ * no icon is a single anonymous item and renders exactly as it did.
+ */
 .au-editor .au-flabel {
-    display: block;
+    display: flex;
+    align-items: center;
     margin-bottom: 6px;
     font-size: 0.8rem;
     letter-spacing: 0.06em;
@@ -1040,8 +1153,39 @@
     gap: 7px;
 }
 
+.au-editor .au-frow .au-mini {
+    flex: 0 0 auto;
+    padding: 6px 10px;
+    font-size: 0.85rem;
+    color: #a9adb6;
+    background: #1c1d22;
+    border: 1px solid #34363e;
+    border-radius: 7px;
+    cursor: pointer;
+}
+
+.au-editor .au-frow .au-mini:hover {
+    color: #fff;
+    background: #2c2f37;
+}
+
 .au-editor .au-radio,
 .au-editor .au-checkrow {
+    /*
+     * The height of the FIRST line's box — `font-size` x `line-height`, both stated just below.
+     * (Kept a separate declaration rather than becoming the `line-height` itself: as a length it
+     * would inherit into `.au-rsub`, whose smaller font-size currently derives its own leading from
+     * the unitless 1.45.)
+     *
+     * The marks centre on THIS, not on the row. `align-items: flex-start` is right — most of these
+     * rows carry a second, smaller line, and centring the whole block puts the control halfway down
+     * a two-line paragraph — but on its own it pins the mark's TOP to the text's top, which sits it
+     * visibly above the title's centre. That is what this row is for.
+     *
+     * In `rem`, deliberately: `.au-cmark` sets its own `font-size`, so an `em` here would resolve
+     * against 0.75rem for the checkbox and 0.9rem for the radio and quietly disagree.
+     */
+    --au-rowline: calc(0.9rem * 1.45);
     display: flex;
     align-items: flex-start;
     gap: 8px;
@@ -1076,7 +1220,9 @@
     flex: 0 0 auto;
     width: 12px;
     height: 12px;
-    margin-top: 2px;
+    /* Centred on the title's line box. `box-sizing: border-box` is global, so 12px is the whole
+       mark including its border. */
+    margin-top: calc((var(--au-rowline) - 12px) / 2);
     border: 1.5px solid #59606b;
     border-radius: 50%;
 }
@@ -1108,7 +1254,8 @@
     height: 13px;
     display: grid;
     place-items: center;
-    margin-top: 1px;
+    /* As `.au-rmark`, for a 13px box. */
+    margin-top: calc((var(--au-rowline) - 13px) / 2);
     font-size: 0.75rem;
     color: transparent;
     border: 1.5px solid #59606b;
@@ -1145,6 +1292,19 @@
     gap: 5px;
 }
 
+/*
+ * The token chips sat flush against the message box above them, reading as part of its border.
+ * `6px` is `.au-fhelp`'s gap, which is the same relationship: a row that explains the control above it.
+ *
+ * Deliberately `.au-finput + `, not `.au-tokens` on its own. Three panels use this row, and only two
+ * of them put it under an input — in `ParsePanel` it is the field's FIRST child, directly after
+ * `.au-flabel`, which already carries `margin-bottom: 6px`. An unqualified rule would fix the two
+ * that touch and silently double the gap on the third.
+ */
+.au-editor .au-finput + .au-tokens {
+    margin-top: 6px;
+}
+
 .au-editor .au-token {
     padding: 4px 9px;
     font-size: 0.85rem;
@@ -1533,6 +1693,25 @@
     background: currentColor;
 }
 
+/*
+ * The state pill and *Re-arm now*, on one row.
+ *
+ * Two problems, one cause, which is why this is a flex row and not two more declarations. JSX
+ * siblings with no literal text between them produce no whitespace node, so the boxes were drawn
+ * touching; and as inline-flex boxes of different heights and font sizes they were aligned on a
+ * baseline they do not share, so the button rode high against the pill. `gap` answers the first and
+ * `align-items: center` answers the second without either of them depending on font metrics.
+ *
+ * It wraps, because the panel is resizable down to 300px and a long pill plus a button does not
+ * always fit on one line.
+ */
+.au-editor .au-nowrow {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
 .au-editor .au-pill.fired,
 .au-editor .au-pill.sim {
     color: #7fd18f;
@@ -1748,3 +1927,201 @@
     font-size: 0.8rem;
     color: #6a6e77;
 }
+
+/* ------------------------------------------------------------------ AuSelect --- */
+
+/*
+ * `.au-sel` is the trigger and keeps `.au-finput`'s box, so it drops into the layouts the
+ * `<select>`s it replaces already sat in.
+ *
+ * `.au-selmenu` is NOT namespaced under `.au-editor`, which every other rule in this file is. It
+ * cannot be: the list portals to `body` so that neither the inspector column's `overflow-y: auto`
+ * nor `.au-modal`'s `overflow: hidden` can clip it, and a descendant selector would then match
+ * nothing. Its own `au-` prefix is what keeps it from colliding.
+ *
+ * z-index sits in the stack this file's header documents: above the editor's 9990, below the 9999
+ * a ConfirmDialog opened over it needs.
+ */
+.au-editor .au-sel {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    text-align: left;
+    cursor: pointer;
+}
+
+.au-editor .au-seltext {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.au-editor .au-selchev {
+    flex: 0 0 auto;
+    color: #7d818c;
+}
+
+.au-selmenu {
+    position: fixed;
+    z-index: 9995;
+    overflow-y: auto;
+    padding: 4px;
+    background: #1c1d22;
+    border: 1px solid #3a3c44;
+    border-radius: 7px;
+    box-shadow: 0 14px 40px rgba(0, 0, 0, 0.55);
+    font-size: 0.95rem;
+    color: #cfd2d8;
+}
+
+.au-selopt {
+    padding: 6px 9px;
+    border-radius: 5px;
+    cursor: pointer;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.au-selopt.on {
+    color: #fff;
+}
+
+/* Hover and keyboard share ONE highlight: `onMouseEnter` moves `active`, so a pointer and the
+   arrow keys cannot disagree about which row is about to be chosen. */
+.au-selopt.active {
+    background: #2c2f37;
+    color: #fff;
+}
+
+.au-selgroup {
+    padding: 6px 9px 3px;
+    font-size: 0.8rem;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    color: #7d818c;
+}
+
+.au-selopt.dead {
+    color: #6b6f78;
+    cursor: not-allowed;
+}
+
+/* ----------------------------------------------------------------- AuInfo --- */
+
+/*
+ * The icon lives INSIDE `.au-flabel`, which is uppercase, letter-spaced and 0.8rem. None of that
+ * should reach the glyph or the panel: `text-transform` and `letter-spacing` are reset here, and
+ * the panel is unnamespaced below because it portals to `body` and never sees the label at all.
+ */
+.au-editor .au-info {
+    margin-left: 7px;
+    width: 15px;
+    height: 15px;
+    padding: 0;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    flex: none;
+    background: transparent;
+    border: 1px solid #4a4d56;
+    border-radius: 999px;
+    color: #8d929c;
+    font-family: Georgia, 'Times New Roman', serif;
+    font-size: 10px;
+    font-style: italic;
+    font-weight: 700;
+    line-height: 1;
+    letter-spacing: 0;
+    text-transform: none;
+    cursor: pointer;
+}
+
+.au-editor .au-info:hover,
+.au-editor .au-info.on {
+    border-color: #5aa9c9;
+    color: #cfe8f2;
+}
+
+/*
+ * NOT namespaced under `.au-editor`, for the reason `.au-selmenu` above gives: the panel is
+ * portalled to `body`, so a descendant selector rooted at the editor never reaches it. Same z-index
+ * as the select menu, which it can never be open alongside — an outside press closes either.
+ *
+ * **A medium, regular reading size (0.9rem / 1.55), deliberately.** This is prose with headings,
+ * lists and code in it, not a label: at the 0.8rem uppercase of the field it sits under, none of it
+ * would be worth opening.
+ */
+.au-infopop {
+    position: fixed;
+    z-index: 9995;
+    box-sizing: border-box;
+    width: 320px;
+    max-height: 300px;
+    overflow-y: auto;
+    padding: 12px 14px;
+    background: #1c1d22;
+    border: 1px solid #3a3c44;
+    border-radius: 8px;
+    box-shadow: 0 14px 40px rgba(0, 0, 0, 0.55);
+    font-size: 0.9rem;
+    font-weight: 400;
+    line-height: 1.55;
+    color: #c2c6ce;
+}
+
+.au-infopop h4 {
+    margin: 12px 0 5px;
+    font-size: 0.9rem;
+    font-weight: 600;
+    color: #e6e6e8;
+}
+
+.au-infopop p {
+    margin: 0 0 8px;
+}
+
+.au-infopop p:last-child {
+    margin-bottom: 0;
+}
+
+/* The two framing sentences: the question to ask, and the trap. Set apart from the examples they
+   bracket, since they are what the examples are FOR. */
+.au-infopop .au-infolead {
+    color: #9aa0aa;
+}
+
+.au-infopop ul {
+    margin: 0 0 8px;
+    padding-left: 18px;
+}
+
+.au-infopop li {
+    margin-bottom: 3px;
+}
+
+.au-infopop code {
+    padding: 1px 5px;
+    background: #26282f;
+    border-radius: 4px;
+    font-family: 'Cascadia Code', Consolas, monospace;
+    font-size: 0.85rem;
+    color: #d7e3b8;
+}
+
+/* ------------------------------------------------------------- AuNodeMenu --- */
+
+/*
+ * `CanvasMenu` borrows `PaneContextMenu.css`, whose `.pane-context-menu` sits at z-index 1000 — a
+ * layer chosen for a menu over the terminal grid, and one this 9990 modal would paint straight
+ * over. Unnamespaced and lifted for the same reason `.au-selmenu` above is: the menu portals to
+ * `body`, so a `.au-editor` descendant selector would match nothing.
+ *
+ * A step above `.au-selmenu`'s 9995 and still below the 9999 a ConfirmDialog opened over the editor
+ * needs. The two can never be open together — the select's own outside-mousedown closes it before
+ * a right-click lands — so the order between them states the stack rather than fixing anything.
+ */
+.pane-context-menu.au-nodemenu {
+    z-index: 9996;
+}
diff --git a/src/renderer/components/Automation/AutomationEditor.tsx b/src/renderer/components/Automation/AutomationEditor.tsx
index 373fad97..168d2a23 100644
--- a/src/renderer/components/Automation/AutomationEditor.tsx
+++ b/src/renderer/components/Automation/AutomationEditor.tsx
@@ -56,13 +56,20 @@ import { blockingProblems, problems as validate } from './automationValidation';
 import { WIRE_CHIPS, faceFor, ruleSummary, stateFor } from './automationDerive';
 import type { NodeFace, NodeState } from './automationDerive';
 import type { OutPortKey, StepKind } from './automationSteps';
-import { STEP_ORDER, canAddStep } from './automationSteps';
+import { STEP_ORDER, canAddStep, removalGroup } from './automationSteps';
+import { listSteps } from './AuNodeMenu';
 import type { CanvasOpening, NodePos } from './automationDraft';
 import { draftFromRule, draftReducer, isDirty, ruleFromDraft, timerShapeOf } from './automationDraft';
 import { AuCanvas } from './AuCanvas';
+import {
+    AU_INSPECT_DEFAULT,
+    AuInspectorDock,
+    clampInspectWidth,
+} from './AuInspectorDock';
 import { AuPalette } from './AuPalette';
 import { AuInspector } from './AuInspector';
 import { AuDrawer } from './AuDrawer';
+import { redactWebhookError } from './webhookRedaction';
 import type { DrawerTab } from './AuDrawer';
 import { useAuPaletteDrag } from './useAuPaletteDrag';
 import './auToggle.css';
@@ -131,6 +138,40 @@ export interface AutomationEditorProps {
     onChanged: () => Promise<void> | void;
 }
 
+const INSPECT_WIDTH_KEY = 'termflow.automation.inspectorWidth';
+const INSPECT_COLLAPSED_KEY = 'termflow.automation.inspectorCollapsed';
+
+/**
+ * `localStorage`, defensively. Every read and write is wrapped: the ACCESSOR itself throws in a
+ * context that blocks site data, and a preference that cannot be stored must cost nothing worse
+ * than the default.
+ */
+function readStored(key: string): string | null {
+    try {
+        return window.localStorage.getItem(key);
+    } catch {
+        return null;
+    }
+}
+
+function writeStored(key: string, value: string): void {
+    try {
+        window.localStorage.setItem(key, value);
+    } catch {
+        /* a preference that will not persist is not an error worth showing anyone */
+    }
+}
+
+/** Clamped on the way IN as well as out: a stored width predates whatever the bounds are today. */
+function readInspectWidth(): number {
+    const raw = Number(readStored(INSPECT_WIDTH_KEY));
+    return Number.isFinite(raw) && raw > 0 ? clampInspectWidth(raw) : AU_INSPECT_DEFAULT;
+}
+
+function readInspectCollapsed(): boolean {
+    return readStored(INSPECT_COLLAPSED_KEY) === '1';
+}
+
 const toast = (message: string, type: 'success' | 'error' | 'info' = 'info') => {
     // The singleton store rather than `useDispatch`, which is the idiom this repo already uses for
     // code that must work outside a Provider (`InputHandler`, `openSettings`). It also keeps the
@@ -218,18 +259,31 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
             const rows = await api.listWatchableTerminals(
                 draft.rule.id.length > 0 ? draft.rule.id : null,
                 draft.rule.targetIds.length > 0 ? draft.rule.targetIds : null,
+                writing.targetMode === 'rule'
+                    ? [writing.criterion, writing.excludeCriterion].filter(
+                        (criterion): criterion is NonNullable<typeof criterion> => criterion != null,
+                    )
+                    : [],
             );
             setTerminals(rows);
             setTerminalsError(null);
         } catch (e) {
-            setTerminalsError(e instanceof Error ? e.message : String(e));
+            setTerminalsError(redactWebhookError(e));
         } finally {
             setTerminalsLoading(false);
         }
         // The pick set is a dependency because a newly ticked id has to appear in the roster with
-        // its snapshot; the rule id is one because it changes exactly once, on the first save.
+        // its snapshot; the criteria are because they decide whether the roster needs process/cwd
+        // data; the rule id changes exactly once, on the first save.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [api, draft.rule.id, draft.rule.targetIds.join(',')]);
+    }, [
+        api,
+        draft.rule.id,
+        draft.rule.targetIds.join(','),
+        writing.targetMode,
+        writing.criterion,
+        writing.excludeCriterion,
+    ]);
 
     /**
      * The roster is POLLED, not fetched once.
@@ -254,7 +308,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
             setEntries(await api.loadAutomationLog(draft.rule.id, true, DRAWER_LOG_LIMIT));
             setLogError(null);
         } catch (e) {
-            setLogError(e instanceof Error ? e.message : String(e));
+            setLogError(redactWebhookError(e));
         }
     }, [api, draft.rule.id]);
 
@@ -352,7 +406,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
         } catch (e) {
             // Reported, and REFUSED. The navigation guard reads this boolean, so swallowing the
             // error here would let a failed save close the editor and take the draft with it.
-            toast(`Could not save: ${e instanceof Error ? e.message : String(e)}`, 'error');
+            toast(`Could not save: ${redactWebhookError(e)}`, 'error');
             return false;
         } finally {
             inFlight.current = false;
@@ -429,7 +483,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
             setReport(await api.dryRunAutomation(writing, target));
         } catch (e) {
             setReport(null);
-            setTestError(e instanceof Error ? e.message : String(e));
+            setTestError(redactWebhookError(e));
         } finally {
             setRunning(false);
         }
@@ -477,7 +531,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
             // The BACKEND owns "is this rule allowed to run" and re-checks — a refusal here is the
             // authority disagreeing with this renderer's own validation, which is exactly the case
             // the mirror exists for and must not be hidden.
-            toast(`Could not switch it ${enabled ? 'on' : 'off'}: ${e instanceof Error ? e.message : String(e)}`, 'error');
+            toast(`Could not switch it ${enabled ? 'on' : 'off'}: ${redactWebhookError(e)}`, 'error');
         }
     };
 
@@ -538,6 +592,78 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
         if (pos) dispatch({ type: 'moveStep', step, pos });
     }, []);
 
+    /**
+     * **The one place a step is removed**, whatever gesture asked for it — the Delete key on a
+     * focused card, and the card's right-click menu. `addStep`'s own note says why this is a
+     * callback rather than a `dispatch` at each call site, and it is the same reason: the gate
+     * belongs where every gesture goes through it, not in whichever caller was written first.
+     *
+     * It is not, however, the only place a step COMES OFF: pulling a destination's wire chip still
+     * removes it, and that path reaches the same `withoutSteps` inside the reducer. The reducer is
+     * where the two meet, so this callback owns only what the reducer cannot see — telling the
+     * user when the gesture took more cards than it was aimed at.
+     *
+     * **The toast fires only for the group**, never for a single card. A card that vanishes when
+     * you press Delete on it needs no narration; three cards vanishing when you aimed at one is a
+     * surprise, and the message names all three rather than announcing a count.
+     */
+    const removeStep = useCallback((step: StepKind) => {
+        const { draft: current } = latest.current;
+        const group = removalGroup(current.present, step);
+        if (group.length === 0) return;
+        dispatch({ type: 'removeStep', step });
+        if (group.length > 1) {
+            toast(
+                `Removed ${listSteps(group)} — the three reading steps work as one, `
+                    + 'so a rule has all of them or none.',
+                'info',
+            );
+        }
+    }, []);
+
+    /**
+     * The inspector's width and whether it is docked open — **per-viewer convenience, so
+     * `localStorage`**. Neither belongs to the rule: they are not dirty-able, they are not written
+     * by a save, and a second machine editing the same rule has no business inheriting them.
+     *
+     * Read through a lazy initialiser so the parse happens once rather than on every render, and
+     * every access is guarded: a private window, cleared site data or a browser set to block site
+     * data throws on the ACCESSOR itself, and an editor that will not open because a preference
+     * could not be read is a worse failure than one that opens at its default width.
+     */
+    const [inspectWidth, setInspectWidth] = useState(() => readInspectWidth());
+    const [inspectCollapsed, setInspectCollapsed] = useState(() => readInspectCollapsed());
+
+    const resizeInspector = useCallback((width: number) => {
+        setInspectWidth(width);
+        writeStored(INSPECT_WIDTH_KEY, String(width));
+    }, []);
+
+    const toggleInspector = useCallback(() => {
+        setInspectCollapsed((was) => {
+            writeStored(INSPECT_COLLAPSED_KEY, was ? '0' : '1');
+            return !was;
+        });
+    }, []);
+
+    /**
+     * **Selecting a card opens the panel**, which is the half that makes collapsing safe: the
+     * inspector holds the only editor for the selected step, so a click on a card while it was
+     * hidden would otherwise select something the user cannot see or change.
+     *
+     * Only a real step does it — clicking the canvas background deselects, and re-opening the
+     * panel to say *"nothing selected"* is the opposite of what the click asked for.
+     */
+    const selectStep = useCallback((step: StepKind | null) => {
+        dispatch({ type: 'select', step });
+        if (step !== null) {
+            setInspectCollapsed((was) => {
+                if (was) writeStored(INSPECT_COLLAPSED_KEY, '0');
+                return false;
+            });
+        }
+    }, []);
+
     const toWorldRef = useRef<(x: number, y: number) => NodePos | null>(() => null);
     // Stable, because `AuCanvas` calls it from an effect: a new identity every render would make
     // that effect re-run on every frame of a drag.
@@ -692,7 +818,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
                                     await onChanged();
                                     toast('Duplicated — the copy is in the list, switched off.', 'success');
                                 } catch (e) {
-                                    toast(`Could not duplicate: ${e instanceof Error ? e.message : String(e)}`, 'error');
+                                    toast(`Could not duplicate: ${redactWebhookError(e)}`, 'error');
                                 }
                             })();
                         }}
@@ -731,10 +857,11 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
                         faces={faces}
                         states={states}
                         chips={chips}
-                        onSelect={(step) => dispatch({ type: 'select', step })}
+                        onSelect={selectStep}
                         onMove={(step, pos) => dispatch({ type: 'moveStep', step, pos })}
                         onConnect={(wire) => dispatch({ type: 'addWire', wire })}
                         onDisconnect={(wire) => dispatch({ type: 'removeWire', wire })}
+                        onRemove={removeStep}
                         onRefuse={(reason) => toast(reason, 'error')}
                         onViewportReady={takeViewport}
                     >
@@ -758,41 +885,43 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
                         )}
                     </AuCanvas>
 
-                    <AuInspector
-                        draft={draft}
-                        problems={problems}
-                        pairs={pairs}
-                        now={now}
-                        terminals={terminals}
-                        terminalsError={terminalsError}
-                        terminalsLoading={terminalsLoading}
-                        report={report}
-                        onRearm={
-                            draft.rule.id.length > 0
-                                ? () => {
-                                    void (async () => {
-                                        try {
-                                            await api?.rearmAutomation?.(draft.rule.id, null);
-                                            await onChanged();
-                                            toast('Re-armed — it can fire again on the next crossing.', 'success');
-                                        } catch (e) {
-                                            toast(`Could not re-arm: ${e instanceof Error ? e.message : String(e)}`, 'error');
-                                        }
-                                    })();
-                                }
-                                : null
-                        }
-                        onTest={() => void runDryRun()}
-                        onFocusStep={(step) => dispatch({ type: 'select', step })}
-                        dispatch={dispatch}
-                    />
+                    <AuInspectorDock
+                        width={inspectWidth}
+                        collapsed={inspectCollapsed}
+                        onWidth={resizeInspector}
+                        onToggle={toggleInspector}
+                    >
+                        <AuInspector
+                            draft={draft}
+                            problems={problems}
+                            pairs={pairs}
+                            now={now}
+                            terminals={terminals}
+                            terminalsError={terminalsError}
+                            terminalsLoading={terminalsLoading}
+                            report={report}
+                            onRearm={
+                                draft.rule.id.length > 0
+                                    ? () => {
+                                        void (async () => {
+                                            try {
+                                                await api?.rearmAutomation?.(draft.rule.id, null);
+                                                await onChanged();
+                                                toast('Re-armed — it can fire again on the next crossing.', 'success');
+                                            } catch (e) {
+                                toast(`Could not re-arm: ${redactWebhookError(e)}`, 'error');
+                                            }
+                                        })();
+                                    }
+                                    : null
+                            }
+                            onTest={() => void runDryRun()}
+                            onFocusStep={selectStep}
+                            dispatch={dispatch}
+                        />
+                    </AuInspectorDock>
                 </div>
 
-                {drawer === null && (
-                    <button type="button" className="au-drawertab" onClick={() => setDrawer('test')}>
-                        Test run &amp; activity
-                    </button>
-                )}
             </div>
 
             {paletteDrag.ghost && (
@@ -825,7 +954,7 @@ export const AutomationEditor: React.FC<AutomationEditorProps> = ({
                             await onChanged();
                             onClose();
                         } catch (e) {
-                            toast(`Could not delete: ${e instanceof Error ? e.message : String(e)}`, 'error');
+                            toast(`Could not delete: ${redactWebhookError(e)}`, 'error');
                         }
                     })();
                 }}
diff --git a/src/renderer/components/Automation/__fixtures__/automationValidationCases.json b/src/renderer/components/Automation/__fixtures__/automationValidationCases.json
index 7d37d60f..bec54841 100644
--- a/src/renderer/components/Automation/__fixtures__/automationValidationCases.json
+++ b/src/renderer/components/Automation/__fixtures__/automationValidationCases.json
@@ -259,6 +259,161 @@
       },
       "expected": []
     },
+    {
+      "name": "an exclusion criterion with no value blocks",
+      "why": "The exclusion is another criterion, so selectors that need a value cannot silently match everything.",
+      "rule": {
+        "id": "au-fix",
+        "name": "r",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "excludedIds": [],
+        "excludeCriterion": "commandContains",
+        "excludeCriterionValue": "   ",
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "onOutput",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "action": {
+            "message": "go",
+            "sendTo": "matched",
+            "submit": true,
+            "cliType": "default"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "targets",
+          "code": "targets.excludeValueEmpty"
+        }
+      ]
+    },
+    {
+      "name": "an all-terminals exclusion needs no criterion value",
+      "why": "AllTerminals is the selector without a companion value, for the exclusion just as for the watched set.",
+      "rule": {
+        "id": "au-fix",
+        "name": "r",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "excludedIds": [],
+        "excludeCriterion": "allTerminals",
+        "excludeCriterionValue": "",
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "onOutput",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "action": {
+            "message": "go",
+            "sendTo": "matched",
+            "submit": true,
+            "cliType": "default"
+          }
+        }
+      },
+      "expected": []
+    },
+    {
+      "name": "a pinned rule ignores its hidden exclusion criterion",
+      "why": "Pinned-mode state may retain a rule exclusion, but no rule criterion participates until the user switches modes.",
+      "rule": {
+        "id": "au-fix",
+        "name": "r",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "pinned",
+        "criterion": "commandContains",
+        "criterionValue": "claude",
+        "followNew": true,
+        "targetIds": [
+          "tm-a71f3c92k"
+        ],
+        "excludedIds": [],
+        "excludeCriterion": "commandContains",
+        "excludeCriterionValue": "   ",
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "onOutput",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "action": {
+            "message": "go",
+            "sendTo": "matched",
+            "submit": true,
+            "cliType": "default"
+          }
+        }
+      },
+      "expected": []
+    },
     {
       "name": "a timer faster than the engine's floor blocks",
       "why": "`due_now` clamps to 250 ms, so a rule asking for 100 would silently get 250.",
@@ -1573,8 +1728,8 @@
       "expected": []
     },
     {
-      "name": "action.unknownToken — $3 with two groups",
-      "why": "Two groups exist, but the message asks for a third. `substitute` is opt-in (plan 032 §4.2), so a text rule can carry this pattern and message with the toggle off with nothing wrong — the case right after this one.",
+      "name": "action.unknownToken — each destination rejects $3 with two groups",
+      "why": "Two groups exist, but both destination messages ask for a third. The terminal action and webhook reuse the same token rule, while retaining their own inspector ownership.",
       "rule": {
         "id": "au-fix",
         "name": "r",
@@ -1614,6 +1769,12 @@
             "submit": true,
             "cliType": "default",
             "substitute": true
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "https://example.invalid/hook",
+            "body": "post $3",
+            "substitute": true
           }
         }
       },
@@ -1622,6 +1783,11 @@
           "severity": "blocks",
           "field": "action",
           "code": "action.unknownToken"
+        },
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "action.unknownToken"
         }
       ]
     },
@@ -3176,6 +3342,432 @@
           "code": "timer.scheduleWithMonitor"
         }
       ]
+    },
+    {
+      "name": "Webhook — must have a destination",
+      "why": "A rule with no action and no webhook is blocked before save or enable.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "commandContains",
+        "criterionValue": "claude",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "onOutput",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "action",
+          "code": "rule.noDestination"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — URL is required",
+      "why": "An empty webhook URL is blocked before save or enable.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "timer",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "percentage",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "",
+            "body": "build failed"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "webhook.urlEmpty"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — malformed URL is blocked",
+      "why": "A non-URL string cannot be used as a webhook destination.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "timer",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "percentage",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "not-a-url",
+            "body": "build failed"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "webhook.urlMalformed"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — URL must be https",
+      "why": "An HTTP webhook destination is blocked because plaintext webhook traffic is unsafe.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "timer",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "percentage",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "http://hooks.example.invalid/relay",
+            "body": "build failed"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "webhook.urlNotHttps"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — body is required",
+      "why": "A blank webhook body cannot be sent.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "timer",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "percentage",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "https://example.invalid/hook",
+            "body": ""
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "webhook.bodyEmpty"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — custom body must be JSON (post-substitution)",
+      "why": "Custom webhooks validate the resolved body; this template would not parse after substitution.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "timer",
+            "everyMs": 30000
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "(?<value>\\\\w+)",
+            "keep": "brackets"
+          },
+          "webhook": {
+            "provider": "custom",
+            "url": "https://example.invalid/hook",
+            "body": "{\"k\": ${value}}",
+            "substitute": true
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "webhook",
+          "code": "webhook.bodyNotJson"
+        }
+      ]
+    },
+    {
+      "name": "Webhook — a present blank terminal action is blocked",
+      "why": "A webhook-only rule omits action; a present action with no message would submit a bare Enter, so it must block even when the webhook is valid.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "commandContains",
+        "criterionValue": "claude",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "monitor": {
+            "read": "newOutput",
+            "cadence": "onOutput",
+            "everyMs": 30000
+          },
+          "parse": {
+            "preset": "custom",
+            "literal": null,
+            "find": "ctx:(\\d+)%",
+            "keep": "brackets"
+          },
+          "cond": {
+            "kind": "number",
+            "op": "gt",
+            "threshold": 25
+          },
+          "action": {
+            "message": "",
+            "sendTo": "matched",
+            "submit": true,
+            "cliType": "default"
+          },
+          "webhook": {
+            "provider": "discord",
+            "url": "https://example.invalid/hook",
+            "body": "build failed"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "action",
+          "code": "action.empty"
+        }
+      ]
+    },
+    {
+      "name": "a destination with nothing to trigger it can never run",
+      "why": "The shape a card removal reaches: the three reading steps taken off a webhook rule that has no wait either. Nothing reads a terminal and no clock fires, so it is unrunnable — and it used to report NOTHING, because a webhook EXEMPTED the rule from the never-runs guard instead of counting as the destination it is. That exemption also hid the same hole for a rule carrying both destinations.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Context handoff reminder",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "webhook": {
+            "provider": "discord",
+            "url": "https://discord.com/api/webhooks/1/abc",
+            "body": "build failed"
+          }
+        }
+      },
+      "expected": [
+        {
+          "severity": "blocks",
+          "field": "timer",
+          "code": "timer.neverRuns"
+        }
+      ]
+    },
+    {
+      "name": "substitution on with no token and no pattern is not a problem",
+      "why": "The narrowing that let the flag become the default. It used to fire for a flag-on message whatever it contained, so a schedule rule — which has no parse step by construction — would open blocked by a switch nobody touched. The TOKEN is what claims a capture; a message naming none substitutes to itself.",
+      "rule": {
+        "id": "au-fix",
+        "name": "Nightly deploy",
+        "enabled": false,
+        "runsOnce": false,
+        "targetMode": "rule",
+        "criterion": "allTerminals",
+        "criterionValue": "",
+        "followNew": true,
+        "targetIds": [],
+        "completedAt": null,
+        "verboseUntil": null,
+        "sortOrder": 0,
+        "schemaVersion": 1,
+        "createdAt": 0,
+        "updatedAt": 0,
+        "graph": {
+          "timer": { "mode": { "dailyAt": { "minuteOfDay": 540, "days": 31 } } },
+          "action": {
+            "message": "/run nightly deploy",
+            "sendTo": "matched",
+            "submit": true,
+            "cliType": "default",
+            "substitute": true
+          }
+        }
+      },
+      "expected": []
     }
   ]
 }
diff --git a/src/renderer/components/Automation/__fixtures__/webhookPayloadCases.json b/src/renderer/components/Automation/__fixtures__/webhookPayloadCases.json
new file mode 100644
index 00000000..ebf11cb2
--- /dev/null
+++ b/src/renderer/components/Automation/__fixtures__/webhookPayloadCases.json
@@ -0,0 +1,46 @@
+{
+  "cases": [
+    {
+      "name": "discord wraps a plain message",
+      "provider": "discord",
+      "message": "build failed",
+      "expected": "{\"content\":\"build failed\"}"
+    },
+    {
+      "name": "slack wraps a plain message",
+      "provider": "slack",
+      "message": "build failed",
+      "expected": "{\"text\":\"build failed\"}"
+    },
+    {
+      "name": "teams posts a MessageCard",
+      "provider": "teams",
+      "message": "build failed",
+      "expected": "{\"@context\":\"http://schema.org/extensions\",\"@type\":\"MessageCard\",\"text\":\"build failed\"}"
+    },
+    {
+      "name": "custom posts its body verbatim",
+      "provider": "custom",
+      "message": "{ \"z\" : 1, \"a\" : 2, \"a\" : 3 }\n",
+      "expected": "{ \"z\" : 1, \"a\" : 2, \"a\" : 3 }\n"
+    },
+    {
+      "name": "discord escapes JSON syntax inside a message",
+      "provider": "discord",
+      "message": "quote: \"; slash: \\; newline:\n{\"injected\":true}",
+      "expected": "{\"content\":\"quote: \\\"; slash: \\\\; newline:\\n{\\\"injected\\\":true}\"}"
+    },
+    {
+      "name": "slack escapes JSON syntax inside a message",
+      "provider": "slack",
+      "message": "quote: \"; slash: \\; newline:\n{\"injected\":true}",
+      "expected": "{\"text\":\"quote: \\\"; slash: \\\\; newline:\\n{\\\"injected\\\":true}\"}"
+    },
+    {
+      "name": "teams escapes JSON syntax inside a message",
+      "provider": "teams",
+      "message": "quote: \"; slash: \\; newline:\n{\"injected\":true}",
+      "expected": "{\"@context\":\"http://schema.org/extensions\",\"@type\":\"MessageCard\",\"text\":\"quote: \\\"; slash: \\\\; newline:\\n{\\\"injected\\\":true}\"}"
+    }
+  ]
+}
diff --git a/src/renderer/components/Automation/__tests__/auCanvasPan.test.tsx b/src/renderer/components/Automation/__tests__/auCanvasPan.test.tsx
index f0394c02..73bf4fc7 100644
--- a/src/renderer/components/Automation/__tests__/auCanvasPan.test.tsx
+++ b/src/renderer/components/Automation/__tests__/auCanvasPan.test.tsx
@@ -68,6 +68,7 @@ describe('AuCanvas — a drag moves the world with the pointer', () => {
                     onMove={() => {}}
                     onConnect={() => {}}
                     onDisconnect={() => {}}
+                    onRemove={() => {}}
                     onRefuse={() => {}}
                     onViewportReady={(fn) => { toWorld = fn; }}
                 />,
diff --git a/src/renderer/components/Automation/__tests__/auInfo.test.tsx b/src/renderer/components/Automation/__tests__/auInfo.test.tsx
new file mode 100644
index 00000000..846d98d3
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auInfo.test.tsx
@@ -0,0 +1,254 @@
+/**
+ * @jest-environment jsdom
+ *
+ * **The ⓘ beside a field label, and the panel it opens.**
+ *
+ * Asked for as *"use custom tooltip so we can display text with style and a medium regular font
+ * size instead of the system tooltip"*. Three things follow from that and are pinned here:
+ *
+ * - It is **not** a `title`. A native tooltip cannot hold a heading, a list and a `<code>` run, and
+ *   it appears on a delay and leaves on a timeout. So: real markup, opened by a real click.
+ * - It is **portalled**. The inspector column is `overflow-y: auto` and the editor's `.au-modal` is
+ *   `overflow: hidden`; a panel rendered in that flow is clipped twice, which is the same trap
+ *   `AuSelect` and `AuTerminalHoverCard` each document.
+ * - Its placement is a **pure function**, because jsdom lays nothing out. `infoPopPosition` is
+ *   checked as arithmetic against a window whose size the test states, which is the only way any of
+ *   this folder's geometry is checkable at all.
+ *
+ * The content itself is asserted through `CondPanel` rather than in isolation: an info panel that
+ * renders perfectly and is wired to no field explains nothing to anybody.
+ */
+import React, { act } from 'react';
+import fs from 'fs';
+import path from 'path';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AU_INFO_MAX_H, AU_INFO_W, AuInfo, infoPopPosition } from '../AuInfo';
+import { AuInspector } from '../AuInspector';
+import { draftFromRule } from '../automationDraft';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+
+describe('infoPopPosition', () => {
+    const view = { width: 1400, height: 900 };
+    /** An icon 15px square, as `.au-info` draws it. */
+    const icon = (left: number, top: number) => ({ left, top, bottom: top + 15 });
+
+    it('hangs below the icon, from its left edge', () => {
+        expect(infoPopPosition(icon(300, 200), view)).toEqual({ left: 300, top: 221 });
+    });
+
+    /**
+     * These labels sit in the inspector at the RIGHT of the window, so the right-edge clamp is the
+     * one that actually runs in production — an unclamped panel would hang off the screen for every
+     * field in the editor.
+     */
+    it('pulls back from the right edge rather than hanging off it', () => {
+        const { left } = infoPopPosition(icon(1300, 200), view);
+        expect(left).toBe(view.width - 8 - AU_INFO_W);
+        expect(left + AU_INFO_W).toBeLessThanOrEqual(view.width - 8);
+    });
+
+    it('flips above only when below genuinely cannot hold it', () => {
+        // Room below for the full height: stays below, so the panel does not jump sides as the
+        // inspector scrolls a few pixels.
+        expect(infoPopPosition(icon(300, 500), view).top).toBe(521);
+        // 60px from the bottom, nowhere near 300 tall.
+        const flipped = infoPopPosition(icon(300, 840), view);
+        expect(flipped.top).toBe(840 - 6 - AU_INFO_MAX_H);
+    });
+
+    /** On a window smaller than the panel, the corner you read from is the one that wins. */
+    it('never places the panel off the top or the left', () => {
+        const tiny = { width: 200, height: 200 };
+        const at = infoPopPosition(icon(10, 190), tiny);
+        expect(at.left).toBe(8);
+        expect(at.top).toBe(8);
+    });
+});
+
+/**
+ * *"A medium regular font size instead of the system tooltip"* — the stated reason for building
+ * this at all, so it is a requirement and not styling.
+ *
+ * Asserted **against the label the icon sits in**, not against a number typed here. `.au-flabel` is
+ * 0.8rem uppercase; the panel holding headings, lists and code has to read larger and plainer than
+ * that, and a comparison says so in a way `font-size: 0.9rem` on its own does not.
+ */
+describe('the panel reads as prose, not as a label', () => {
+    const CSS = fs.readFileSync(path.join(__dirname, '..', 'AutomationEditor.css'), 'utf8')
+        .replace(/\/\*[\s\S]*?\*\//g, '');
+
+    const body = (selector: string): string => {
+        for (const m of CSS.matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+            if (m[1].trim() === selector) return m[2];
+        }
+        throw new Error(`no rule for ${selector}`);
+    };
+    const rem = (css: string): number => Number(css.match(/font-size:\s*([\d.]+)rem/)![1]);
+
+    it('is set larger than the uppercase label it hangs off', () => {
+        expect(rem(body('.au-infopop'))).toBeGreaterThan(rem(body('.au-editor .au-flabel')));
+    });
+
+    it('is regular weight and not upper-cased', () => {
+        expect(body('.au-infopop')).toMatch(/font-weight:\s*400/);
+        expect(body('.au-infopop')).not.toMatch(/text-transform:\s*uppercase/);
+        // The icon inherits the label's casing and tracking unless it undoes them.
+        expect(body('.au-editor .au-info')).toMatch(/text-transform:\s*none/);
+        expect(body('.au-editor .au-info')).toMatch(/letter-spacing:\s*0/);
+    });
+
+    /** Portalled to `body`, so a selector rooted at `.au-editor` would never reach it. */
+    it('is styled by an unscoped selector', () => {
+        expect(CSS).toMatch(/(^|\})\s*\.au-infopop\s*\{/);
+    });
+});
+
+describe('AuInfo', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show() {
+        await act(async () => {
+            root.render(
+                <AuInfo label="Examples of each kind">
+                    <p>a worked example</p>
+                </AuInfo>,
+            );
+        });
+        return container.querySelector<HTMLButtonElement>('[aria-label="Examples of each kind"]')!;
+    }
+
+    const pop = () => document.body.querySelector<HTMLElement>('.au-infopop');
+
+    it('shows nothing until it is asked', async () => {
+        const trigger = await show();
+        expect(pop()).toBeNull();
+        expect(trigger.getAttribute('aria-expanded')).toBe('false');
+    });
+
+    it('opens on a click and closes on the next one', async () => {
+        const trigger = await show();
+        await act(async () => { trigger.click(); });
+        expect(pop()?.textContent).toContain('a worked example');
+        expect(trigger.getAttribute('aria-expanded')).toBe('true');
+
+        await act(async () => { trigger.click(); });
+        expect(pop()).toBeNull();
+    });
+
+    /** The clipping ancestors are the whole reason this is not rendered in place. */
+    it('portals out of its own tree', async () => {
+        const trigger = await show();
+        await act(async () => { trigger.click(); });
+        expect(container.querySelector('.au-infopop')).toBeNull();
+        expect(pop()).not.toBeNull();
+    });
+
+    it('closes on an outside press, and not on a press inside it', async () => {
+        const trigger = await show();
+        await act(async () => { trigger.click(); });
+
+        // Inside: the panel holds text people select and read.
+        await act(async () => {
+            pop()!.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+        expect(pop()).not.toBeNull();
+
+        await act(async () => {
+            document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+        expect(pop()).toBeNull();
+    });
+
+    /**
+     * Escape must close the panel WITHOUT reaching the editor behind it. Dismissing a panel and
+     * discarding an unsaved rule are not the same gesture, and the editor listens for Escape.
+     */
+    it('swallows the Escape that closes it', async () => {
+        const trigger = await show();
+        await act(async () => { trigger.click(); });
+
+        const heard: string[] = [];
+        const listener = (e: Event) => heard.push((e as KeyboardEvent).key);
+        document.addEventListener('keydown', listener);
+        await act(async () => {
+            document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        });
+        document.removeEventListener('keydown', listener);
+
+        expect(pop()).toBeNull();
+        expect(heard).not.toContain('Escape');
+    });
+});
+
+/**
+ * The wiring. `CondPanel`'s `finds` radio is the field this was asked for, and the examples have to
+ * be reachable FROM it — an `AuInfo` that renders beautifully beside nothing is the failure this
+ * half exists to catch.
+ */
+describe('the examples behind "What this pattern finds"', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeEach(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    it('opens from the field label and names an example of each kind', async () => {
+        const rule = blankDraft();
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={{ ...draftFromRule(rule), selected: 'cond' }}
+                    problems={[]}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={() => {}}
+                />,
+            );
+        });
+
+        const label = [...container.querySelectorAll('.au-flabel')].find((l) =>
+            l.textContent?.includes('What this pattern finds'),
+        );
+        const trigger = label?.querySelector('button.au-info') as HTMLButtonElement | undefined;
+        expect(trigger).toBeDefined();
+
+        await act(async () => { trigger!.click(); });
+        const text = document.body.querySelector('.au-infopop')?.textContent ?? '';
+        // One of each kind, and the sentence that tells them apart.
+        expect(text).toContain('ctx:63%');
+        expect(text).toContain('FAILED 3 tests');
+        expect(text).toMatch(/still.*true/is);
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auInspectorChromeGaps.test.tsx b/src/renderer/components/Automation/__tests__/auInspectorChromeGaps.test.tsx
new file mode 100644
index 00000000..8b455efb
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auInspectorChromeGaps.test.tsx
@@ -0,0 +1,203 @@
+/**
+ * @jest-environment jsdom
+ *
+ * Two overlaps in the inspector's chrome, both reported against the running build, both of the same
+ * shape: **an element positioned over or beside another, with the spacing owed to it granted at one
+ * call site out of two.**
+ *
+ * 1. The collapse button is absolutely positioned over the panel's top-left corner. The gutter that
+ *    keeps text clear of it was written as `.au-ihead` — the header a SELECTED step renders — so
+ *    the empty state (`.au-inspect-none`, a different element) drew `Nothing selected` underneath
+ *    the button.
+ * 2. *Re-arm now* follows the state pill with no whitespace text node between them, JSX siblings
+ *    producing none, so the two inline-flex boxes were drawn touching.
+ *
+ * Asserted against the stylesheet, because jsdom has no layout: `getComputedStyle` would return the
+ * declared value at best and nothing useful at worst. What makes these worth writing anyway is that
+ * **both bounds are derived from the geometry they have to clear**, not restated. Move the button's
+ * `left` or `width` and the gutter test fails, which is the class of change that caused #1.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import fs from 'fs';
+import path from 'path';
+
+import { AuInspector } from '../AuInspector';
+import { draftFromRule } from '../automationDraft';
+import type { StepKind } from '../automationSteps';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+
+const CSS = fs.readFileSync(
+    path.join(__dirname, '..', 'AutomationEditor.css'),
+    'utf8',
+);
+
+/** Comments stripped first: a block comment holds no braces, so its prose would otherwise be
+ *  swallowed into the following rule's selector. */
+const RULES = CSS.replace(/\/\*[\s\S]*?\*\//g, '');
+
+/** The body of the first rule whose selector matches, or `null`. */
+function ruleBody(selector: string): string | null {
+    for (const m of RULES.matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+        if (m[1].trim() === selector) return m[2];
+    }
+    return null;
+}
+
+const px = (body: string | null, prop: string): number | null => {
+    const m = body?.match(new RegExp(`(?:^|[;\\s])${prop}:\\s*(-?\\d+(?:\\.\\d+)?)px`));
+    return m ? Number(m[1]) : null;
+};
+
+describe('the collapse button clears whatever is at the top of the panel', () => {
+    const button = ruleBody('.au-editor .au-icollapse');
+
+    it('reserves at least the button\'s own extent, derived from the button', () => {
+        const right = px(button, 'right');
+        const width = px(button, 'width');
+        expect(right).not.toBeNull();
+        expect(width).not.toBeNull();
+
+        const gutter = px(ruleBody('.au-editor .au-idock .au-inspect > :first-child'), 'padding-right');
+        expect(gutter).not.toBeNull();
+        // `+ 2` for the button's 1px border on each side. Anything less and text runs under it.
+        expect(gutter!).toBeGreaterThanOrEqual(right! + width! + 2);
+    });
+
+    /**
+     * The button and the gutter must name the SAME edge. Moving one and not the other leaves a
+     * panel that reserves space where nothing sits and draws text under the button anyway — which
+     * is not a visibly broken stylesheet, just a wrong one.
+     */
+    it('reserves the edge the button is actually on', () => {
+        const first = ruleBody('.au-editor .au-idock .au-inspect > :first-child')!;
+        const onRight = px(button, 'right') !== null;
+        expect(px(first, 'padding-right') !== null).toBe(onRight);
+        expect(px(first, 'padding-left') !== null).toBe(!onRight);
+    });
+
+    /**
+     * `.au-inspect` scrolls, and its scrollbar runs down the right edge — the same edge the button
+     * now sits on. Inset past it, or the top of the scrollbar is unreachable. 10px is what
+     * `index.css` sets app-wide.
+     */
+    it('clears the scrollbar it now shares an edge with', () => {
+        expect(px(button, 'right')!).toBeGreaterThanOrEqual(10);
+    });
+
+    /**
+     * Except in the collapsed rail, which has no scrollbar and is only 30px wide — the inset plus
+     * the button would not fit inside it.
+     */
+    it('drops the inset in the rail, where it would not fit', () => {
+        const rail = px(ruleBody('.au-editor .au-idock.collapsed .au-icollapse'), 'right');
+        const width = px(button, 'width')!;
+        expect(rail).not.toBeNull();
+        // AU_INSPECT_RAIL is 30.
+        expect(rail! + width + 2).toBeLessThanOrEqual(30);
+    });
+
+    /**
+     * The rule that made this a bug twice over. A gutter keyed to one state's own class covers that
+     * state and no other; keyed to the panel's first child it covers every state there is, and the
+     * next one too.
+     */
+    it('is keyed to the panel\'s first child, not to one state\'s class', () => {
+        expect(ruleBody('.au-editor .au-idock .au-inspect > :first-child')).not.toBeNull();
+        expect(ruleBody('.au-editor .au-idock .au-ihead')).toBeNull();
+    });
+});
+
+/**
+ * The other half of the same claim, and the half the stylesheet cannot make: that
+ * `.au-inspect > :first-child` actually lands on what the user reads at the top of the panel. The
+ * CSS test above passes on a rule pointing at nothing.
+ */
+describe('what the gutter rule lands on', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show(selected: StepKind | null) {
+        const rule = blankDraft();
+        const draft = { ...draftFromRule(rule), selected };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={[]}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={() => {}}
+                />,
+            );
+        });
+        return container.querySelector('.au-inspect')!.firstElementChild;
+    }
+
+    /** The reported one: `Nothing selected` was drawn under the button. */
+    it('covers the empty state, whose top row is not a header at all', async () => {
+        const top = await show(null);
+        expect(top?.textContent).toContain('Nothing selected');
+    });
+
+    it('covers a selected step, whose top row is its header', async () => {
+        const top = await show('monitor');
+        expect(top?.classList.contains('au-ihead')).toBe(true);
+    });
+});
+
+/**
+ * Two complaints about this pair, one cause: as inline-flex boxes with no whitespace node between
+ * them they were drawn touching, and being different heights and font sizes they were aligned on a
+ * baseline they do not share, so the button rode high. A flex row answers both without either
+ * answer depending on font metrics — which is why it is asserted as a row and not as two lengths.
+ */
+describe('the state pill and its re-arm button', () => {
+    const row = ruleBody('.au-editor .au-nowrow');
+
+    it('sit on one row, centred on each other and held apart', () => {
+        expect(row).toMatch(/display:\s*flex/);
+        expect(row).toMatch(/align-items:\s*center/);
+        expect(px(row, 'gap')).toBeGreaterThan(0);
+    });
+
+    /** The panel resizes down to 300px, where a long pill plus a button is two lines. */
+    it('wrap rather than overflow a narrow panel', () => {
+        expect(row).toMatch(/flex-wrap:\s*wrap/);
+    });
+});
+
+/**
+ * The same alignment problem in the other place it appeared: a 15px icon beside 0.8rem uppercase
+ * text, aligned on a baseline neither shares. The label centres its items rather than picking a
+ * `vertical-align` length that can only be right for one font size.
+ */
+describe('an info icon in a field label', () => {
+    it('is centred against the label rather than hung off its baseline', () => {
+        const label = ruleBody('.au-editor .au-flabel');
+        expect(label).toMatch(/display:\s*flex/);
+        expect(label).toMatch(/align-items:\s*center/);
+        expect(ruleBody('.au-editor .au-info')).not.toMatch(/vertical-align/);
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auInspectorDock.test.tsx b/src/renderer/components/Automation/__tests__/auInspectorDock.test.tsx
new file mode 100644
index 00000000..798408ea
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auInspectorDock.test.tsx
@@ -0,0 +1,180 @@
+/**
+ * @jest-environment jsdom
+ *
+ * The right-hand column's chrome: **wider, resizable, collapsible, and reachable again afterwards.**
+ *
+ * The fourth of those is the one worth writing a test for. The inspector holds the only editor for
+ * whichever step is selected, so a collapsed panel plus a card click is a user selecting something
+ * they cannot see or change — which is why collapsed is a RAIL with a reopen button rather than a
+ * zero-width column, and why `AutomationEditor` opens the dock on selection. Both halves are
+ * asserted: the rail keeps its button, and the editor's own `selectStep` un-collapses.
+ *
+ * The resize is asserted through the CLAMP rather than through a pixel. jsdom lays nothing out, so
+ * `window.innerWidth - clientX` is the only real input the drag has, and the bounds are the part a
+ * mistake actually shows up in — a panel that can be dragged to 12px or past the canvas.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import {
+    AU_INSPECT_DEFAULT,
+    AU_INSPECT_MAX,
+    AU_INSPECT_MIN,
+    AU_INSPECT_RAIL,
+    AuInspectorDock,
+    clampInspectWidth,
+} from '../AuInspectorDock';
+
+describe('clampInspectWidth', () => {
+    it.each([
+        [10, AU_INSPECT_MIN],
+        [AU_INSPECT_MIN - 1, AU_INSPECT_MIN],
+        [AU_INSPECT_MIN, AU_INSPECT_MIN],
+        [420, 420],
+        [AU_INSPECT_MAX, AU_INSPECT_MAX],
+        [AU_INSPECT_MAX + 1, AU_INSPECT_MAX],
+        [99999, AU_INSPECT_MAX],
+    ])('clamps %d to %d', (given, expected) => {
+        expect(clampInspectWidth(given)).toBe(expected);
+    });
+
+    it('starts wider than the 340px that clipped the comparison row', () => {
+        // A source select, an operator select and a value field share one line there; at 340 the
+        // operator ellipsed to `con...`, which is the whole of what it has to say.
+        expect(AU_INSPECT_DEFAULT).toBeGreaterThan(340);
+        expect(clampInspectWidth(AU_INSPECT_DEFAULT)).toBe(AU_INSPECT_DEFAULT);
+    });
+});
+
+describe('AuInspectorDock', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show(props: { width?: number; collapsed?: boolean } = {}) {
+        const onWidth = jest.fn();
+        const onToggle = jest.fn();
+        await act(async () => {
+            root.render(
+                <AuInspectorDock
+                    width={props.width ?? AU_INSPECT_DEFAULT}
+                    collapsed={props.collapsed ?? false}
+                    onWidth={onWidth}
+                    onToggle={onToggle}
+                >
+                    <aside className="au-inspect">panel body</aside>
+                </AuInspectorDock>,
+            );
+        });
+        return { onWidth, onToggle };
+    }
+
+    const dock = () => container.querySelector<HTMLElement>('.au-idock')!;
+    const grip = () => container.querySelector<HTMLElement>('.au-igrip');
+    const collapseButton = () => container.querySelector<HTMLButtonElement>('.au-icollapse')!;
+
+    /** jsdom ships no pointer-event constructor; a `MouseEvent` under the pointer type name
+     *  reaches both React's synthetic handler and the window listeners, and carries `buttons`.
+     *  The same shim `auCanvasPan.test.tsx` uses. */
+    const pointer = (type: string, over: MouseEventInit = {}) =>
+        new MouseEvent(type, { bubbles: true, buttons: 1, ...over });
+
+    it('carries its own width, so one number drives the grid column', async () => {
+        await show({ width: 420 });
+        expect(dock().style.width).toBe('420px');
+    });
+
+    it('collapses to a rail that still holds the reopen button', async () => {
+        await show({ collapsed: true });
+        expect(dock().style.width).toBe(`${AU_INSPECT_RAIL}px`);
+        // The panel body is gone and the way back is not — a zero-width column would lose both.
+        expect(container.textContent).not.toContain('panel body');
+        expect(collapseButton()).not.toBeNull();
+        expect(collapseButton().getAttribute('aria-expanded')).toBe('false');
+    });
+
+    it('offers no resize handle while collapsed, where there is nothing to size', async () => {
+        await show({ collapsed: true });
+        expect(grip()).toBeNull();
+    });
+
+    it('reports a width measured from the window edge, clamped', async () => {
+        const { onWidth } = await show();
+        (window as unknown as { innerWidth: number }).innerWidth = 1400;
+
+        await act(async () => {
+            grip()!.dispatchEvent(pointer('pointerdown'));
+            window.dispatchEvent(pointer('pointermove', { clientX: 940 }));
+        });
+        // Absolute, not a delta: 1400 - 940.
+        expect(onWidth).toHaveBeenLastCalledWith(460);
+
+        // Dragged past the far bound, it reports the bound rather than a runaway number.
+        await act(async () => {
+            window.dispatchEvent(pointer('pointermove', { clientX: 10 }));
+        });
+        expect(onWidth).toHaveBeenLastCalledWith(AU_INSPECT_MAX);
+    });
+
+    it('stops reporting once the button is no longer down', async () => {
+        const { onWidth } = await show();
+        (window as unknown as { innerWidth: number }).innerWidth = 1400;
+        await act(async () => {
+            grip()!.dispatchEvent(pointer('pointerdown'));
+            window.dispatchEvent(pointer('pointerup'));
+            window.dispatchEvent(pointer('pointermove', { clientX: 940 }));
+        });
+        expect(onWidth).not.toHaveBeenCalled();
+    });
+
+    /**
+     * A release outside the window never delivers `pointerup`, so the button state on the next
+     * move is the only thing that can end the gesture — the same guard the canvas's own pan keeps,
+     * for the same reason. Without it the panel follows the pointer forever after one drag.
+     */
+    it('ends the drag on a move that arrives with no button held', async () => {
+        const { onWidth } = await show();
+        (window as unknown as { innerWidth: number }).innerWidth = 1400;
+        await act(async () => {
+            grip()!.dispatchEvent(pointer('pointerdown'));
+            window.dispatchEvent(pointer('pointermove', { clientX: 940, buttons: 0 }));
+            window.dispatchEvent(pointer('pointermove', { clientX: 900 }));
+        });
+        expect(onWidth).not.toHaveBeenCalled();
+    });
+
+    it('resizes by keyboard, left widening the way the drag does', async () => {
+        const { onWidth } = await show({ width: 400 });
+        await act(async () => {
+            grip()!.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowLeft', bubbles: true }));
+        });
+        expect(onWidth).toHaveBeenLastCalledWith(416);
+
+        await act(async () => {
+            grip()!.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }));
+        });
+        expect(onWidth).toHaveBeenLastCalledWith(384);
+    });
+
+    it('exposes the handle as a separator with its real range', async () => {
+        await show({ width: 420 });
+        expect(grip()!.getAttribute('role')).toBe('separator');
+        expect(grip()!.getAttribute('aria-valuenow')).toBe('420');
+        expect(grip()!.getAttribute('aria-valuemin')).toBe(String(AU_INSPECT_MIN));
+        expect(grip()!.getAttribute('aria-valuemax')).toBe(String(AU_INSPECT_MAX));
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auNodeDelete.test.tsx b/src/renderer/components/Automation/__tests__/auNodeDelete.test.tsx
new file mode 100644
index 00000000..105fe975
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auNodeDelete.test.tsx
@@ -0,0 +1,147 @@
+/**
+ * @jest-environment jsdom
+ *
+ * **The two gestures that take a card off the canvas** — Delete on a focused card, and the
+ * right-click menu.
+ *
+ * Asserted through `AuCanvas` rather than on `AuNode` alone, because the reducer is already pinned
+ * by `automationRemoveStep.test.ts` and what is left to go wrong is the wiring between them. A card
+ * that handles Delete perfectly and is handed an `onDelete` that never reaches the editor's
+ * `removeStep` is a feature that does nothing, and neither end's own test can see it.
+ *
+ * The MENU's label is asserted as well as its effect. `removalGroup` answers with three steps when
+ * one of the reading cards is aimed at, so an item reading *Delete “Read a value”* over a gesture
+ * that removes three would be the menu misdescribing what pressing it does — and a menu is read
+ * before it is pressed.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AuCanvas } from '../AuCanvas';
+import { draftFromRule, draftReducer } from '../automationDraft';
+import type { AutomationDraft } from '../automationDraft';
+import { faceFor, stateFor } from '../automationDerive';
+import type { NodeFace, NodeState } from '../automationDerive';
+import { problems } from '../automationValidation';
+import { STEP_ORDER } from '../automationSteps';
+import type { StepKind } from '../automationSteps';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+
+const NOW = 1_700_000_000_000;
+
+describe('AuCanvas — removing a card', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+    let removed: StepKind[];
+    let draft: AutomationDraft;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(async () => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+        removed = [];
+
+        // Built from the palette rather than from a template, so every card this file aims at is
+        // certainly on the canvas — templates carry whichever steps they happen to need.
+        draft = (['monitor', 'parse', 'cond', 'timer', 'action'] as StepKind[]).reduce(
+            (d, step) => draftReducer(d, { type: 'addStep', step }),
+            draftFromRule(blankDraft(), 'blank'),
+        );
+        const rule = draft.rule;
+        const ctx = { now: NOW, problems: problems(rule) };
+        const faces = {} as Record<StepKind, NodeFace>;
+        const states = {} as Record<StepKind, NodeState>;
+        for (const step of STEP_ORDER) {
+            faces[step] = faceFor(rule, step, ctx);
+            states[step] = stateFor(rule, step, ctx);
+        }
+
+        await act(async () => {
+            root.render(
+                <AuCanvas
+                    draft={draft}
+                    faces={faces}
+                    states={states}
+                    chips={{}}
+                    onSelect={() => {}}
+                    onMove={() => {}}
+                    onConnect={() => {}}
+                    onDisconnect={() => {}}
+                    onRemove={(step) => { removed.push(step); }}
+                    onRefuse={() => {}}
+                    onViewportReady={() => {}}
+                />,
+            );
+        });
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    const card = (step: StepKind) =>
+        container.querySelector<HTMLElement>(`.au-node[data-step="${step}"]`)!;
+
+    /** Open the card's menu the way a pointer does, and let `CanvasMenu`'s rAF gate settle. */
+    async function rightClick(step: StepKind) {
+        await act(async () => {
+            card(step).dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, clientX: 40, clientY: 60 }));
+        });
+        return document.body.querySelector<HTMLElement>('.au-nodemenu')!;
+    }
+
+    it('removes the card the Delete key was pressed on', async () => {
+        await act(async () => {
+            card('timer').dispatchEvent(new KeyboardEvent('keydown', { key: 'Delete', bubbles: true }));
+        });
+        expect(removed).toEqual(['timer']);
+    });
+
+    /**
+     * The key is aimed by FOCUS, which is the whole reason the card is a tab stop. Without it the
+     * gesture would have to be a window listener reading the selection, and the selection outlives
+     * the pointer — a Delete typed into the inspector's message box would then have to be told
+     * apart from a Delete meaning the card.
+     */
+    it('makes the card focusable, so the key has something to be aimed at', () => {
+        expect(card('timer').tabIndex).toBe(0);
+    });
+
+    it('leaves other keys alone', async () => {
+        await act(async () => {
+            card('timer').dispatchEvent(new KeyboardEvent('keydown', { key: 'x', bubbles: true }));
+            card('timer').dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        });
+        expect(removed).toEqual([]);
+    });
+
+    it('opens a menu on right-click and removes on the item', async () => {
+        const menu = await rightClick('timer');
+        expect(menu).not.toBeNull();
+
+        const item = menu.querySelector<HTMLElement>('.context-menu-item')!;
+        expect(item.textContent).toContain('Delete “Wait”');
+
+        await act(async () => { item.click(); });
+        expect(removed).toEqual(['timer']);
+        expect(document.body.querySelector('.au-nodemenu')).toBeNull();
+    });
+
+    it('names every card a reading-step removal will take', async () => {
+        const menu = await rightClick('parse');
+        const item = menu.querySelector<HTMLElement>('.context-menu-item')!;
+        // Not `Delete “Read a value”`: pressing this takes all three.
+        expect(item.textContent).toContain('Delete Watch output, Read a value and Compare it');
+    });
+
+    it('portals the menu out of the canvas, which transforms and clips its own children', async () => {
+        await rightClick('timer');
+        expect(container.querySelector('.au-nodemenu')).toBeNull();
+        expect(document.body.querySelector('.au-nodemenu')).not.toBeNull();
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auNodeTwoLineValue.test.tsx b/src/renderer/components/Automation/__tests__/auNodeTwoLineValue.test.tsx
index b8251d97..992c9c02 100644
--- a/src/renderer/components/Automation/__tests__/auNodeTwoLineValue.test.tsx
+++ b/src/renderer/components/Automation/__tests__/auNodeTwoLineValue.test.tsx
@@ -234,6 +234,7 @@ describe('a node value wraps to two lines instead of ellipsing at one', () => {
                         onMove={() => {}}
                         onConnect={() => {}}
                         onDisconnect={() => {}}
+                        onRemove={() => {}}
                         onRefuse={() => {}}
                         onViewportReady={() => {}}
                     />,
diff --git a/src/renderer/components/Automation/__tests__/auSelect.test.tsx b/src/renderer/components/Automation/__tests__/auSelect.test.tsx
new file mode 100644
index 00000000..ab30d2ec
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auSelect.test.tsx
@@ -0,0 +1,156 @@
+/**
+ * @jest-environment jsdom
+ *
+ * `AuSelect` exists for one reason: a native `<select>` near the bottom of the window opened
+ * downward and WebView2 clipped the list at the window edge, with no scrollbar and no way to reach
+ * the hidden rows. So the behaviour worth pinning is the placement, and jsdom has no layout engine
+ * — the trigger's rect is stubbed, which is the only way to ask the question at all.
+ *
+ * The two placement cases are asserted as a PAIR. "It sets `bottom` when it flips" is satisfied by a
+ * component that always flips, which would move the same bug to the top of the window.
+ */
+import React from 'react';
+import { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import { AuSelect } from '../AuSelect';
+
+const OPTIONS = [
+    { value: 'a', label: 'Every 10 seconds' },
+    { value: 'b', label: 'Every 30 seconds' },
+    { value: 'c', label: 'Every minute' },
+];
+
+describe('AuSelect', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+        jest.restoreAllMocks();
+    });
+
+    /** Put the trigger at `top`, with the window 768 tall (jsdom's default). */
+    async function renderAt(top: number, onChange = jest.fn()) {
+        await act(async () => {
+            root.render(
+                <AuSelect value="a" options={OPTIONS} ariaLabel="How often to check" onChange={onChange} />,
+            );
+        });
+        const trigger = container.querySelector<HTMLButtonElement>('[aria-label="How often to check"]')!;
+        jest.spyOn(trigger, 'getBoundingClientRect').mockReturnValue({
+            top, bottom: top + 30, left: 40, right: 240, width: 200, height: 30, x: 40, y: top,
+            toJSON: () => ({}),
+        } as DOMRect);
+        await act(async () => { trigger.click(); });
+        return { trigger, onChange };
+    }
+
+    const menu = () => document.body.querySelector<HTMLElement>('.au-selmenu')!;
+
+    it('opens downward when there is room below', async () => {
+        await renderAt(100);
+        expect(menu().style.top).toBe('134px');
+        expect(menu().style.bottom).toBe('');
+    });
+
+    it('flips up when the trigger is against the bottom of the window', async () => {
+        // 740 of 768: 28px below the trigger's bottom, far less than a usable list.
+        await renderAt(710);
+        expect(menu().style.bottom).toBe('62px');
+        expect(menu().style.top).toBe('');
+    });
+
+    /**
+     * Reported: `does not equal` opened as `does not e…`. The list carried `width: trigger.width`,
+     * which is the one width guaranteed to be too small — an option longer than the closed control
+     * is exactly why the list is being opened.
+     *
+     * The assertion is on the BOUNDS rather than on a measured pixel, because jsdom lays nothing
+     * out and a rendered width would be 0 either way. A `width` is what makes text clip, so its
+     * absence is the property: `minWidth` keeps the list from being narrower than its trigger and
+     * `maxWidth` keeps it inside the window, and between them the box shrink-wraps its content.
+     */
+    it('is never narrower than its trigger and never fixed to it', async () => {
+        await renderAt(100);
+        expect(menu().style.minWidth).toBe('200px');
+        expect(menu().style.width).toBe('');
+        // 1024 (jsdom) - 40 left - 8 edge. Room the portalled list may grow into, which for these
+        // selects is the whole of the inspector column they sit at the right of.
+        expect(menu().style.maxWidth).toBe('976px');
+    });
+
+    /** A trigger wider than the room beside it still gets its own width, never a negative bound. */
+    it('never bounds the list below the width of its own trigger', async () => {
+        await act(async () => {
+            root.render(
+                <AuSelect value="a" options={OPTIONS} ariaLabel="How often to check" onChange={jest.fn()} />,
+            );
+        });
+        const trigger = container.querySelector<HTMLButtonElement>('[aria-label="How often to check"]')!;
+        jest.spyOn(trigger, 'getBoundingClientRect').mockReturnValue({
+            top: 100, bottom: 130, left: 1000, right: 1200, width: 200, height: 30, x: 1000, y: 100,
+            toJSON: () => ({}),
+        } as DOMRect);
+        await act(async () => { trigger.click(); });
+        expect(menu().style.maxWidth).toBe('200px');
+        expect(menu().style.minWidth).toBe('200px');
+    });
+
+    it('escapes the clipping ancestors by portalling out of its own tree', async () => {
+        await renderAt(100);
+        expect(container.querySelector('.au-selmenu')).toBeNull();
+        expect(document.body.querySelector('.au-selmenu')).not.toBeNull();
+    });
+
+    it('commits the row that was pressed', async () => {
+        const { onChange } = await renderAt(100);
+        const row = menu().querySelector<HTMLElement>('[data-value="c"]')!;
+        await act(async () => {
+            row.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+        expect(onChange).toHaveBeenCalledWith('c');
+    });
+
+    it('refuses a disabled row, by pointer and by keyboard alike', async () => {
+        const onChange = jest.fn();
+        await act(async () => {
+            root.render(
+                <AuSelect
+                    value=""
+                    options={[
+                        { value: '', label: 'choose a terminal…' },
+                        { value: 'gone', label: 'tm-1 (not open)', disabled: true },
+                    ]}
+                    ariaLabel="Terminal to test against"
+                    onChange={onChange}
+                />,
+            );
+        });
+        const trigger = container.querySelector<HTMLButtonElement>('[aria-label="Terminal to test against"]')!;
+        await act(async () => { trigger.click(); });
+
+        const dead = document.body.querySelector<HTMLElement>('[data-value="gone"]')!;
+        await act(async () => {
+            dead.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+        expect(onChange).not.toHaveBeenCalled();
+
+        // ArrowDown must not land on it either, or Enter would choose what the pointer cannot.
+        await act(async () => {
+            trigger.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }));
+            trigger.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        });
+        expect(onChange).not.toHaveBeenCalledWith('gone');
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auStepAccent.test.ts b/src/renderer/components/Automation/__tests__/auStepAccent.test.ts
new file mode 100644
index 00000000..1855873a
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/auStepAccent.test.ts
@@ -0,0 +1,51 @@
+/**
+ * Every step kind must carry an accent colour, on all three surfaces that draw its glyph.
+ *
+ * `webhook` shipped without one. The palette, the canvas node and the inspector head each render
+ * `STEP_GLYPHS[step]` inside a `.au-palico` / `.au-nico` / `.au-gi`, and the five original kinds got
+ * their colour from a three-selector group in `AutomationEditor.css`. The sixth kind was added with
+ * no group at all, so its glyph inherited the body colour and rendered near-black on the dark rail —
+ * an icon that looked switched off.
+ *
+ * Asserted as a TABLE over `STEP_ORDER` rather than as one case for `webhook`, because the defect
+ * was never really about webhooks: it is that the colour table and the step list could disagree
+ * silently. A seventh kind added later must fail here, not slip past.
+ *
+ * Read out of the stylesheet, in the manner of `auNodeTwoLineValue.test.tsx`: jsdom has no cascade,
+ * so the file itself is the only place this contract can be checked.
+ */
+import fs from 'fs';
+import path from 'path';
+import { STEP_ORDER } from '../automationSteps';
+
+const CSS = fs.readFileSync(path.join(__dirname, '..', 'AutomationEditor.css'), 'utf8');
+
+/** The declarations of the group whose LAST selector is `selector`. */
+function groupBody(selector: string): string {
+    const at = CSS.indexOf(`${selector} {`);
+    expect(at).toBeGreaterThanOrEqual(0);
+    const open = CSS.indexOf('{', at);
+    return CSS.slice(open + 1, CSS.indexOf('}', open));
+}
+
+describe('step accent colours', () => {
+    it.each(STEP_ORDER)('%s is drawn on all three surfaces by one group', (step) => {
+        // The three selectors share one body, so a kind cannot be coloured in the palette while
+        // staying invisible on the canvas — which is the half-fix this test exists to refuse.
+        expect(CSS).toContain(`.au-editor .au-palitem.${step} .au-palico,`);
+        expect(CSS).toContain(`.au-editor .au-node.${step} .au-nico,`);
+
+        const body = groupBody(`.au-editor .au-gi.${step}`);
+        expect(body).toMatch(/color:\s*#[0-9a-f]{6}/i);
+        expect(body).toMatch(/background:\s*rgba\(/i);
+    });
+
+    it('gives every kind a colour of its own, so two steps never read as the same', () => {
+        const colours = STEP_ORDER.map((step) => {
+            const found = /color:\s*(#[0-9a-f]{6})/i.exec(groupBody(`.au-editor .au-gi.${step}`));
+            if (!found) throw new Error(`${step} has no accent colour`);
+            return found[1].toLowerCase();
+        });
+        expect(new Set(colours).size).toBe(STEP_ORDER.length);
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/auWireRouting.test.tsx b/src/renderer/components/Automation/__tests__/auWireRouting.test.tsx
index a68bf194..f11fdee6 100644
--- a/src/renderer/components/Automation/__tests__/auWireRouting.test.tsx
+++ b/src/renderer/components/Automation/__tests__/auWireRouting.test.tsx
@@ -68,6 +68,7 @@ describe('AuCanvas — wire routing follows the cards', () => {
                     onMove={() => {}}
                     onConnect={() => {}}
                     onDisconnect={() => {}}
+                    onRemove={() => {}}
                     onRefuse={() => {}}
                     onViewportReady={() => {}}
                 />,
@@ -140,6 +141,7 @@ describe('AuCanvas — wire routing follows the cards', () => {
                     onMove={() => {}}
                     onConnect={() => {}}
                     onDisconnect={() => {}}
+                    onRemove={() => {}}
                     onRefuse={() => {}}
                     onViewportReady={() => {}}
                 />,
diff --git a/src/renderer/components/Automation/__tests__/automationDerive.test.ts b/src/renderer/components/Automation/__tests__/automationDerive.test.ts
index 7833c066..e70b48b0 100644
--- a/src/renderer/components/Automation/__tests__/automationDerive.test.ts
+++ b/src/renderer/components/Automation/__tests__/automationDerive.test.ts
@@ -1,5 +1,5 @@
 /**
- * §10.20 — the six-template table, asserted through **both renderers**.
+ * §10.20 — the ten-template table, asserted through **both renderers**.
  *
  * **The direct port of the test that caught the mockup's worst rev-1 bug.** Rev 1 had four
  * hard-coded inspector panels, so five of six templates showed one rule on the canvas and a
@@ -60,19 +60,23 @@ describe('automationDerive — each template carries its OWN values, through bot
             const { parse, cond, action } = rule.graph;
 
             // --- the pattern ---------------------------------------------------------------------
-            const shown = displayedPattern(parse);
-            expect(faceText(rule, 'parse')).toContain(shown);
-            expect(panelText(rule, 'parse')).toContain(shown);
+            if (parse) {
+                const shown = displayedPattern(parse);
+                expect(faceText(rule, 'parse')).toContain(shown);
+                expect(panelText(rule, 'parse')).toContain(shown);
+            }
 
             // --- the threshold -------------------------------------------------------------------
-            if (cond.kind === 'number' && cond.threshold !== null && cond.threshold !== undefined) {
+            if (cond?.kind === 'number' && cond.threshold !== null && cond.threshold !== undefined) {
                 expect(faceText(rule, 'cond')).toContain(String(cond.threshold));
                 expect(panelText(rule, 'cond')).toContain(String(cond.threshold));
             }
 
             // --- the message ---------------------------------------------------------------------
-            expect(faceText(rule, 'action')).toContain(action.message);
-            expect(panelText(rule, 'action')).toContain(action.message);
+            if (action) {
+                expect(faceText(rule, 'action')).toContain(action.message);
+                expect(panelText(rule, 'action')).toContain(action.message);
+            }
         },
     );
 
@@ -505,12 +509,29 @@ describe('automationDerive — missing values are marked, not blank', () => {
 });
 
 describe('automationDerive — the palette summary', () => {
+    it('describes a webhook-only rule as a post, never a terminal send', () => {
+        const { action: _action, ...graph } = draftFromTemplate(AUTOMATION_TEMPLATES[0]).graph;
+        const rule = {
+            ...draftFromTemplate(AUTOMATION_TEMPLATES[0]),
+            graph: {
+                ...graph,
+                webhook: { provider: 'discord' as const, url: 'https://secret.invalid/hook', body: 'done' },
+            },
+        };
+
+        expect(ruleSummary(rule)).toBe(
+            'Watching command contains "claude" · when the value in ctx:(\\d+)% is greater than 25 · post discord',
+        );
+        expect(describeRule(rule).verbSend).toBe('post');
+    });
+
     it('describes each template differently, from the same values', () => {
         const summaries = AUTOMATION_TEMPLATES.map((t) => ruleSummary(draftFromTemplate(t)));
-        expect(new Set(summaries).size).toBe(AUTOMATION_TEMPLATES.length);
+        expect(new Set(summaries).size).toBe(AUTOMATION_TEMPLATES.length - 1);
         // And it is the rule's own message, not a label stored beside it.
         for (const template of AUTOMATION_TEMPLATES) {
-            expect(ruleSummary(draftFromTemplate(template))).toContain(template.rule.graph.action.message);
+            const action = template.rule.graph.action;
+            if (action) expect(ruleSummary(draftFromTemplate(template))).toContain(action.message);
         }
     });
 
diff --git a/src/renderer/components/Automation/__tests__/automationEditorLifecycle.test.tsx b/src/renderer/components/Automation/__tests__/automationEditorLifecycle.test.tsx
index e5113d59..f773e040 100644
--- a/src/renderer/components/Automation/__tests__/automationEditorLifecycle.test.tsx
+++ b/src/renderer/components/Automation/__tests__/automationEditorLifecycle.test.tsx
@@ -448,6 +448,30 @@ describe('the editor, mounted', () => {
         }
     });
 
+    it('asks the roster for the draft exception criterion, not the saved rule alone', async () => {
+        const api = await openEditorOn(rule({ criterion: 'allTerminals' }));
+        const exception = editor()!.querySelector<HTMLButtonElement>(
+            '[aria-label="What the exception must match"]',
+        )!;
+
+        // `AuSelect`, not a `<select>`: its list portals to `body` and commits on `mousedown`, so
+        // the row is opened and clicked rather than having a value assigned to it.
+        await act(async () => { exception.click(); });
+        const row = document.body.querySelector<HTMLElement>(
+            '.au-selmenu[aria-label="What the exception must match"] [data-value="commandContains"]',
+        )!;
+        await act(async () => {
+            row.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+        await settle();
+
+        expect(api.listWatchableTerminals.mock.calls.at(-1)).toEqual([
+            'au-1',
+            null,
+            ['allTerminals', 'commandContains'],
+        ]);
+    });
+
     /**
      * **A save that visibly does nothing, on the most common path into this editor.**
      *
@@ -544,4 +568,43 @@ describe('the editor, mounted', () => {
             clearSpy.mockRestore();
         }
     });
+
+    /**
+     * **Collapsing the settings panel must not be able to strand a selection.**
+     *
+     * The panel holds the only editor for whichever step is selected, so a click on a card while it
+     * is hidden would select something the user can neither see nor change. That is the half of the
+     * collapse feature that cannot live in `AuInspectorDock` — the dock knows nothing about
+     * selection — and it is why collapsed is a rail with a reopen button rather than a zero-width
+     * column: two independent ways back, one automatic and one deliberate.
+     */
+    it('opens the settings panel again when a card is clicked', async () => {
+        await openEditorOn(rule());
+
+        const hide = document.querySelector<HTMLButtonElement>('.au-icollapse')!;
+        await act(async () => hide.click());
+        expect(document.querySelector('.au-idock.collapsed')).not.toBeNull();
+        expect(document.querySelector('.au-inspect')).toBeNull();
+
+        await selectStep('parse');
+        expect(document.querySelector('.au-idock.collapsed')).toBeNull();
+        expect(document.querySelector('.au-inspect')).not.toBeNull();
+    });
+
+    /**
+     * ...but clicking the BACKGROUND deselects, and re-opening the panel to announce that nothing
+     * is selected is the opposite of what that click asked for.
+     */
+    it('leaves the panel collapsed when the click deselects', async () => {
+        await openEditorOn(rule());
+
+        await act(async () => document.querySelector<HTMLButtonElement>('.au-icollapse')!.click());
+        await act(async () => {
+            document.querySelector<HTMLElement>('.au-canvas')!.dispatchEvent(
+                new MouseEvent('pointerdown', { bubbles: true, buttons: 1 }),
+            );
+        });
+
+        expect(document.querySelector('.au-idock.collapsed')).not.toBeNull();
+    });
 });
diff --git a/src/renderer/components/Automation/__tests__/automationExclusions.test.tsx b/src/renderer/components/Automation/__tests__/automationExclusions.test.tsx
new file mode 100644
index 00000000..f9f39316
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/automationExclusions.test.tsx
@@ -0,0 +1,178 @@
+/**
+ * @jest-environment jsdom
+ *
+ * The rule-mode exclusions panel consumes the backend preview rather than recreating targeting in
+ * the renderer. The id sets below are Task 3's `resolve_target_sets` fixture: counts alone would
+ * also pass if the editor removed tm-c while the engine removed tm-b.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AuInspector } from '../AuInspector';
+import { draftFromRule } from '../automationDraft';
+import { problems } from '../automationValidation';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+import type {
+    AutomationRule,
+    AutomationTargetPreview,
+    WatchableTerminal,
+} from '../../../types/electron';
+
+const TERMINALS: WatchableTerminal[] = [
+    { terminalId: 'tm-a', label: 'worker a', commandLines: ['node worker-a'], alive: true },
+    { terminalId: 'tm-b', label: 'worker b', commandLines: ['node worker-b'], alive: true },
+    { terminalId: 'tm-c', label: 'worker c', commandLines: ['node worker-c'], alive: true },
+];
+
+function rule(over: Partial<AutomationRule> = {}): AutomationRule {
+    const blank = blankDraft();
+    return {
+        ...blank,
+        id: 'au-exclusions',
+        name: 'Node workers',
+        criterion: 'commandContains',
+        criterionValue: 'node',
+        graph: {
+            ...blank.graph,
+            parse: { preset: 'custom', literal: null, find: 'ready', keep: 'whole' },
+            action: { ...blank.graph.action, message: 'continue' },
+        },
+        ...over,
+    };
+}
+
+interface Api {
+    previewAutomationTargets: jest.Mock;
+}
+
+function installPreview(preview: AutomationTargetPreview): Api {
+    const api: Api = { previewAutomationTargets: jest.fn(() => Promise.resolve(preview)) };
+    (window as unknown as { electronAPI: Api }).electronAPI = api;
+    return api;
+}
+
+describe('the exclusions panel', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+        delete (window as unknown as { electronAPI?: unknown }).electronAPI;
+    });
+
+    async function show(next: AutomationRule) {
+        const draft = { ...draftFromRule(next), selected: 'monitor' as const };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={problems(next)}
+                    now={1_700_000_000_000}
+                    terminals={TERMINALS}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={() => {}}
+                />,
+            );
+        });
+        await act(async () => {
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+    }
+
+    const exclusionLabel = () => [...container.querySelectorAll('.au-flabel')]
+        .find((label) => label.textContent === 'Except these');
+
+    it('shows the exclusions panel only in rule mode', async () => {
+        installPreview({ matched: [], excluded: [], watching: [] });
+        await show(rule());
+        expect(exclusionLabel()).toBeDefined();
+        expect(container.querySelector('[aria-label="What the exception must match"]')).not.toBeNull();
+
+        await show(rule({ targetMode: 'pinned', targetIds: ['tm-a'] }));
+        expect(exclusionLabel()).toBeUndefined();
+        expect(container.querySelector('[aria-label="What the exception must match"]')).toBeNull();
+    });
+
+    it('renders matched, excluded and watching as three separate numbers', async () => {
+        installPreview({
+            matched: ['tm-a', 'tm-b', 'tm-c', 'tm-d'],
+            excluded: ['tm-b', 'tm-d'],
+            watching: ['tm-a', 'tm-c'],
+        });
+        await show(rule({ excludedIds: ['tm-b'] }));
+
+        const count = container.querySelector('.au-termcount');
+        expect(count?.textContent).toBe('Matching 4 - excluded 2 = watching 2');
+        const numbers = count === null ? [] : [...count.querySelectorAll('.au-n')];
+        expect(numbers.map((n) => n.textContent)).toEqual(['4', '2', '2']);
+    });
+
+    it('advises when the shared preview resolves no terminals to watch', async () => {
+        installPreview({ matched: ['tm-a'], excluded: ['tm-a'], watching: [] });
+        await show(rule({ excludedIds: ['tm-a'] }));
+
+        expect(container.querySelector('.au-termcount')?.textContent)
+            .toBe('Matching 1 - excluded 1 = watching 0 — nothing is being watched');
+    });
+
+    it('does not offer exclusions on a hand-picked target set', async () => {
+        await show(rule({
+            targetMode: 'pinned',
+            targetIds: ['tm-a'],
+            excludedIds: ['tm-b'],
+            excludeCriterion: 'commandContains',
+            excludeCriterionValue: 'node',
+        }));
+
+        expect(exclusionLabel()).toBeUndefined();
+        expect(container.textContent).not.toContain('anything matching this exception');
+        expect(container.querySelector('[aria-label="What the exception must match"]')).toBeNull();
+    });
+
+    it('previews exactly the ids the engine would watch', async () => {
+        const enginePreview: AutomationTargetPreview = {
+            matched: ['tm-a', 'tm-b', 'tm-c'],
+            excluded: ['tm-b'],
+            watching: ['tm-a', 'tm-c'],
+        };
+        const api = installPreview(enginePreview);
+        await show(rule({ excludedIds: ['tm-b'] }));
+
+        expect(api.previewAutomationTargets).toHaveBeenCalledWith(
+            expect.objectContaining({
+                targetMode: 'rule',
+                criterion: 'commandContains',
+                criterionValue: 'node',
+                excludedIds: ['tm-b'],
+            }),
+            TERMINALS,
+        );
+
+        // The ID sets are the oracle. These assertions intentionally precede the count assertion:
+        // excluding tm-c instead of tm-b would still produce 3 - 1 = 2.
+        const preview = await api.previewAutomationTargets.mock.results[0].value;
+        expect(preview.matched).toEqual(['tm-a', 'tm-b', 'tm-c']);
+        expect(preview.excluded).toEqual(['tm-b']);
+        expect(preview.watching).toEqual(['tm-a', 'tm-c']);
+
+        expect(container.querySelector('.au-termcount')?.textContent)
+            .toBe('Matching 3 - excluded 1 = watching 2');
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/automationPanelsRender.test.tsx b/src/renderer/components/Automation/__tests__/automationPanelsRender.test.tsx
index dee26cc5..12c0ff96 100644
--- a/src/renderer/components/Automation/__tests__/automationPanelsRender.test.tsx
+++ b/src/renderer/components/Automation/__tests__/automationPanelsRender.test.tsx
@@ -102,21 +102,27 @@ describe('the inspector panels — rendered, per template', () => {
 
             // The pattern is a control binding — the field's `value` — and the panel's prose about
             // it is the paraphrase, which has its own tests below.
-            await show(rule, 'parse');
-            expect(fields()).toContain(displayedPattern(parse));
+            if (parse) {
+                await show(rule, 'parse');
+                expect(fields()).toContain(displayedPattern(parse));
+            }
 
-            const condText = await show(rule, 'cond');
-            if (cond.kind === 'number' && cond.threshold !== null && cond.threshold !== undefined) {
-                expect(`${condText} ${fields()}`).toContain(String(cond.threshold));
+            if (cond) {
+                const condText = await show(rule, 'cond');
+                if (cond.kind === 'number' && cond.threshold !== null && cond.threshold !== undefined) {
+                    expect(`${condText} ${fields()}`).toContain(String(cond.threshold));
+                }
             }
 
             // **The DISPLAY, not the field.** Asserting over the two together is what let the first
             // draft of this test survive the very mutation it was written for: the preview span was
             // replaced with a hard-coded string and the textarea still carried the right value, so
             // `contains` found it anyway. A displayed value has to be read where it is displayed.
-            await show(rule, 'action');
-            expect(container.querySelector('.au-cap')?.textContent).toBe(action.message);
-            expect(fields()).toContain(action.message);
+            if (action) {
+                await show(rule, 'action');
+                expect(container.querySelector('.au-cap')?.textContent).toBe(action.message);
+                expect(fields()).toContain(action.message);
+            }
         },
     );
 
@@ -139,24 +145,29 @@ describe('the inspector panels — rendered, per template', () => {
             // that chrome as if it were a leaked value; reading the same `.au-cap` span the
             // per-template loop above reads is the precise oracle for "the value this panel is
             // SHOWING", exactly as that loop's own comment already argues.
-            await show(rule, 'action');
-            // Assert the node EXISTS before reading it — `?? ''` here made every `not.toContain`
-            // below pass vacuously against an empty string whenever the preview was blocked and
-            // `.au-cap` was absent from the DOM altogether.
-            const capNode = container.querySelector('.au-cap');
-            expect(capNode).not.toBeNull();
-            const shownMessage = capNode!.textContent ?? '';
-            for (const other of others) {
-                if (other.graph.action.message === rule.graph.action.message) continue;
-                expect(shownMessage).not.toContain(other.graph.action.message);
+            if (rule.graph.action) {
+                await show(rule, 'action');
+                // Assert the node EXISTS before reading it — `?? ''` here made every `not.toContain`
+                // below pass vacuously against an empty string whenever the preview was blocked and
+                // `.au-cap` was absent from the DOM altogether.
+                const capNode = container.querySelector('.au-cap');
+                expect(capNode).not.toBeNull();
+                const shownMessage = capNode!.textContent ?? '';
+                for (const other of others) {
+                    const otherAction = other.graph.action;
+                    if (!otherAction || otherAction.message === rule.graph.action.message) continue;
+                    expect(shownMessage).not.toContain(otherAction.message);
+                }
             }
 
-            await show(rule, 'parse');
-            const shown = fields();
-            for (const other of others) {
-                const pattern = displayedPattern(other.graph.parse);
-                if (pattern === displayedPattern(rule.graph.parse)) continue;
-                expect(shown).not.toContain(pattern);
+            if (rule.graph.parse) {
+                await show(rule, 'parse');
+                const shown = fields();
+                for (const other of others) {
+                    const otherParse = other.graph.parse;
+                    if (!otherParse || displayedPattern(otherParse) === displayedPattern(rule.graph.parse)) continue;
+                    expect(shown).not.toContain(displayedPattern(otherParse));
+                }
             }
         }
     });
@@ -183,6 +194,8 @@ describe('the inspector panels — rendered, per template', () => {
             // sentence about a missing step both surfaces state in prose.
             timer: ['when'],
             action: ['message', 'send'],
+            // Task 11 adds the canvas card. Its editable inspector is deliberately Task 12.
+            webhook: [],
         };
         const rule = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
         for (const step of STEP_ORDER) {
@@ -479,6 +492,11 @@ describe('ActionPanel — the substitute checkbox, token chips, and live preview
         expect(dead).toEqual(['$2']);
     });
 
+    /**
+     * The patch carries `substitute: true` alongside the text, and that is the fix for a reported
+     * defect rather than an incidental extra field: a chip that inserted a reference into a message
+     * sent verbatim produced literal `$1` on the wire. See `tokenSubstitutionAffordance.test.tsx`.
+     */
     it('clicking a chip inserts it into the message at the cursor', async () => {
         const dispatch = jest.fn();
         const { messageInput } = await renderAction({ message: 'fix ', substitute: false }, { dispatch });
@@ -488,7 +506,10 @@ describe('ActionPanel — the substitute checkbox, token chips, and live preview
         const chip = [...container.querySelectorAll('.au-tokens .au-token')]
             .find((el) => el.textContent === '$1') as HTMLButtonElement;
         await act(async () => chip.click());
-        expect(dispatch).toHaveBeenCalledWith({ type: 'action', patch: { message: 'fix $1' } });
+        expect(dispatch).toHaveBeenCalledWith({
+            type: 'action',
+            patch: { message: 'fix $1', substitute: true },
+        });
     });
 
     it('uses a braced token for group 10 and the next dead boundary, while leaving single digits bare', async () => {
@@ -739,16 +760,34 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
         expect(group!.getAttribute('aria-label')).toMatch(/combine/i);
     });
 
+    /**
+     * `AuSelect` replaced the panels' `<select>`s (its list portals to `body` so the window edge
+     * cannot clip it), so a dropdown is opened before its rows exist and each row carries its key in
+     * `data-value` rather than in an `<option>`'s `value`.
+     */
+    const openSelect = async (label: string) => {
+        const trigger = container.querySelector<HTMLButtonElement>(`[aria-label="${label}"]`)!;
+        // ENSURE open, never toggle: the trigger flips state, and a re-render inside one test keeps
+        // the component instance, so a second blind click closed the list and read back no rows.
+        if (trigger.getAttribute('aria-expanded') === 'true') return;
+        await act(async () => { trigger.click(); });
+    };
+    const rowsOf = (label: string) => [...document.body.querySelectorAll<HTMLElement>(
+        `.au-selmenu[aria-label="${label}"] .au-selopt`,
+    )];
+    const pickRow = async (label: string, match: RegExp) => {
+        const row = rowsOf(label).find((el) => match.test(el.textContent ?? ''))!;
+        expect(row).toBeTruthy();
+        await act(async () => {
+            row.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+        });
+    };
+
     it('clears the operand when a row switches between text and number', async () => {
         const dispatch = jest.fn();
         await renderCond([clause('$1', 'is', '529')], { dispatch });
-        const opSelect = container.querySelector<HTMLSelectElement>('[aria-label="How to compare"]')!;
-        const overOption = [...opSelect.options].find((o) => /is over/i.test(o.textContent ?? ''))!;
-        expect(overOption).toBeTruthy();
-        await act(async () => {
-            opSelect.value = overOption.value;
-            opSelect.dispatchEvent(new Event('change', { bubbles: true }));
-        });
+        await openSelect('How to compare');
+        await pickRow('How to compare', /is over/i);
         expect(dispatch).toHaveBeenCalledTimes(1);
         const action = dispatch.mock.calls[0][0] as { type: string; clauses: AutomationClause[] };
         expect(action.type).toBe('clauses');
@@ -778,8 +817,8 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
 
     it('offers only tokens the pattern actually produces', async () => {
         await renderCond([clause('$1', 'is', 'x')], { find: 'a(\\d+)b' });
-        const select = container.querySelector<HTMLSelectElement>('[aria-label="Which captured value"]')!;
-        const opts = [...select.options].map((o) => o.textContent ?? '');
+        await openSelect('Which captured value');
+        const opts = rowsOf('Which captured value').map((o) => o.textContent ?? '');
         expect(opts).toHaveLength(2);
         expect(opts[0]).toContain('$0');
         expect(opts[1]).toContain('$1');
@@ -797,8 +836,8 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
      */
     it('offers the pattern\'s named groups as well as its numbered ones', async () => {
         await renderCond([clause('$1', 'is', 'x')], { find: 'err (?<code>\\d+) (?<why>\\w+)' });
-        const select = container.querySelector<HTMLSelectElement>('[aria-label="Which captured value"]')!;
-        const opts = [...select.options].map((o) => o.textContent ?? '');
+        await openSelect('Which captured value');
+        const opts = rowsOf('Which captured value').map((o) => o.textContent ?? '');
         // Each option carries the value it holds in the live preview (§5.9), so `${why}` is never
         // picked blind — `sayPattern`'s own worked example for this pattern is `err 63 abc`.
         expect(opts).toEqual([
@@ -809,7 +848,7 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
             '${why} — "abc"',
         ]);
         // And the VALUES are the keys `sourceFromKey` round-trips, not the labels.
-        expect([...select.options].map((o) => o.value)).toEqual([
+        expect(rowsOf('Which captured value').map((o) => o.getAttribute('data-value'))).toEqual([
             'whole',
             'group:1',
             'group:2',
@@ -822,8 +861,9 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
         // The paired negative: an unconditional `${…}` row, or one built from a stale name set,
         // would satisfy the test above and break this.
         await renderCond([clause('$1', 'is', 'x')], { find: 'a(\\d+)b' });
-        const select = container.querySelector<HTMLSelectElement>('[aria-label="Which captured value"]')!;
-        expect([...select.options].map((o) => o.value)).toEqual(['whole', 'group:1']);
+        await openSelect('Which captured value');
+        expect(rowsOf('Which captured value').map((o) => o.getAttribute('data-value')))
+            .toEqual(['whole', 'group:1']);
     });
 
     /* ------------------------------------------------------ task 28: §5.9's other two bullets --- */
@@ -836,17 +876,15 @@ describe('CondPanel — the finds radio, the clause list, the join (mockup §06)
 
     it('shows what $0 holds, and keeps its words when there is nothing to show', async () => {
         await renderCond([clause('$1', 'is', 'x')], { find: 'ctx:(\\d+)%' });
-        const opts = [...container.querySelectorAll<HTMLOptionElement>(
-            '[aria-label="Which captured value"] option',
-        )].map((o) => o.textContent ?? '');
+        await openSelect('Which captured value');
+        const opts = rowsOf('Which captured value').map((o) => o.textContent ?? '');
         expect(opts).toEqual(['$0 — "ctx:63%"', '$1 — "63"']);
 
         // …and a pattern with no worked example to read falls back to the words, never to a blank
         // or an invented value.
         await renderCond([clause('$1', 'is', 'x')], { find: 'FAILED (\\d+) tests in (\\S+)' });
-        const bare = [...container.querySelectorAll<HTMLOptionElement>(
-            '[aria-label="Which captured value"] option',
-        )].map((o) => o.textContent ?? '');
+        await openSelect('Which captured value');
+        const bare = rowsOf('Which captured value').map((o) => o.textContent ?? '');
         expect(bare).toEqual(['$0 — the whole match', '$1', '$2']);
     });
 
diff --git a/src/renderer/components/Automation/__tests__/automationRemoveStep.test.ts b/src/renderer/components/Automation/__tests__/automationRemoveStep.test.ts
new file mode 100644
index 00000000..88c4854a
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/automationRemoveStep.test.ts
@@ -0,0 +1,170 @@
+/**
+ * **Taking a card off the canvas** — `removalGroup` and the reducer's `removeStep`.
+ *
+ * A removal is two things that must happen together: the card leaves `present`, and the step's
+ * field leaves the graph. Asserting only the first passes a reducer that hides a Wait while the
+ * engine goes on delaying every send, which is precisely the data consequence the old "there is no
+ * remove gesture" note was holding out for. Every case here therefore asks BOTH questions, and the
+ * write is checked through `ruleFromDraft` rather than off `draft.rule` — a step `graphAsWritten`
+ * happens to omit and a step that is really gone are the same picture on screen and different rows
+ * in the store.
+ *
+ * The wires are the third question and the one easiest to get wrong, because removal is not
+ * subtraction: dropping the wait does not leave the verdict dangling, it reconnects the verdict to
+ * the send the wait used to sit between.
+ */
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+import { draftFromRule, draftReducer, ruleFromDraft } from '../automationDraft';
+import type { AutomationDraft, DraftAction } from '../automationDraft';
+import { INPUT_STEPS, STEP_ORDER, removalGroup } from '../automationSteps';
+import type { StepKind } from '../automationSteps';
+import { blockingProblems, problems } from '../automationValidation';
+
+const run = (draft: AutomationDraft, actions: DraftAction[]): AutomationDraft =>
+    actions.reduce(draftReducer, draft);
+
+/** A canvas holding every step the palette can add, so a removal has something to disturb. */
+const fullCanvas = (): AutomationDraft =>
+    run(draftFromRule(blankDraft(), 'blank'), [
+        { type: 'addStep', step: 'monitor' },
+        { type: 'addStep', step: 'parse' },
+        { type: 'addStep', step: 'cond' },
+        { type: 'addStep', step: 'timer' },
+        { type: 'addStep', step: 'action' },
+    ]);
+
+/** What a save would actually serialize — `undefined` values and absent keys are not the same row. */
+const written = (draft: AutomationDraft) => JSON.parse(JSON.stringify(ruleFromDraft(draft))).graph;
+
+describe('removalGroup', () => {
+    /**
+     * A table over all six, not a spot check on the wait. Half the point of the function is the
+     * three steps that answer with something other than themselves, and a test that only asked
+     * about `timer` would pass on an implementation that always answered `[kind]`.
+     */
+    it.each(STEP_ORDER.map((step) => [step] as const))('answers for %s', (step) => {
+        const present = [...STEP_ORDER];
+        const expected = INPUT_STEPS.includes(step) ? [...INPUT_STEPS] : [step];
+        expect(removalGroup(present, step)).toEqual(expected);
+    });
+
+    it('reports only the cards actually on the canvas', () => {
+        // A schedule rule drawing a wait and a send: aiming at either takes exactly it, and the
+        // group answer must not name three reading steps that are not there to remove.
+        expect(removalGroup(['timer', 'action'], 'timer')).toEqual(['timer']);
+        expect(removalGroup(['monitor', 'action'], 'parse')).toEqual(['monitor']);
+    });
+
+    it('is empty for a step that is not drawn, which the reducer treats as a no-op', () => {
+        const draft = fullCanvas();
+        expect(removalGroup(draft.present, 'webhook')).toEqual([]);
+        expect(draftReducer(draft, { type: 'removeStep', step: 'webhook' })).toBe(draft);
+    });
+});
+
+describe('removeStep', () => {
+    it('takes the wait off the canvas AND out of the graph', () => {
+        const before = fullCanvas();
+        expect(before.rule.graph.timer).toBeDefined();
+
+        const after = draftReducer(before, { type: 'removeStep', step: 'timer' });
+        expect(after.present).toEqual(['monitor', 'parse', 'cond', 'action']);
+        // `graphAsWritten` has no rule for `timer`, so a card merely hidden would still be saved —
+        // and the rule would go on holding every send for thirty seconds with nothing on screen.
+        expect(written(after)).not.toHaveProperty('timer');
+    });
+
+    it('reconnects the verdict to the send the wait sat between', () => {
+        const after = draftReducer(fullCanvas(), { type: 'removeStep', step: 'timer' });
+        expect(after.wires).toEqual([
+            { from: { step: 'monitor', port: 'out' }, to: { step: 'parse', port: 'in' } },
+            { from: { step: 'parse', port: 'out' }, to: { step: 'cond', port: 'in' } },
+            { from: { step: 'cond', port: 'true' }, to: { step: 'action', port: 'in' } },
+        ]);
+    });
+
+    it('takes all three reading steps when any one of them is aimed at', () => {
+        const after = draftReducer(fullCanvas(), { type: 'removeStep', step: 'parse' });
+        expect(after.present).toEqual(['timer', 'action']);
+        const graph = written(after);
+        for (const step of INPUT_STEPS) expect(graph).not.toHaveProperty(step);
+    });
+
+    /**
+     * The reason the three travel together, stated as behaviour rather than as a comment.
+     * `eval::InputSteps::of` answers `None` for a strict subset, so a rule keeping two of them
+     * reads nothing — and `neverRunsProblem` only recognises the shape when all three are gone.
+     */
+    it('never leaves a strict subset of the reading steps behind', () => {
+        for (const step of INPUT_STEPS) {
+            const graph = written(draftReducer(fullCanvas(), { type: 'removeStep', step }));
+            const kept = INPUT_STEPS.filter((s) => s in graph);
+            expect(kept).toEqual([]);
+        }
+    });
+
+    it('clears the selection only when it pointed at what just went', () => {
+        const draft = fullCanvas();
+
+        const gone = draftReducer({ ...draft, selected: 'monitor' }, { type: 'removeStep', step: 'parse' });
+        expect(gone.selected).toBeNull();
+
+        const kept = draftReducer({ ...draft, selected: 'action' }, { type: 'removeStep', step: 'timer' });
+        expect(kept.selected).toBe('action');
+    });
+
+    it('keeps the arrangement, so the palette puts a card back where its owner left it', () => {
+        const moved = draftReducer(fullCanvas(), { type: 'moveStep', step: 'timer', pos: { x: 111, y: 222 } });
+        const removed = draftReducer(moved, { type: 'removeStep', step: 'timer' });
+        expect(removed.layout.timer).toEqual({ x: 111, y: 222 });
+
+        const readded = draftReducer(removed, { type: 'addStep', step: 'timer' });
+        expect(readded.layout.timer).toEqual({ x: 111, y: 222 });
+    });
+
+    /**
+     * The trap this gesture would otherwise open, and the reason `never_runs_problem` stopped
+     * treating a webhook as a trigger: strip the reading steps off a webhook rule that has no wait,
+     * and nothing reads a terminal and no clock fires. Before the fix this rule reported no problem
+     * whatsoever — saveable, enabled, and silent forever.
+     */
+    it('leaves an unrunnable rule BLOCKED rather than quietly saveable', () => {
+        const webhookRule = run(draftFromRule(blankDraft(), 'blank'), [
+            { type: 'addStep', step: 'monitor' },
+            { type: 'addStep', step: 'parse' },
+            { type: 'addStep', step: 'cond' },
+            { type: 'addStep', step: 'webhook' },
+        ]);
+        const configured = draftReducer(webhookRule, {
+            type: 'webhook',
+            patch: { url: 'https://hooks.example.invalid/gone', body: 'done' },
+        });
+        const stripped = draftReducer(configured, { type: 'removeStep', step: 'monitor' });
+
+        expect(written(stripped)).toEqual({ webhook: expect.any(Object), layout: expect.any(Object) });
+        expect(blockingProblems(problems(ruleFromDraft(stripped))).map((p) => p.code))
+            .toContain('timer.neverRuns');
+    });
+
+    /**
+     * The wire chip and the Delete key are two gestures reaching ONE removal. They were separate
+     * code paths until this milestone, which is how they would have drifted: the chip removed the
+     * destination, and a second implementation of "and re-derive the wires, and clear the
+     * selection" is a second set of answers to those questions.
+     */
+    it.each(['action', 'webhook'] as StepKind[])(
+        'reaches the same draft for %s whether the card or its wire is aimed at',
+        (destination) => {
+            const canvas = run(draftFromRule(blankDraft(), 'blank'), [
+                { type: 'addStep', step: 'monitor' },
+                { type: 'addStep', step: 'parse' },
+                { type: 'addStep', step: 'cond' },
+                { type: 'addStep', step: destination },
+            ]);
+            const wire = canvas.wires.find((w) => w.to.step === destination)!;
+
+            expect(draftReducer(canvas, { type: 'removeStep', step: destination }))
+                .toEqual(draftReducer(canvas, { type: 'removeWire', wire }));
+        },
+    );
+});
diff --git a/src/renderer/components/Automation/__tests__/automationRoundTrip.test.ts b/src/renderer/components/Automation/__tests__/automationRoundTrip.test.ts
index 42da1a31..5f52c2a9 100644
--- a/src/renderer/components/Automation/__tests__/automationRoundTrip.test.ts
+++ b/src/renderer/components/Automation/__tests__/automationRoundTrip.test.ts
@@ -29,7 +29,8 @@ import { problems } from '../automationValidation';
 import { STEP_ORDER, canAddStep, defaultWires } from '../automationSteps';
 
 /** The steps an ordinary v1 rule has, and therefore the cards it opens with — the wait is opt-in. */
-const WITHOUT_TIMER = STEP_ORDER.filter((s) => s !== 'timer');
+const WITHOUT_TIMER = STEP_ORDER.filter((s) => s !== 'timer' && s !== 'webhook');
+const WITH_TIMER = STEP_ORDER.filter((s) => s !== 'webhook');
 import type { AutomationRule } from '../../../types/electron';
 
 /** The wire hop, exactly as `invoke` performs it. */
@@ -124,6 +125,7 @@ describe('draft ⇄ row', () => {
                     // asserting the default rather than the carried value.
                     timer: { x: 51, y: 52 },
                     action: { x: 41, y: 42 },
+                    webhook: { x: 61, y: 62 },
                 },
             },
         };
@@ -296,8 +298,8 @@ describe('draftFromRule', () => {
         const withWait = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
         withWait.graph.timer = { mode: { afterMatch: { delayMs: 30_000 } } };
         const draft = draftFromRule(withWait);
-        expect(draft.present).toEqual([...STEP_ORDER]);
-        expect(draft.wires).toEqual(defaultWires(STEP_ORDER, 'afterMatch'));
+        expect(draft.present).toEqual(WITH_TIMER);
+        expect(draft.wires).toEqual(defaultWires(WITH_TIMER, 'afterMatch'));
         expect(canAddStep(draft.present, 'timer')).not.toBeNull();
 
         // And without one, the palette can still offer it.
@@ -314,7 +316,7 @@ describe('draftFromRule', () => {
         const schedule = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
         schedule.graph.timer = { mode: { dailyAt: { minuteOfDay: 540, days: 0b0001_1111 } } };
         const draft = draftFromRule(schedule);
-        expect(draft.present).toEqual([...STEP_ORDER]);
+        expect(draft.present).toEqual(WITH_TIMER);
         expect(draft.wires.map((w) => `${w.from.step}.${w.from.port}->${w.to.step}.${w.to.port}`))
             .toEqual(['timer.out->action.in']);
     });
@@ -495,7 +497,10 @@ describe('draftFromRule', () => {
             ...blankDraft(),
             targetMode: 'pinned',
             targetIds: [],
-            graph: { ...blankDraft().graph, layout: DEFAULT_LAYOUT },
+            graph: (() => {
+                const { action: _action, ...graph } = blankDraft().graph;
+                return { ...graph, layout: DEFAULT_LAYOUT };
+            })(),
         });
     });
 
@@ -711,8 +716,8 @@ describe('the reducer', () => {
 
         // The wait step drops in fifth wherever it is dropped, and re-draws the chain THROUGH it.
         d = draftReducer(d, { type: 'addStep', step: 'timer' });
-        expect(d.present).toEqual([...STEP_ORDER]);
-        expect(d.wires).toEqual(defaultWires(STEP_ORDER, 'afterMatch'));
+        expect(d.present).toEqual(WITH_TIMER);
+        expect(d.wires).toEqual(defaultWires(WITH_TIMER, 'afterMatch'));
     });
 
     /**
@@ -727,7 +732,7 @@ describe('the reducer', () => {
         const rule = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
         rule.graph.timer = { mode: { afterMatch: { delayMs: 30_000 } } };
         const opened = draftFromRule(rule);
-        expect(opened.wires).toEqual(defaultWires(STEP_ORDER, 'afterMatch'));
+        expect(opened.wires).toEqual(defaultWires(WITH_TIMER, 'afterMatch'));
 
         const scheduled = draftReducer(opened, {
             type: 'timer',
@@ -736,11 +741,11 @@ describe('the reducer', () => {
         expect(scheduled.rule.graph.timer).toEqual({
             mode: { dailyAt: { minuteOfDay: 540, days: 0b0001_1111 } },
         });
-        expect(scheduled.wires).toEqual(defaultWires(STEP_ORDER, 'dailyAt'));
+        expect(scheduled.wires).toEqual(defaultWires(WITH_TIMER, 'dailyAt'));
 
         // And back, so this is a re-derivation rather than a one-way collapse.
         const back = draftReducer(scheduled, { type: 'timer', mode: { afterMatch: { delayMs: 5_000 } } });
-        expect(back.wires).toEqual(defaultWires(STEP_ORDER, 'afterMatch'));
+        expect(back.wires).toEqual(defaultWires(WITH_TIMER, 'afterMatch'));
     });
 
     /**
diff --git a/src/renderer/components/Automation/__tests__/automationSteps.test.ts b/src/renderer/components/Automation/__tests__/automationSteps.test.ts
index aa97b0c1..3f8e8a91 100644
--- a/src/renderer/components/Automation/__tests__/automationSteps.test.ts
+++ b/src/renderer/components/Automation/__tests__/automationSteps.test.ts
@@ -1,12 +1,12 @@
 /**
- * §10.21 — the ordered-pair matrix over all five steps.
+ * §10.21 — the ordered-pair matrix over all six steps.
  *
- * Total rather than sampled: nine ports, eighty-one ordered pairs, and exactly five are legal. A
+ * Total rather than sampled: ten ports, one hundred ordered pairs, and exactly seven are legal. A
  * test that checked "monitor connects to parse" and "parse does not connect to action" would pass on
  * a `canConnect` that had lost its type check entirely — the interesting refusals are the ones
  * nobody thinks to write down.
  *
- * **The fifth step is `timer`, and it has two shapes rather than one** (plan 032 §6.2, §6.3), which
+ * **The timer has two shapes rather than one** (plan 032 §6.2, §6.3), which
  * is why `defaultWires` takes the shape as an argument and why this file asserts BOTH: in delay mode
  * the wait sits between the verdict and the send, and in schedule mode it *starts* the rule and
  * nothing else is wired at all.
@@ -34,7 +34,7 @@ import {
 const key = (p: PortRef) => `${p.step}.${p.port}`;
 
 /** The four steps a rule had before the wait step existed — still a real shape, and the common one. */
-const WITHOUT_TIMER: StepKind[] = STEP_ORDER.filter((s) => s !== 'timer');
+const WITHOUT_TIMER: StepKind[] = STEP_ORDER.filter((s) => s !== 'timer' && s !== 'webhook');
 
 /**
  * The wires SOME legal shape of a rule implies, and nothing else.
@@ -45,7 +45,7 @@ const WITHOUT_TIMER: StepKind[] = STEP_ORDER.filter((s) => s !== 'timer');
  * FAILS while the engine goes on firing when it succeeds. `wires` is session-only canvas state and
  * no behaviour derives from it, so the drawing was the only thing that changed.
  *
- * **Five rather than three, because the wait step adds two and removes none.** `cond.true->action.in`
+ * **Seven rather than three, because the wait and webhook add four and remove none.** `cond.true->action.in`
  * stays legal: a rule with no wait step is still the ordinary rule, and refusing that pair would
  * un-draw every rule written before this milestone.
  */
@@ -55,12 +55,14 @@ const LEGAL = new Set([
     'cond.true->timer.in',
     'cond.true->action.in',
     'timer.out->action.in',
+    'cond.true->webhook.in',
+    'timer.out->webhook.in',
 ]);
 
 describe('canConnect — the ordered-pair matrix', () => {
     const ports = allPorts();
 
-    it('has the nine ports the step table declares', () => {
+    it('has the ten ports the step table declares', () => {
         expect(ports.map(key)).toEqual([
             'monitor.out',
             'parse.in',
@@ -74,10 +76,11 @@ describe('canConnect — the ordered-pair matrix', () => {
             'timer.in',
             'timer.out',
             'action.in',
+            'webhook.in',
         ]);
     });
 
-    it('accepts exactly five of the eighty-one ordered pairs', () => {
+    it('accepts exactly seven of the one hundred ordered pairs', () => {
         const accepted: string[] = [];
         for (const from of ports) {
             for (const to of ports) {
@@ -87,7 +90,7 @@ describe('canConnect — the ordered-pair matrix', () => {
             }
         }
         expect(accepted.sort()).toEqual([...LEGAL].sort());
-        expect(ports.length * ports.length).toBe(81);
+        expect(ports.length * ports.length).toBe(100);
     });
 
     it('refuses each pair for the RIGHT reason', () => {
@@ -116,6 +119,9 @@ describe('canConnect — the ordered-pair matrix', () => {
         expect(reason('parse.out', 'action.in')).toBe(
             `${STEP_LABELS.parse} sends a value, and ${STEP_LABELS.action} expects a yes or no.`,
         );
+        expect(reason('parse.out', 'webhook.in')).toBe(
+            `${STEP_LABELS.parse} sends a value, and ${STEP_LABELS.webhook} expects a yes or no.`,
+        );
         // Shape. The one refusal that is not about direction, self or type: `cond.false` is a real
         // output of the right type into a free input, and wiring it would draw the opposite of what
         // the rule does. The reason names the port that DOES drive the step, not the one tried.
@@ -129,6 +135,10 @@ describe('canConnect — the ordered-pair matrix', () => {
             `${STEP_LABELS.timer} runs on ${STEP_LABELS.cond}'s yes output. The canvas draws the `
             + 'rule, and a wire the rule would not follow is a picture of something else.',
         );
+        expect(reason('cond.false', 'webhook.in')).toBe(
+            `${STEP_LABELS.webhook} runs on ${STEP_LABELS.cond}'s yes output. The canvas draws the `
+            + 'rule, and a wire the rule would not follow is a picture of something else.',
+        );
         // Type, on the new kind: the wait carries a verdict, so a value cannot enter it and the
         // lines a monitor prints cannot either.
         expect(reason('parse.out', 'timer.in')).toBe(
@@ -136,6 +146,7 @@ describe('canConnect — the ordered-pair matrix', () => {
         );
         // Direction, on the new kind: the wait's own input is not a source.
         expect(reason('timer.in', 'action.in')).toMatch(/output.*input/i);
+        expect(reason('timer.in', 'webhook.in')).toMatch(/output.*input/i);
     });
 
     it('refuses a second wire into an input, BEFORE it asks about shape', () => {
@@ -222,6 +233,11 @@ describe('canAddStep', () => {
         expect(refusal?.reason).toContain(STEP_LABELS.timer);
     });
 
+    it('accepts the webhook after EITHER of the two steps that can drive it', () => {
+        expect(canAddStep(['timer'], 'webhook')).toBeNull();
+        expect(canAddStep(['monitor', 'parse', 'cond'], 'webhook')).toBeNull();
+    });
+
     /**
      * **R3 — the palette must not offer an add that validation will block with no way back.**
      *
@@ -285,14 +301,15 @@ describe('defaultWires', () => {
     const drawn = (wires: ReturnType<typeof defaultWires>) =>
         wires.map((w) => `${key(w.from)}->${key(w.to)}`);
 
-    it('wires the chain and leaves the `no` branch empty', () => {
+    it('wires both destinations directly from the verdict without a wait', () => {
         // The unused `no` port is how a user learns nothing happens on the other path — mockup §03
         // draws it deliberately, so wiring it would be a design change, not a convenience.
-        const wires = defaultWires(WITHOUT_TIMER);
+        const wires = defaultWires(STEP_ORDER.filter((s) => s !== 'timer'));
         expect(drawn(wires)).toEqual([
             'monitor.out->parse.in',
             'parse.out->cond.in',
             'cond.true->action.in',
+            'cond.true->webhook.in',
         ]);
         expect(wires.some((w) => w.from.port === 'false')).toBe(false);
     });
@@ -308,6 +325,7 @@ describe('defaultWires', () => {
             'parse.out->cond.in',
             'cond.true->timer.in',
             'timer.out->action.in',
+            'timer.out->webhook.in',
         ]);
     });
 
@@ -321,9 +339,13 @@ describe('defaultWires', () => {
      * interesting case is the rule that HAS a monitor (which `timer.scheduleWithMonitor` blocks),
      * not the tidy two-card one, because only the former can tell the two modes apart.
      */
-    it('wires only the wait into the send in schedule mode, and nothing else', () => {
-        expect(drawn(defaultWires(STEP_ORDER, 'dailyAt'))).toEqual(['timer.out->action.in']);
+    it('wires the wait into both destinations in schedule mode, and nothing else', () => {
+        expect(drawn(defaultWires(STEP_ORDER, 'dailyAt'))).toEqual([
+            'timer.out->action.in',
+            'timer.out->webhook.in',
+        ]);
         expect(drawn(defaultWires(['timer', 'action'], 'dailyAt'))).toEqual(['timer.out->action.in']);
+        expect(drawn(defaultWires(['timer', 'webhook'], 'dailyAt'))).toEqual(['timer.out->webhook.in']);
     });
 
     it('produces only wires `canConnect` would accept, at every stage of building', () => {
diff --git a/src/renderer/components/Automation/__tests__/automationValidation.test.ts b/src/renderer/components/Automation/__tests__/automationValidation.test.ts
index 5120c25f..5d9b5d84 100644
--- a/src/renderer/components/Automation/__tests__/automationValidation.test.ts
+++ b/src/renderer/components/Automation/__tests__/automationValidation.test.ts
@@ -67,7 +67,7 @@ describe('automationValidation — the shared fixture', () => {
         // "at least 20" and this test would stay green. `all.length` is DERIVED from `BADGES`
         // (never hand-typed), so bumping this number is the one place a new code cannot be added
         // silently — it forces a look at whether the fixture actually covers it.
-        expect(all.length).toBe(22);
+        expect(all.length).toBe(29);
         expect(all.filter((code) => !covered.has(code))).toEqual([]);
     });
 });
@@ -84,6 +84,18 @@ describe('automationValidation — the words the user reads', () => {
             'Pick at least one terminal for this rule to watch.',
         );
 
+        const noExclusionValue: AutomationRule = {
+            ...base(),
+            targetMode: 'rule',
+            criterion: 'allTerminals',
+            criterionValue: '',
+            excludeCriterion: 'commandContains',
+            excludeCriterionValue: '   ',
+        };
+        expect(find(noExclusionValue, 'targets.excludeValueEmpty')?.message).toBe(
+            'Fill in what the exclusion must match, or exclude all terminals instead.',
+        );
+
         const noPattern: AutomationRule = {
             ...base(),
             graph: { ...base().graph, parse: { ...base().graph.parse, find: '' } },
@@ -384,19 +396,23 @@ describe('automationValidation — the words the user reads', () => {
     });
 });
 
-describe('automationValidation — the six templates', () => {
+describe('automationValidation — the ten templates', () => {
     // §10.19 said "all six report EXACTLY ONE problem (target) before terminals are picked, and zero
     // after", and so did the gallery's own note and `automationTemplates.ts`. **All three were wrong,
     // and this test is what made the claim testable.** Every template targets by CRITERION, which is
     // a complete choice — mockup §04's first panel draws exactly that for the context reminder — and
-    // only a PINNED rule can be empty in a way validation can see. None of the six are pinned.
+    // only a PINNED rule can be empty in a way validation can see. None of the templates are pinned.
+    // The two webhook templates deliberately carry blank URLs rather than someone else's endpoint,
+    // so their one `webhook.urlEmpty` problem remains until the user provides their own.
     //
     // The safety property is `enabled: false`, asserted below. That is the one that matters: nothing
     // a template does can happen without one deliberate act.
     it.each(AUTOMATION_TEMPLATES.map((t) => [t.title, t] as const))(
-        '%s is valid and enableable as it ships',
+        '%s has only its expected shipping validation problem',
         (_title, template) => {
-            expect(problems(draftFromTemplate(template))).toEqual([]);
+            expect(problems(draftFromTemplate(template)).map((p) => p.code)).toEqual(
+                template.rule.graph.webhook ? ['webhook.urlEmpty'] : [],
+            );
         },
     );
 
@@ -410,12 +426,14 @@ describe('automationValidation — the six templates', () => {
         },
     );
 
-    it('but a template SWITCHED to pinned then has the one problem, and says which', () => {
+    it('but a template SWITCHED to pinned then identifies its missing targets', () => {
         // The paired positive for the two above: without it they pass on a `problems` that returns
         // an empty list for everything.
         for (const template of AUTOMATION_TEMPLATES) {
             const pinned = { ...draftFromTemplate(template), targetMode: 'pinned' as const };
-            expect(problems(pinned).map((p) => p.code)).toEqual(['targets.empty']);
+            expect(problems(pinned).map((p) => p.code)).toEqual(
+                template.rule.graph.webhook ? ['targets.empty', 'webhook.urlEmpty'] : ['targets.empty'],
+            );
         }
     });
 });
diff --git a/src/renderer/components/Automation/__tests__/automationWritesWhatIsDrawn.test.ts b/src/renderer/components/Automation/__tests__/automationWritesWhatIsDrawn.test.ts
index 9628e9d5..404c192a 100644
--- a/src/renderer/components/Automation/__tests__/automationWritesWhatIsDrawn.test.ts
+++ b/src/renderer/components/Automation/__tests__/automationWritesWhatIsDrawn.test.ts
@@ -26,7 +26,100 @@ const run = (draft: AutomationDraft, actions: DraftAction[]): AutomationDraft =>
 const blockingCodes = (draft: AutomationDraft): string[] =>
     blockingProblems(problems(ruleFromDraft(draft))).map((p) => p.code);
 
+const webhook = { provider: 'discord' as const, url: 'https://hooks.example.invalid/canvas', body: 'done' };
+
+const configuredWebhook = (draft: AutomationDraft): AutomationDraft => ({
+    ...draft,
+    rule: { ...draft.rule, graph: { ...draft.rule.graph, webhook } },
+});
+
 describe('the editor writes the steps the canvas draws', () => {
+    it('omits a hidden action scaffold from the graph a save serializes', () => {
+        const draft = draftFromRule(blankDraft(), 'blank');
+        expect(draft.rule.graph.action).toBeDefined();
+        expect(draft.present).not.toContain('action');
+
+        const written = JSON.parse(JSON.stringify(ruleFromDraft(draft)));
+        expect(written.graph).not.toHaveProperty('action');
+    });
+
+    it('ignores an action edit when the draft has no action', () => {
+        const { action: _action, ...graph } = blankDraft().graph;
+        const draft = draftFromRule({ ...blankDraft(), graph }, 'blank');
+
+        const after = draftReducer(draft, { type: 'action', patch: { message: 'do not send' } });
+        expect(after).toBe(draft);
+        expect(after.rule.graph).not.toHaveProperty('action');
+    });
+
+    it('creates and reopens a webhook-only canvas without serializing the action scaffold', () => {
+        const created = configuredWebhook(run(draftFromRule(blankDraft(), 'blank'), [
+            { type: 'addStep', step: 'monitor' },
+            { type: 'addStep', step: 'parse' },
+            { type: 'addStep', step: 'cond' },
+            { type: 'addStep', step: 'webhook' },
+        ]));
+
+        const saved = JSON.parse(JSON.stringify(ruleFromDraft(created)));
+        expect(saved.graph.action).toBeUndefined();
+        expect(saved.graph.webhook).toEqual(webhook);
+
+        const reopened = draftFromRule(saved);
+        expect(reopened.present).toEqual(['monitor', 'parse', 'cond', 'webhook']);
+        expect(reopened.wires).toEqual([
+            { from: { step: 'monitor', port: 'out' }, to: { step: 'parse', port: 'in' } },
+            { from: { step: 'parse', port: 'out' }, to: { step: 'cond', port: 'in' } },
+            { from: { step: 'cond', port: 'true' }, to: { step: 'webhook', port: 'in' } },
+        ]);
+    });
+
+    it('adds a terminal send beside a webhook destination and reopens both', () => {
+        const withBoth = configuredWebhook(run(draftFromRule(blankDraft(), 'blank'), [
+            { type: 'addStep', step: 'monitor' },
+            { type: 'addStep', step: 'parse' },
+            { type: 'addStep', step: 'cond' },
+            { type: 'addStep', step: 'webhook' },
+            { type: 'addStep', step: 'action' },
+            { type: 'action', patch: { message: 'send this too' } },
+        ]));
+
+        const reopened = draftFromRule(JSON.parse(JSON.stringify(ruleFromDraft(withBoth))));
+        expect(reopened.present).toEqual(['monitor', 'parse', 'cond', 'action', 'webhook']);
+        expect(reopened.wires).toEqual([
+            { from: { step: 'monitor', port: 'out' }, to: { step: 'parse', port: 'in' } },
+            { from: { step: 'parse', port: 'out' }, to: { step: 'cond', port: 'in' } },
+            { from: { step: 'cond', port: 'true' }, to: { step: 'action', port: 'in' } },
+            { from: { step: 'cond', port: 'true' }, to: { step: 'webhook', port: 'in' } },
+        ]);
+    });
+
+    it('removes either destination through its wire chip without retaining an action scaffold', () => {
+        const withBoth = configuredWebhook(run(draftFromRule(blankDraft(), 'blank'), [
+            { type: 'addStep', step: 'monitor' },
+            { type: 'addStep', step: 'parse' },
+            { type: 'addStep', step: 'cond' },
+            { type: 'addStep', step: 'action' },
+            { type: 'action', patch: { message: 'send this too' } },
+            { type: 'addStep', step: 'webhook' },
+        ]));
+
+        const withoutTerminal = draftReducer(withBoth, {
+            type: 'removeWire',
+            wire: { from: { step: 'cond', port: 'true' }, to: { step: 'action', port: 'in' } },
+        });
+        expect(withoutTerminal.present).toEqual(['monitor', 'parse', 'cond', 'webhook']);
+        expect(ruleFromDraft(withoutTerminal).graph.action).toBeUndefined();
+        expect(ruleFromDraft(withoutTerminal).graph.webhook).toEqual(webhook);
+
+        const withoutWebhook = draftReducer(withBoth, {
+            type: 'removeWire',
+            wire: { from: { step: 'cond', port: 'true' }, to: { step: 'webhook', port: 'in' } },
+        });
+        expect(withoutWebhook.present).toEqual(['monitor', 'parse', 'cond', 'action']);
+        expect(ruleFromDraft(withoutWebhook).graph.webhook).toBeUndefined();
+        expect(ruleFromDraft(withoutWebhook).graph.action?.message).toBe('send this too');
+    });
+
     /**
      * **C1, and the one assertion whose absence hid it.** Built the way the palette builds it —
      * `addStep` for each card, then the Wait panel's own mode dispatch — and asked of
@@ -83,9 +176,9 @@ describe('the editor writes the steps the canvas draws', () => {
      * type"* — the first thing a new user sees after *Start from scratch*. The group omission
      * removes the first, because nothing on the canvas claims to read anything.
      *
-     * The second stays, and stays on purpose. `action` is the one step the DTO makes mandatory
-     * (§3.1: *"every rule in both scenarios ends in a send"*), so *"enter the message"* is true of a
-     * blank rule and not a claim about an undrawn card. Filtering it out is the alternative, and it
+     * The second stays, and stays on purpose. A blank rule has neither a terminal message nor a
+     * webhook destination, so reporting its missing destination is true of a blank rule and not a
+     * claim about an undrawn card. Filtering it out is the alternative, and it
      * would make the inspector's list disagree with the Enable gate beside it — `blocking.length`
      * is what dims the toggle, so a filtered list reads *no problems* over a control that refuses to
      * move and says nothing. One unfixable-looking sentence is worse than one true one.
@@ -93,6 +186,6 @@ describe('the editor writes the steps the canvas draws', () => {
     it('a blank canvas reports exactly the one problem a blank rule really has', () => {
         const draft = draftFromRule(blankDraft(), 'blank');
         expect(draft.present).toEqual([]);
-        expect(blockingCodes(draft)).toEqual(['action.empty']);
+        expect(blockingCodes(draft)).toEqual(['rule.noDestination']);
     });
 });
diff --git a/src/renderer/components/Automation/__tests__/monitorSkipTypedLine.test.tsx b/src/renderer/components/Automation/__tests__/monitorSkipTypedLine.test.tsx
new file mode 100644
index 00000000..09891ab2
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/monitorSkipTypedLine.test.tsx
@@ -0,0 +1,162 @@
+/**
+ * @jest-environment jsdom
+ *
+ * **"Ignore the line being typed"** — the *Watch output* inspector's opt-out.
+ *
+ * Reported: *"Whatever I choose, it will capture the value on the screen whenever I type in, not
+ * press enter yet. It still capture the value and activate the trigger."* A command being typed is
+ * echoed onto the screen like anything else, and nothing in the bytes says the user has not pressed
+ * Enter — so the rule is given a way to say that the line the cursor is parked on is not output
+ * yet. What that then DROPS is decided in `state.rs` (`typed_line_span`, and the tests around it);
+ * this file is about the control, its default, and whether the setting survives a save.
+ *
+ * Mounted through the real `AuInspector`, for the reason `timerPanel` states: a panel that is never
+ * reached from the inspector's `step === …` chain renders nothing however well it renders alone.
+ *
+ * **Off is the default and that is a decision, not caution.** The cursor's line is genuine output
+ * for plenty of terminals — a full-screen TUI parks it wherever it likes — so a rule that silently
+ * gained this would lose matches with no way to see why.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AuInspector } from '../AuInspector';
+import { draftFromRule, draftReducer, ruleFromDraft } from '../automationDraft';
+import type { DraftAction } from '../automationDraft';
+import { problems } from '../automationValidation';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+import type { AutomationReadMode, AutomationRule } from '../../../types/electron';
+
+const ruleWith = (over: { read?: AutomationReadMode; skipTypedLine?: boolean } = {}): AutomationRule => {
+    const rule = blankDraft();
+    const monitor = rule.graph.monitor!;
+    return {
+        ...rule,
+        graph: {
+            ...rule.graph,
+            monitor: {
+                ...monitor,
+                read: over.read ?? monitor.read,
+                ...(over.skipTypedLine === undefined ? {} : { skipTypedLine: over.skipTypedLine }),
+            },
+        },
+    };
+};
+
+describe('ignore the line being typed', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+    let sent: DraftAction[];
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+        sent = [];
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show(rule: AutomationRule) {
+        const draft = { ...draftFromRule(rule), selected: 'monitor' as const };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={problems(rule)}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={(a) => sent.push(a)}
+                />,
+            );
+        });
+    }
+
+    /** The checkbox row carrying these words, and its input. `includes`, not `startsWith`: the row
+     *  opens with `AuCheck`'s own tick glyph. */
+    const row = () =>
+        [...container.querySelectorAll('label.au-checkrow')].find((l) =>
+            l.textContent?.includes('Ignore the line being typed'),
+        ) as HTMLLabelElement | undefined;
+    const box = () => row()?.querySelector('input') as HTMLInputElement | undefined;
+
+    const click = async (el: HTMLInputElement) => {
+        await act(async () => {
+            el.click();
+        });
+    };
+
+    /** The monitor patches the panel dispatched, in order. */
+    const patches = () =>
+        sent.filter((a): a is { type: 'monitor'; patch: Record<string, unknown> } => a.type === 'monitor')
+            .map((a) => a.patch);
+
+    it('offers the box unticked on a rule that never asked for it', async () => {
+        await show(ruleWith());
+        expect(box()).toBeDefined();
+        expect(box()!.checked).toBe(false);
+    });
+
+    /**
+     * It narrows whichever read mode is picked, so it belongs to neither of them. A shell echoing a
+     * half-typed command reaches `newOutput` exactly as an input box reaches `onScreen` — offering
+     * it under only one would leave the reported bug live in the other.
+     */
+    it.each<AutomationReadMode>(['newOutput', 'onScreen'])('is offered for %s', async (read) => {
+        await show(ruleWith({ read }));
+        expect(box()).toBeDefined();
+    });
+
+    it('asks for it, and asks to drop it again', async () => {
+        await show(ruleWith());
+        await click(box()!);
+        expect(patches()).toEqual([{ skipTypedLine: true }]);
+
+        // A second toggle must turn it OFF. A handler that dispatched `true` unconditionally passes
+        // the test above and leaves a box the user cannot untick.
+        await show(ruleWith({ skipTypedLine: true }));
+        expect(box()!.checked).toBe(true);
+        await click(box()!);
+        expect(patches().at(-1)).toEqual({ skipTypedLine: false });
+    });
+
+    /**
+     * The rest of the chain: the patch has to reach the reducer, and the reducer's rule has to
+     * reach what a SAVE writes. A control wired to a field nothing persists is the failure mode
+     * this half exists for — it looks exactly like a working control until the editor is reopened.
+     */
+    it('survives the reducer and the save', async () => {
+        const draft = draftFromRule(ruleWith());
+        const ticked = draftReducer(draft, { type: 'monitor', patch: { skipTypedLine: true } });
+        expect(ticked.rule.graph.monitor?.skipTypedLine).toBe(true);
+        expect(ruleFromDraft(ticked).graph.monitor?.skipTypedLine).toBe(true);
+
+        const unticked = draftReducer(ticked, { type: 'monitor', patch: { skipTypedLine: false } });
+        expect(ruleFromDraft(unticked).graph.monitor?.skipTypedLine).toBe(false);
+    });
+
+    /**
+     * What the row actually says. The reported use is an agentic CLI whose status line sits UNDER
+     * its input box — the text such a rule is usually watching for — so the wording has to promise
+     * that everything else is still read, not merely that something is skipped.
+     */
+    it('says what it keeps, not only what it drops', async () => {
+        await show(ruleWith());
+        const text = row()?.textContent ?? '';
+        expect(text).toMatch(/cursor/i);
+        expect(text).toMatch(/still read/i);
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/tokenSubstitutionAffordance.test.tsx b/src/renderer/components/Automation/__tests__/tokenSubstitutionAffordance.test.tsx
new file mode 100644
index 00000000..d521bf13
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/tokenSubstitutionAffordance.test.tsx
@@ -0,0 +1,181 @@
+/** @jest-environment jsdom
+ *
+ * **A capture token must not be offered by a control that will not resolve it.**
+ *
+ * Reported from a live build: a webhook body reading `the context is over $0` posted the literal
+ * `$0` to Discord. The engine was right — `run_webhook` substitutes, and
+ * `a_crossing_posts_the_resolved_webhook_body` now proves the resolved bytes reach the wire — and
+ * the editor was wrong in two separate ways, which is why this file asserts both:
+ *
+ * 1. **The chips and the toggle disagreed.** Clicking `$0` inserted a reference into a body that
+ *    was posted verbatim, so the click produced nothing but literal text. Inserting a token now
+ *    turns substitution on in the same patch.
+ * 2. **A TYPED token said nothing at all.** The chips cannot help someone who wrote `$0` by hand,
+ *    so the panel says what will happen to it — and only when a token is really there, or the note
+ *    would fire on every message containing a dollar sign, including `awk '{print $1}'`, which is
+ *    the case the toggle exists for.
+ *
+ * Both destinations, as a table. The defect was reported against the webhook, but the terminal
+ * action carries the same chips over the same toggle, and a fix applied to one side of a pair is
+ * how the other side keeps the bug.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AuInspector } from '../AuInspector';
+import { draftFromRule } from '../automationDraft';
+import type { DraftAction } from '../automationDraft';
+import { problems } from '../automationValidation';
+import type { AutomationRule } from '../../../types/electron';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+
+const URL = 'https://hooks.example.invalid/secret';
+const PATTERN = String.raw`ctx:(\d+)%`;
+
+type Destination = 'action' | 'webhook';
+
+/** A complete rule whose destination carries `message`, with substitution off. */
+function ruleWith(destination: Destination, message: string): AutomationRule {
+    const blank = blankDraft();
+    const graph = { ...blank.graph, parse: { ...blank.graph.parse!, preset: 'custom' as const, find: PATTERN } };
+    if (destination === 'webhook') {
+        const { action: _action, ...rest } = graph;
+        return {
+            ...blank,
+            graph: { ...rest, webhook: { provider: 'discord', url: URL, body: message, substitute: false } },
+        };
+    }
+    return {
+        ...blank,
+        graph: { ...graph, action: { ...graph.action!, message, substitute: false } },
+    };
+}
+
+describe.each(['action', 'webhook'] as Destination[])('%s — token chips and the toggle', (destination) => {
+    let container: HTMLDivElement;
+    let root: Root;
+    let dispatched: DraftAction[];
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+        dispatched = [];
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show(message: string) {
+        const rule = ruleWith(destination, message);
+        const draft = { ...draftFromRule(rule), selected: destination };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={problems(rule)}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={(action) => { dispatched.push(action); }}
+                />,
+            );
+        });
+    }
+
+    const chip = (text: string) =>
+        [...container.querySelectorAll<HTMLElement>('.au-token')].find((b) => b.textContent === text)!;
+
+    /**
+     * Put the caret at the end of the message box.
+     *
+     * A real textarea keeps its selection across a blur, so a user who types and then clicks a chip
+     * has the caret where they left it. jsdom's value is set by React, never typed, so its
+     * `selectionStart` is 0 and a chip would insert at the FRONT — an artefact of the environment,
+     * not of the panel, and one that would make the assertion below about the wrong thing.
+     */
+    function caretToEnd() {
+        // The action's message box is an `<input>` and the webhook's body is a `<textarea>`.
+        const box = container.querySelector<HTMLInputElement | HTMLTextAreaElement>(
+            'textarea, input[aria-label="Message to send"]',
+        )!;
+        box.setSelectionRange(box.value.length, box.value.length);
+    }
+
+    it('turns substitution on in the same patch that inserts a token', async () => {
+        await show('the context is over ');
+        caretToEnd();
+        await act(async () => { chip('$0').click(); });
+
+        expect(dispatched).toHaveLength(1);
+        const [action] = dispatched as [{ type: string; patch: Record<string, unknown> }];
+        expect(action.type).toBe(destination);
+        // ONE patch, not two dispatches: the message and the flag cannot land apart.
+        expect(action.patch.substitute).toBe(true);
+        expect(action.patch[destination === 'webhook' ? 'body' : 'message']).toBe('the context is over $0');
+    });
+
+    it('says what will happen to a token that was typed rather than clicked', async () => {
+        await show('the context is over $0');
+        const warning = container.querySelector<HTMLElement>('.au-fhelp.warn')!;
+        expect(warning).not.toBeNull();
+        expect(warning.textContent).toContain('$0');
+        expect(warning.textContent).toContain('Insert captured values');
+    });
+
+    /**
+     * The half that keeps the note from becoming noise, and it corrects an assumption this file
+     * was first written on: `$5` in *"the build cost $5 of compute"* IS a token by the grammar, so
+     * a note built on `tokensUsed` alone fires on prose. It is filtered by what the PATTERN can
+     * supply — this rule declares one group, so `$5` is not something the rule could have filled
+     * in, and there is nothing to tell the user they are missing.
+     */
+    it('stays silent for a dollar amount the pattern could never have supplied', async () => {
+        await show('the build cost $5 of compute');
+        expect(container.querySelector('.au-fhelp.warn')).toBeNull();
+    });
+
+    /** ...while the group the pattern DOES declare is exactly what the note is for. */
+    it('names a token the pattern really does supply', async () => {
+        await show('context is at $1 percent');
+        expect(container.querySelector<HTMLElement>('.au-fhelp.warn')!.textContent).toContain('$1');
+    });
+
+    it('stays silent once substitution is on, where a token is not literal', async () => {
+        const rule = ruleWith(destination, 'the context is over $0');
+        const graph = rule.graph;
+        const on: AutomationRule = destination === 'webhook'
+            ? { ...rule, graph: { ...graph, webhook: { ...graph.webhook!, substitute: true } } }
+            : { ...rule, graph: { ...graph, action: { ...graph.action!, substitute: true } } };
+        const draft = { ...draftFromRule(on), selected: destination };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={problems(on)}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={() => {}}
+                />,
+            );
+        });
+        expect(container.querySelector('.au-fhelp.warn')).toBeNull();
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/webhookPanel.test.tsx b/src/renderer/components/Automation/__tests__/webhookPanel.test.tsx
new file mode 100644
index 00000000..f897f2fb
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/webhookPanel.test.tsx
@@ -0,0 +1,141 @@
+/** @jest-environment jsdom */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+import { AuInspector } from '../AuInspector';
+import { draftFromRule } from '../automationDraft';
+import { problems } from '../automationValidation';
+import payloadFixture from '../__fixtures__/webhookPayloadCases.json';
+import { previewWebhookPayload } from '../panels/WebhookPanel';
+import type { AutomationRule, AutomationWebhookProvider } from '../../../types/electron';
+import { blankDraft } from '../../Settings/Automations/automationTemplates';
+
+const SECRET_A = 'https://hooks.example.invalid/secret-a';
+const SECRET_B = 'https://hooks.example.invalid/secret-b';
+
+interface PayloadCase {
+    provider: AutomationWebhookProvider;
+    message: string;
+    expected: string;
+}
+
+const payloadCases = (payloadFixture as unknown as { cases: PayloadCase[] }).cases;
+
+function ruleWithWebhook(
+    id: string,
+    provider: AutomationWebhookProvider = 'discord',
+    body = 'build failed',
+): AutomationRule {
+    const blank = blankDraft();
+    const { action: _action, ...graph } = blank.graph;
+    return {
+        ...blank,
+        id,
+        graph: {
+            ...graph,
+            webhook: { provider, url: id === 'au-b' ? SECRET_B : SECRET_A, body },
+        },
+    };
+}
+
+describe('the webhook inspector', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    beforeAll(() => {
+        (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    });
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(async () => {
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    async function show(rule: AutomationRule) {
+        const draft = { ...draftFromRule(rule), selected: 'webhook' as const };
+        await act(async () => {
+            root.render(
+                <AuInspector
+                    draft={draft}
+                    problems={problems(rule)}
+                    now={1_700_000_000_000}
+                    terminals={[]}
+                    terminalsError={null}
+                    terminalsLoading={false}
+                    report={null}
+                    onRearm={null}
+                    onTest={() => {}}
+                    onFocusStep={() => {}}
+                    dispatch={() => {}}
+                />,
+            );
+        });
+    }
+
+    const urlInput = () => container.querySelector<HTMLInputElement>('[aria-label="Webhook URL"]')!;
+    const preview = () => container.querySelector<HTMLElement>('[data-testid="webhook-preview"]')!;
+
+    it('masks the URL until Reveal is pressed', async () => {
+        await show(ruleWithWebhook('au-a'));
+        expect(urlInput().type).toBe('password');
+        expect(container.textContent).not.toContain(SECRET_A);
+
+        await act(async () => {
+            [...container.querySelectorAll('button')].find((button) => button.textContent === 'Reveal')!.click();
+        });
+        expect(urlInput().type).toBe('text');
+
+        // A different saved rule replaces the panel, so its credential cannot inherit Reveal.
+        await show(ruleWithWebhook('au-b'));
+        expect(urlInput().type).toBe('password');
+        expect(container.textContent).not.toContain(SECRET_A);
+        expect(container.textContent).not.toContain(SECRET_B);
+    });
+
+    it('never renders the URL in the preview', async () => {
+        for (const payloadCase of payloadCases) {
+            await show(ruleWithWebhook('au-a', payloadCase.provider, payloadCase.message));
+            expect(preview().textContent).toBe(payloadCase.expected);
+            expect(preview().textContent).not.toContain(SECRET_A);
+            expect(container.textContent).not.toContain(SECRET_A);
+            for (const element of container.querySelectorAll<HTMLElement>('[title], [aria-label]')) {
+                expect(element.getAttribute('title') ?? '').not.toContain(SECRET_A);
+                expect(element.getAttribute('aria-label') ?? '').not.toContain(SECRET_A);
+            }
+            expect([...container.querySelectorAll('button')].some((button) => /copy/i.test(button.textContent ?? ''))).toBe(false);
+        }
+    });
+
+    it('previewWebhookPayload matches the shared fixture', () => {
+        expect(payloadCases).toHaveLength(7);
+        for (const payloadCase of payloadCases) {
+            expect(previewWebhookPayload(payloadCase.provider, payloadCase.message))
+                .toBe(payloadCase.expected);
+        }
+    });
+
+    it('refuses a capture token the pattern cannot supply', async () => {
+        const rule = ruleWithWebhook('au-a');
+        const withPattern: AutomationRule = {
+            ...rule,
+            graph: {
+                ...rule.graph,
+                parse: { preset: 'custom', literal: null, find: 'FAILED (\\d+)', keep: 'brackets' },
+                webhook: { ...rule.graph.webhook!, body: 'post $2', substitute: true },
+            },
+        };
+        expect(problems(withPattern)).toContainEqual(expect.objectContaining({
+            field: 'webhook',
+            code: 'action.unknownToken',
+        }));
+
+        await show(withPattern);
+        expect(container.textContent).toContain('$2 has nothing to stand for.');
+    });
+});
diff --git a/src/renderer/components/Automation/__tests__/webhookRedaction.test.tsx b/src/renderer/components/Automation/__tests__/webhookRedaction.test.tsx
new file mode 100644
index 00000000..976b8923
--- /dev/null
+++ b/src/renderer/components/Automation/__tests__/webhookRedaction.test.tsx
@@ -0,0 +1,96 @@
+/**
+ * @jest-environment jsdom
+ *
+ * Webhook redaction covers the enumerated surfaces below. This is intentionally not a derived
+ * registry: adding a future display surface does not make this test find it automatically.
+ */
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import type { AutomationLogEntry } from '../../../types/electron';
+import { ActivityLogView } from '../../Settings/Automations/ActivityLogView';
+import { logCopyText } from '../../Settings/Automations/activityLog';
+import {
+    REDACTED_WEBHOOK_URL,
+    redactWebhookError,
+    redactWebhookLogEntry,
+} from '../webhookRedaction';
+
+const secret = 'https://hooks.example.invalid/renderer-credential';
+
+function entry(over: Partial<AutomationLogEntry> = {}): AutomationLogEntry {
+    return {
+        id: 1,
+        ruleId: 'au-1',
+        terminalId: 'tm-1',
+        terminalName: secret,
+        kind: 'failed',
+        detail: `webhook failed: ${secret}`,
+        at: new Date(2026, 8, 4, 9, 11, 5).getTime(),
+        ...over,
+    };
+}
+
+describe('webhook redaction — enumerated surfaces only', () => {
+    it('redacts every serialised activity entry field, not only detail', () => {
+        const source = entry({ ruleId: secret, terminalId: secret });
+        const safe = redactWebhookLogEntry(source);
+        expect(JSON.stringify(safe)).toBe(JSON.stringify({
+            ...source,
+            ruleId: REDACTED_WEBHOOK_URL,
+            terminalId: REDACTED_WEBHOOK_URL,
+            terminalName: REDACTED_WEBHOOK_URL,
+            detail: `webhook failed: ${REDACTED_WEBHOOK_URL}`,
+        }));
+    });
+
+    it('copies the actual redacted clipboard text, not merely the rendered row', () => {
+        const copied = logCopyText([entry()]);
+        expect(copied).toBe(
+            `09:11:05\ttm-1 ${REDACTED_WEBHOOK_URL}\tfailed\twebhook failed: ${REDACTED_WEBHOOK_URL}`,
+        );
+        expect(copied).not.toContain(secret);
+    });
+
+    it('passes the exact redacted export text to the Activity Log Copy action', async () => {
+        const writeText = jest.fn(() => Promise.resolve());
+        Object.defineProperty(navigator, 'clipboard', {
+            configurable: true,
+            value: { writeText },
+        });
+        const container = document.createElement('div');
+        document.body.appendChild(container);
+        const root: Root = createRoot(container);
+
+        await act(async () => {
+            root.render(
+                <ActivityLogView
+                    rule={null}
+                    entries={[entry()]}
+                    newestFirst={false}
+                    error={null}
+                    now={0}
+                    onScopeChange={jest.fn()}
+                    onSetVerbose={jest.fn()}
+                    onBack={jest.fn()}
+                />,
+            );
+        });
+        await act(async () => {
+            [...container.querySelectorAll('button')].find((button) => button.textContent === 'Copy')!.click();
+        });
+
+        expect(writeText).toHaveBeenCalledWith(
+            `09:11:05\ttm-1 ${REDACTED_WEBHOOK_URL}\tfailed\twebhook failed: ${REDACTED_WEBHOOK_URL}`,
+        );
+        expect(container.textContent).not.toContain(secret);
+        await act(async () => root.unmount());
+        container.remove();
+    });
+
+    it('redacts the error text that save, enable, and duplicate toast paths receive', () => {
+        const error = new Error(`automation store rejected the value: ${secret}`);
+        expect(redactWebhookError(error)).toBe(
+            `automation store rejected the value: ${REDACTED_WEBHOOK_URL}`,
+        );
+    });
+});
diff --git a/src/renderer/components/Automation/automationDerive.ts b/src/renderer/components/Automation/automationDerive.ts
index 15697534..c899c534 100644
--- a/src/renderer/components/Automation/automationDerive.ts
+++ b/src/renderer/components/Automation/automationDerive.ts
@@ -52,6 +52,8 @@ export const STEP_FIELDS: Record<StepKind, ProblemField[]> = {
     cond: ['cond'],
     timer: ['timer'],
     action: ['action'],
+    // Webhook validation is still owned by the destination field until Task 12 adds its panel.
+    webhook: [],
 };
 
 export interface DeriveContext {
@@ -268,7 +270,7 @@ export function describeDelay(ms: number): string {
  * face that silently picked `values[1]` would break the moment a row moved.
  */
 export function stepValues(rule: AutomationRule, step: StepKind): Record<string, StepValue> {
-    const { monitor, parse, cond, timer, action } = rule.graph;
+    const { monitor, parse, cond, timer, action, webhook } = rule.graph;
     switch (step) {
         case 'monitor':
             return {
@@ -346,7 +348,13 @@ export function stepValues(rule: AutomationRule, step: StepKind): Record<string,
             return { mode: value(WAIT_MODE_PHRASES.dailyAt), when: value(`${at}, ${when}`) };
         }
         case 'action':
-        default:
+            if (!action) {
+                return {
+                    message: NOT_IN_THIS_RULE,
+                    send: NOT_IN_THIS_RULE,
+                    sendTo: NOT_IN_THIS_RULE,
+                };
+            }
             return {
                 message:
                     action.message.trim().length === 0
@@ -355,6 +363,8 @@ export function stepValues(rule: AutomationRule, step: StepKind): Record<string,
                 send: value(action.submit ? SEND_PHRASES.submit : SEND_PHRASES.hold),
                 sendTo: value(SEND_TO_PHRASES[action.sendTo]),
             };
+        case 'webhook':
+            return { provider: webhook ? value(webhook.provider) : NOT_IN_THIS_RULE };
     }
 }
 
@@ -400,6 +410,11 @@ const FACE_ROWS: Record<StepKind, Array<{ label: string; key: string }>> = {
         { label: 'Send', key: 'message' },
         { label: 'Then', key: 'send' },
     ],
+    webhook: [
+        // The endpoint is a credential. Provider is the only webhook configuration safe to show
+        // on the canvas; Task 12 owns its editable inspector.
+        { label: 'Post', key: 'provider' },
+    ],
 };
 
 /** The problems belonging to a step — both categories, for the monitor. */
@@ -474,15 +489,14 @@ export type NodeTone = 'error' | 'warn' | 'live' | 'ready' | 'absent';
 /**
  * Does the rule actually HAVE this step? (plan 032 §3.1.)
  *
- * `action` is the one step no rule can be without — a rule with nothing to send is not a rule — so
- * it is the only kind this answers `true` for unconditionally. The other three are optional on the
- * DTO. Since task 29 `draftFromRule` draws only the steps a rule HAS, so the editor no longer opens
+ * Every step is optional on the DTO: a rule needs at least one destination, not necessarily a
+ * terminal send. Since task 29 `draftFromRule` draws only the steps a rule HAS, so the editor no longer opens
  * a schedule rule on three cards standing for steps it does not have — but this answer is still
  * load-bearing for every other reader of a graph, the test pane included, and for a row that reached
  * the store by some other route.
  */
 function hasStep(rule: AutomationRule, step: StepKind): boolean {
-    return step === 'action' || rule.graph[step] != null;
+    return rule.graph[step] != null;
 }
 
 export interface NodeState {
@@ -632,7 +646,15 @@ function whenPhrase(rule: AutomationRule, pattern: string, cond: Record<string,
  */
 export function ruleSummary(rule: AutomationRule): string {
     const timer = rule.graph.timer;
-    const action = stepValues(rule, 'action');
+    const destination = rule.graph.action
+        ? {
+            verb: rule.graph.action.submit ? 'send' : 'type',
+            message: rule.graph.action.message,
+        }
+        : {
+            verb: 'post',
+            message: rule.graph.webhook?.provider ?? 'no destination',
+        };
     // A schedule fires on its clock even when it carries monitor/parse/cond steps (the validator
     // reports that shape separately), so it takes the same precedence as `describeRule` below.
     // The rail omits targets: the list row has no room for them and saying it is “watching” would
@@ -642,15 +664,15 @@ export function ruleSummary(rule: AutomationRule): string {
         const at = clockTime(minuteOfDay);
         const when = describeDays(days);
         if (at !== null && when !== '') {
-            return `At ${at} on ${when} · ${rule.graph.action.submit ? 'send' : 'type'} ${action.message.text}`;
+            return `At ${at} on ${when} · ${destination.verb} ${destination.message}`;
         }
     }
     const monitor = stepValues(rule, 'monitor');
     const parse = stepValues(rule, 'parse');
     const cond = stepValues(rule, 'cond');
     return `Watching ${monitor.terminals.text} · ${whenPhrase(rule, parse.find.text, cond)} · ${
-        rule.graph.action.submit ? 'send' : 'type'
-    } ${action.message.text}`;
+        destination.verb
+    } ${destination.message}`;
 }
 
 /**
@@ -760,10 +782,16 @@ function delayClause(timer: AutomationTimerStep | undefined): string | null {
 
 export function describeRule(rule: AutomationRule): RuleSentence {
     const { parse, cond, timer, action } = rule.graph;
-    const send = {
+    const send = action
+        ? {
         verbSend: action.submit ? 'send' : 'type',
         message: action.message,
         sendNote: action.submit ? null : ' — no Enter',
+        }
+        : {
+            verbSend: 'post',
+            message: rule.graph.webhook?.provider ?? 'no destination',
+            sendNote: null,
     };
 
     // **Schedule mode leads with the clock and never with the output.** §6.3: the walk skips
diff --git a/src/renderer/components/Automation/automationDraft.ts b/src/renderer/components/Automation/automationDraft.ts
index 3454bf1d..3720cc29 100644
--- a/src/renderer/components/Automation/automationDraft.ts
+++ b/src/renderer/components/Automation/automationDraft.ts
@@ -35,7 +35,7 @@ import type {
     AutomationTimerMode,
 } from '../../types/electron';
 import type { StepKind, TimerShape, Wire } from './automationSteps';
-import { INPUT_STEPS, STEP_ORDER, STEP_PORTS, defaultWires, samePort } from './automationSteps';
+import { INPUT_STEPS, STEP_ORDER, STEP_PORTS, defaultWires, removalGroup, samePort } from './automationSteps';
 import { applyPreset, setFind, setLiteral } from './automationPresets';
 // The gallery's own starting point, used here as the `'template'` opening's dirty BASELINE — the
 // state the gallery was showing before a card was clicked. Same direction `AutomationMenuSection`
@@ -99,6 +99,7 @@ export const DEFAULT_LAYOUT: Record<StepKind, NodePos> = {
     // `draft.present`, not a reason to give one kind two default positions.
     timer: { x: AU_GAP_X * 3, y: 0 },
     action: { x: AU_GAP_X * 4, y: 0 },
+    webhook: { x: AU_GAP_X * 5, y: 0 },
 };
 
 /**
@@ -397,15 +398,11 @@ export function draftFromRule(rule: AutomationRule, opening: CanvasOpening = 'sa
     // whose whole point is that it is empty. The two new-rule openings are saying something the
     // graph cannot.
     //
-    // `action` is drawn unconditionally because §3.1 keeps it required — there is no absence to
-    // detect — and the wait is drawn on the same rule as the other three now, rather than as the
-    // exception it used to be: a rule that has one gets its card, a rule that does not can be
-    // offered one by the palette.
     const present: StepKind[] = opening === 'blank'
         ? []
         : opening === 'seeded'
             ? ['monitor']
-            : STEP_ORDER.filter((s) => s === 'action' || rule.graph[s] != null);
+            : STEP_ORDER.filter((s) => rule.graph[s] != null);
     const layout = layoutOf(rule);
     // **The rule and the baseline are the SAME object, layout already resolved.** A rule saved
     // before this field existed has no `graph.layout`, so the arrangement it opens with is the
@@ -440,11 +437,26 @@ function graphAsWritten(
     graph: AutomationRule['graph'],
     present: readonly StepKind[],
 ): AutomationRule['graph'] {
-    if (INPUT_STEPS.some((s) => present.includes(s))) return graph;
-    // The KEYS go, not `undefined` values: §3.1's own note says the backend omits an absent step
-    // rather than sending `null`, so an absent step must not decode as a present-but-empty one.
-    const { monitor: _m, parse: _p, cond: _c, ...rest } = graph;
-    return rest;
+    const keepInput = INPUT_STEPS.some((s) => present.includes(s));
+    const keepAction = present.includes('action');
+    const keepWebhook = present.includes('webhook');
+    const graphHasInput = INPUT_STEPS.some((step) => step in graph);
+    // Preserve the graph object whenever it already says exactly what the canvas says. Besides
+    // avoiding churn, that preserves property order for the dirty check's wire-shaped baseline.
+    if (
+        (keepInput || !graphHasInput)
+        && (keepAction || !('action' in graph))
+        && (keepWebhook || !('webhook' in graph))
+    ) return graph;
+    // The KEYS go, not `undefined` values. In particular, an action scaffold hidden by the canvas
+    // must not survive serialisation and submit an Enter in a supposedly webhook-only rule.
+    const { monitor, parse, cond, action, webhook, ...rest } = graph;
+    return {
+        ...rest,
+        ...(keepInput ? { monitor, parse, cond } : {}),
+        ...(keepAction ? { action } : {}),
+        ...(keepWebhook ? { webhook } : {}),
+    };
 }
 
 /**
@@ -522,8 +534,8 @@ function layoutOf(rule: AutomationRule): Record<StepKind, NodePos> {
  * second one: any canvas keeping one input step keeps all three, and `parse.empty` goes on catching
  * the partial cases.
  *
- * `action` is never omitted — §3.1 keeps it required on the DTO — and `timer` needs no rule here,
- * because `addStep` materialises it into the graph exactly when the canvas reveals it.
+ * The two destinations are omitted independently when their cards are absent; `timer` needs no rule
+ * here, because `addStep` materialises it into the graph exactly when the canvas reveals it.
  *
  * **`op`/`threshold` are dropped from the row that carries clauses, and only from that row.** §5.3
  * makes the pair v1-only — read at load, folded into `clauses` by `fold_v1_clauses`, never written
@@ -567,11 +579,11 @@ export function isDirty(draft: AutomationDraft): boolean {
 /**
  * The rule as a string, with the one field whose ORDER means nothing put in a fixed one.
  *
- * `targetIds` is a set: `write_rule` replaces the pick set row by row and the engine resolves it
- * with a lookup, so nothing downstream can tell `['tm-1','tm-2']` from `['tm-2','tm-1']`. The
- * picker's toggle appends, though, so unticking a terminal and ticking it straight back rotated the
- * array — and the draft then read dirty forever, with a *Leave without saving?* dialog over an
- * identical rule.
+ * `targetIds` and `excludedIds` are sets: `write_rule` replaces each set row by row and the engine
+ * resolves them with a lookup, so nothing downstream can tell `['tm-1','tm-2']` from
+ * `['tm-2','tm-1']`. The picker's toggle appends, though, so unticking a terminal and ticking it
+ * straight back rotated the array — and the draft then read dirty forever, with a *Leave without
+ * saving?* dialog over an identical rule.
  *
  * **Both sides go through this**, which is the whole point: normalising one side of a comparison and
  * not the other can only invent differences (`transform-on-one-side-of-a-comparison`). And it
@@ -593,7 +605,12 @@ function comparable(rule: AutomationRule): string {
               ),
           }
         : rule.graph;
-    return JSON.stringify({ ...rule, graph, targetIds: [...rule.targetIds].sort() });
+    return JSON.stringify({
+        ...rule,
+        graph,
+        targetIds: [...rule.targetIds].sort(),
+        excludedIds: [...(rule.excludedIds ?? [])].sort(),
+    });
 }
 
 export type DraftAction =
@@ -613,6 +630,10 @@ export type DraftAction =
     | { type: 'followNew'; followNew: boolean }
     | { type: 'targets'; ids: string[] }
     | { type: 'toggleTarget'; id: string }
+    | { type: 'excludedTargets'; ids: string[] }
+    | { type: 'toggleExcludedTarget'; id: string }
+    | { type: 'excludeCriterion'; criterion: AutomationRule['criterion'] | null }
+    | { type: 'excludeCriterionValue'; value: string }
     | { type: 'monitor'; patch: Partial<AutomationMonitorStep> }
     | { type: 'preset'; preset: AutomationParseStep['preset'] }
     | { type: 'literal'; literal: string }
@@ -636,9 +657,18 @@ export type DraftAction =
      * expressible-but-refused is the shape that saves clean and comes back broken.
      */
     | { type: 'timer'; mode: AutomationTimerMode }
-    | { type: 'action'; patch: Partial<AutomationRule['graph']['action']> }
+    | { type: 'action'; patch: Partial<NonNullable<AutomationRule['graph']['action']>> }
+    | { type: 'webhook'; patch: Partial<NonNullable<AutomationRule['graph']['webhook']>> }
     | { type: 'select'; step: StepKind | null }
     | { type: 'addStep'; step: StepKind }
+    /**
+     * Take a card OFF the canvas and delete the graph field behind it.
+     *
+     * One step is named, never a list, because the caller does not get to choose the set: the
+     * three input steps come off together and `removalGroup` is the one place that is decided.
+     * An action carrying its own list would let a gesture drop `parse` alone.
+     */
+    | { type: 'removeStep'; step: StepKind }
     | { type: 'moveStep'; step: StepKind; pos: NodePos }
     | { type: 'addWire'; wire: Wire }
     | { type: 'removeWire'; wire: Wire }
@@ -709,6 +739,15 @@ function freeSlot(
  *
  * Returns the rule UNCHANGED when there is nothing to fill in, so `addStep` on a complete rule is
  * still presentation-only and cannot make an unedited draft read dirty.
+ * **A new destination starts with substitution ON** (`blankDraft`'s action carries it too). It was
+ * off, and the chips above it inserted `$0` into a message that was then sent verbatim — the
+ * literal-`$0`-on-Discord defect. Tam: *"Let's enable the insert capture values on by default"*,
+ * new rules and templates only: a SAVED rule carries its own value and keeps it, so nothing that
+ * already exists changes what it types or posts.
+ *
+ * This is what narrowed `action.tokenWithoutParse` to fire on a TOKEN rather than on the flag —
+ * a schedule rule has no parse step at all, and would otherwise open blocked by a default nobody
+ * chose.
  */
 function materialise(rule: AutomationRule, step: StepKind): AutomationRule {
     if (step === 'timer') {
@@ -716,7 +755,16 @@ function materialise(rule: AutomationRule, step: StepKind): AutomationRule {
             ? { ...rule, graph: { ...rule.graph, timer: { mode: DEFAULT_TIMER_MODE } } }
             : rule;
     }
-    if (step === 'action' || INPUT_STEPS.every((s) => rule.graph[s] != null)) return rule;
+    if (step === 'action') {
+        const action = rule.graph.action ?? blankDraft().graph.action;
+        return action ? { ...rule, graph: { ...rule.graph, action } } : rule;
+    }
+    if (step === 'webhook') {
+        return rule.graph.webhook == null
+            ? { ...rule, graph: { ...rule.graph, webhook: { provider: 'discord', url: '', body: '', substitute: true } } }
+            : rule;
+    }
+    if (INPUT_STEPS.every((s) => rule.graph[s] != null)) return rule;
     const blank = blankDraft().graph;
     return {
         ...rule,
@@ -729,6 +777,42 @@ function materialise(rule: AutomationRule, step: StepKind): AutomationRule {
     };
 }
 
+/**
+ * The draft with `steps` gone — **off the canvas AND out of the graph**, which is one operation.
+ *
+ * The pair is the whole of the design `removalGroup` describes. Dropping a card from `present`
+ * alone leaves the step's data behind, and `graphAsWritten` only omits the input group and the two
+ * destinations — a `timer` hidden that way would go on delaying every send with no card on screen
+ * to say so. Deleting the graph field alone leaves a card drawing a step that is not there.
+ *
+ * `layout` is deliberately KEPT. A position is a user choice — it is why `graph.layout` is
+ * persisted at all — so a card the palette puts back returns to where its owner last dragged it
+ * rather than to the default column; `freeSlot` still pushes it clear if something moved into the
+ * slot meanwhile.
+ *
+ * Used by `removeStep` and by `removeWire`'s destination branch, which is the same removal reached
+ * by pulling the wire out instead of by aiming at the card. Two copies of *"and re-derive the
+ * wires, and clear the selection if it pointed at what just went"* is how two gestures end up
+ * leaving different drafts behind.
+ */
+function withoutSteps(draft: AutomationDraft, steps: readonly StepKind[]): AutomationDraft {
+    if (steps.length === 0) return draft;
+    const graph = { ...draft.rule.graph };
+    for (const step of steps) delete graph[step];
+    const present = draft.present.filter((step) => !steps.includes(step));
+    const next = { ...draft.rule, graph };
+    return {
+        ...draft,
+        rule: next,
+        present,
+        // Re-derived, never filtered: removing the wait does not merely drop its two wires, it
+        // reconnects the verdict to the send the wait used to sit between.
+        wires: defaultWires(present, timerShapeOf(next)),
+        selected: draft.selected !== null && steps.includes(draft.selected) ? null : draft.selected,
+    };
+}
+
+
 export function draftReducer(draft: AutomationDraft, action: DraftAction): AutomationDraft {
     const { rule } = draft;
     switch (action.type) {
@@ -759,6 +843,21 @@ export function draftReducer(draft: AutomationDraft, action: DraftAction): Autom
                     ? rule.targetIds.filter((id) => id !== action.id)
                     : [...rule.targetIds, action.id],
             });
+        case 'excludedTargets':
+            return withRule(draft, { ...rule, excludedIds: [...action.ids] });
+        case 'toggleExcludedTarget': {
+            const excludedIds = rule.excludedIds ?? [];
+            return withRule(draft, {
+                ...rule,
+                excludedIds: excludedIds.includes(action.id)
+                    ? excludedIds.filter((id) => id !== action.id)
+                    : [...excludedIds, action.id],
+            });
+        }
+        case 'excludeCriterion':
+            return withRule(draft, { ...rule, excludeCriterion: action.criterion });
+        case 'excludeCriterionValue':
+            return withRule(draft, { ...rule, excludeCriterionValue: action.value });
         // **A patch to a step the rule does not have is a no-op, never a materialisation.** Plan
         // 032 §3.1 lets a schedule rule carry no monitor/parse/cond at all, and these six actions
         // come from panels that are only mounted for a step the rule HAS. Filling the gap in from
@@ -812,7 +911,15 @@ export function draftReducer(draft: AutomationDraft, action: DraftAction): Autom
             return { ...draft, rule: next, wires: defaultWires(draft.present, timerShapeOf(next)) };
         }
         case 'action':
-            return withGraph(draft, { action: { ...rule.graph.action, ...action.patch } });
+            return rule.graph.action
+                ? withGraph(draft, { action: { ...rule.graph.action, ...action.patch } })
+                : draft;
+        case 'webhook':
+            // A panel patch cannot materialise a destination. In particular, it must never make
+            // an ActionStep: an empty action can still submit Enter to a live terminal.
+            return rule.graph.webhook
+                ? withGraph(draft, { webhook: { ...rule.graph.webhook, ...action.patch } })
+                : draft;
         case 'select':
             return { ...draft, selected: action.step };
         case 'addStep': {
@@ -853,7 +960,18 @@ export function draftReducer(draft: AutomationDraft, action: DraftAction): Autom
             return { ...draft, layout: { ...draft.layout, [action.step]: action.pos } };
         case 'addWire':
             return { ...draft, wires: [...draft.wires, action.wire] };
+        case 'removeStep':
+            // The GROUP, not the step: aiming at `Read a value` takes all three reading cards with
+            // it. Aiming at a card that is not on the canvas returns an empty list, which
+            // `withoutSteps` treats as the no-op it is.
+            return withoutSteps(draft, removalGroup(draft.present, action.step));
         case 'removeWire':
+            // A destination card has exactly one incoming wire, so its wire chip is its remove
+            // gesture. Removing it must remove the destination too: merely hiding the card while
+            // retaining `action` would leave a live terminal send on a webhook-only canvas.
+            if (action.wire.to.step === 'action' || action.wire.to.step === 'webhook') {
+                return withoutSteps(draft, [action.wire.to.step]);
+            }
             return {
                 ...draft,
                 wires: draft.wires.filter(
diff --git a/src/renderer/components/Automation/automationSteps.ts b/src/renderer/components/Automation/automationSteps.ts
index 90d16160..586b3d1d 100644
--- a/src/renderer/components/Automation/automationSteps.ts
+++ b/src/renderer/components/Automation/automationSteps.ts
@@ -1,5 +1,5 @@
 /**
- * The five steps, their typed ports, and the one function that decides whether a wire is legal
+ * The six steps, their typed ports, and the one function that decides whether a wire is legal
  * (plan 028 §6.3, plan 032 §6.2/§6.3/§9, mockup §03).
  *
  * **Canvas Mode's ports are undirected 4-compass geometry with no type system**, and the only
@@ -8,7 +8,7 @@
  * §10.21's ordered-pair matrix a cheap and total test rather than a sampling of the interesting
  * cases.
  *
- * **The five step KINDS are fixed; a rule having all five is not.** This file's arithmetic is over
+ * **The six step KINDS are fixed; a rule having all six is not.** This file's arithmetic is over
  * the names — the order, the ports, which pairs may be wired — and none of it reads `rule.graph`.
  * That is what keeps it true while the DTO changes underneath it: plan 032 §3.1 made `monitor`,
  * `parse` and `cond` optional, so a schedule rule (§6.3) is `action` and a `timer` and nothing else.
@@ -31,7 +31,7 @@
  * — but no longer by every schedule rule on open.
  */
 
-export type StepKind = 'monitor' | 'parse' | 'cond' | 'timer' | 'action';
+export type StepKind = 'monitor' | 'parse' | 'cond' | 'timer' | 'action' | 'webhook';
 
 /**
  * Left to right, and also the order the palette lists them and the problem list reports them.
@@ -48,6 +48,7 @@ export const STEP_ORDER: readonly StepKind[] = Object.freeze([
     'cond',
     'timer',
     'action',
+    'webhook',
 ]);
 
 /**
@@ -84,6 +85,7 @@ export const STEP_LABELS: Record<StepKind, string> = {
     cond: 'Compare it',
     timer: 'Wait',
     action: 'Send to terminal',
+    webhook: 'Send to webhook',
 };
 
 /** The line under the title in the inspector head — *Step 2 · find text, pull a number out*. */
@@ -93,6 +95,7 @@ export const STEP_SUBTITLES: Record<StepKind, string> = {
     cond: 'decide yes or no',
     timer: 'hold, or fire on the clock',
     action: 'what happens when it fires',
+    webhook: 'what happens when it fires',
 };
 
 /** What travels on a wire. Three types, and only equal types connect. */
@@ -150,6 +153,7 @@ const PORTS = {
         { id: 'out', dir: 'out', type: 'verdict', label: 'go' },
     ] as const),
     action: Object.freeze([{ id: 'in', dir: 'in', type: 'verdict', label: 'verdict' }] as const),
+    webhook: Object.freeze([{ id: 'in', dir: 'in', type: 'verdict', label: 'verdict' }] as const),
 } as const;
 
 export const STEP_PORTS: Record<StepKind, readonly PortSpec[]> = PORTS;
@@ -266,8 +270,8 @@ export function canConnect(
 /**
  * Which step must already be on the canvas before this one makes sense — **any ONE of them**.
  *
- * A list rather than a single kind, because `action` has two drivers and always did in principle:
- * the verdict from `Compare it` on a watching rule, and the wait itself on a schedule rule, which
+ * A list rather than a single kind, because either destination has two drivers in principle: the
+ * verdict from `Compare it` on a watching rule, and the wait itself on a schedule rule, which
  * has no comparison and is not allowed one (§6.3). Named as one predecessor, the palette demanded a
  * `Compare it` that a schedule rule must not carry, so *"a wait and a send"* — the whole of mockup
  * §03's rule — could not be built at all.
@@ -280,6 +284,7 @@ const REQUIRES: Partial<Record<StepKind, readonly StepKind[]>> = {
     parse: ['monitor'],
     cond: ['parse'],
     action: ['cond', 'timer'],
+    webhook: ['cond', 'timer'],
 };
 
 /**
@@ -288,10 +293,12 @@ const REQUIRES: Partial<Record<StepKind, readonly StepKind[]>> = {
  *
  * **`shape` is the wait's mode, and it is here because of what task 29 made possible.** Once
  * `draftFromRule` draws only the steps a rule HAS, a saved schedule rule can be offered a
- * `Watch output` step — and there is no remove gesture and no undo, so an add whose only remedy is
- * a control that does not exist strands the user with the draft or with discarding every other edit
- * they made. The invariant is *the palette must not offer an add that validation will block with no
- * way back*, and exactly one add fails it:
+ * `Watch output` step. This refusal was first written under *"there is no remove gesture and no
+ * undo"*, which `removalGroup` has since made false — so the invariant it enforces is restated on
+ * the ground that survives: **the palette must not offer an add whose only remedy is a control the
+ * user has to go looking for.** A card can now be deleted, but a step that blocks the rule the
+ * instant it lands still teaches the wrong thing about what the palette offers, and the refusal's
+ * own sentence names the control that actually fixes the shape. Exactly one add fails it:
  *
  * - `monitor` on a `dailyAt` rule raises `timer.scheduleWithMonitor`, whose own message offers
  *   *"remove the schedule, or remove the Watch output step"* — and no field anywhere clears it.
@@ -343,29 +350,48 @@ export function canAddStep(
 }
 
 /**
- * **There is still no `canRemoveStep`, and the reason it used to give has expired.**
+ * Which cards come off together when this one is removed — **the three input steps travel as a
+ * group; every other step is alone.**
  *
- * There was one — a mirror of `canAddStep`, with a test, and no caller. What justified deleting it
- * was the sentence *"`present` is session-only canvas state, and a rule's graph carries all four
- * steps whatever is drawn"*. **That second clause is no longer true.** §3.1 made `monitor`, `parse`
- * and `cond` optional, task 29 made `draftFromRule` derive `present` from the graph, and
- * `ruleFromDraft` omits the three input steps as a group when the canvas draws none — so `present`
- * now DOES mean something the saved rule agrees with, which is precisely the condition the old note
- * said a remove would need. A false comment that justifies real behaviour is how C1 got here, so it
- * is corrected rather than left standing.
+ * There used to be nothing here but a note explaining why removal was unimplemented, and both
+ * halves of it have now been overtaken. The first — *"a rule's graph carries all four steps
+ * whatever is drawn"* — died when §3.1 made `monitor`, `parse` and `cond` optional and task 29
+ * made `draftFromRule` derive `present` from the graph. The second said the gesture "needs
+ * designing rather than enabling"; this is that design, and `draftReducer`'s `removeStep` is where
+ * it happens.
  *
- * Remove is still absent, on the remaining half of the argument, which is untouched: taking a card
- * off the canvas has to decide what happens to the DATA behind it. Hiding *Send to terminal* while
- * leaving the message, the Enter and the send-to intact means the rule goes on typing into terminals
- * with nothing on screen to say so — and `action` is not optional on the DTO, so there is no shape
- * for its absence to write. For the three that are optional the question is answerable but not
- * answered here: it is a gesture with a data consequence, and it needs designing rather than
- * enabling.
+ * **A removal deletes the step's graph field**, so nothing survives the card that drew it. That was
+ * the concrete worry the old note raised and it is a real one: hiding *Send to terminal* while
+ * leaving its message, its Enter and its send-to intact would leave the rule typing into terminals
+ * with nothing on screen to say so. The DTO makes the deletion expressible — all six steps are
+ * optional on `AutomationGraph` — so absence is a shape a save can write, not a hole
+ * `graphAsWritten` has to paper over.
  *
- * `addStep` is coherent because it moves the other way: it REVEALS a step and materialises whatever
- * the panel needs to bind to, and everything it reveals is blank and blocking until the user fills
- * it in.
+ * **Why the input steps are a group and not three cards.** `eval::InputSteps::of` answers `None`
+ * unless a graph holds all three, so a strict subset is a rule the engine reads nothing for. That
+ * is the contract `INPUT_STEPS` already documents and `ruleFromDraft` already writes under;
+ * removing one at a time would be a THIRD answer to it, and the one that produces a rule which
+ * looks complete on screen and silently never fires.
+ *
+ * Filtered by `present`, so this is the cards actually on the canvas rather than the cards a
+ * complete rule would have — and it is computed ONCE, for the menu that names them, the reducer
+ * that drops them and the toast that reports them. A menu offering to delete three steps over a
+ * canvas holding two is what a second derivation buys.
+ *
+ * **There is deliberately no `canRemoveStep` refusal to go with `canAddStep`.** Every shape a
+ * removal can reach is one `problems()` already reports on — no destination is
+ * `rule.noDestination`, nothing to trigger the rule is `timer.neverRuns` — so a refusal would be a
+ * second, weaker statement of a rule that already holds for every producer. Aiming at a card that
+ * is not on the canvas returns an empty group, and the reducer treats that as a no-op: the same
+ * discipline its panel patches follow.
  */
+export function removalGroup(
+    present: readonly StepKind[],
+    kind: StepKind,
+): StepKind[] {
+    const group = INPUT_STEPS.includes(kind) ? INPUT_STEPS : [kind];
+    return group.filter((step) => present.includes(step));
+}
 
 /**
  * The wires implied by a set of steps and the wait's mode — the chain, plus the `yes` branch.
@@ -399,6 +425,9 @@ export function defaultWires(
         if (has('action')) {
             out.push({ from: { step: 'timer', port: 'out' }, to: { step: 'action', port: 'in' } });
         }
+        if (has('webhook')) {
+            out.push({ from: { step: 'timer', port: 'out' }, to: { step: 'webhook', port: 'in' } });
+        }
         return out;
     }
 
@@ -416,6 +445,11 @@ export function defaultWires(
     } else if (has('cond') && has('action')) {
         out.push({ from: { step: 'cond', port: 'true' }, to: { step: 'action', port: 'in' } });
     }
+    if (has('timer') && has('webhook')) {
+        out.push({ from: { step: 'timer', port: 'out' }, to: { step: 'webhook', port: 'in' } });
+    } else if (has('cond') && has('webhook')) {
+        out.push({ from: { step: 'cond', port: 'true' }, to: { step: 'webhook', port: 'in' } });
+    }
     return out;
 }
 
diff --git a/src/renderer/components/Automation/automationValidation.ts b/src/renderer/components/Automation/automationValidation.ts
index a687d188..680daecb 100644
--- a/src/renderer/components/Automation/automationValidation.ts
+++ b/src/renderer/components/Automation/automationValidation.ts
@@ -27,17 +27,19 @@
  */
 import type {
     AutomationClause,
+    AutomationCriterion,
     AutomationGraph,
     AutomationParseStep,
     AutomationRule,
     AutomationSource,
 } from '../../types/electron';
-import { tokensUsed } from './automationTokens';
+import { previewSubstitute, tokensUsed } from './automationTokens';
+import type { Token } from './automationTokens';
 
 export type Severity = 'blocks' | 'warns';
 
 /** Which step owns a problem, so the editor can point at the panel that fixes it. */
-export type ProblemField = 'targets' | 'monitor' | 'parse' | 'cond' | 'timer' | 'action';
+export type ProblemField = 'targets' | 'monitor' | 'parse' | 'cond' | 'timer' | 'action' | 'webhook';
 
 /**
  * A stable identity for the RULE that fired.
@@ -50,6 +52,7 @@ export type ProblemField = 'targets' | 'monitor' | 'parse' | 'cond' | 'timer' |
 export type ProblemCode =
     | 'targets.empty'
     | 'targets.criterion'
+    | 'targets.excludeValueEmpty'
     | 'monitor.interval'
     | 'parse.empty'
     | 'parse.uncompilable'
@@ -67,6 +70,12 @@ export type ProblemCode =
     | 'timer.scheduleWithMonitor'
     | 'timer.neverRuns'
     | 'action.empty'
+    | 'rule.noDestination'
+    | 'webhook.urlEmpty'
+    | 'webhook.urlMalformed'
+    | 'webhook.urlNotHttps'
+    | 'webhook.bodyEmpty'
+    | 'webhook.bodyNotJson'
     | 'action.echo'
     | 'action.tokenWithoutParse'
     | 'action.unknownToken';
@@ -95,6 +104,10 @@ const problem = (
     message: string,
 ): Problem => ({ severity, field, code, message });
 
+/** `allTerminals` is the one selector that deliberately has no companion value field. */
+const criterionNeedsValue = (criterion: AutomationCriterion): boolean =>
+    criterion !== 'allTerminals';
+
 /**
  * Compile a user pattern the way the browser will run it for the live preview.
  *
@@ -196,6 +209,33 @@ function tokenSupplied(
     return true; // $0 / Source::Whole is always the whole match.
 }
 
+/**
+ * The tokens in `message` that this pattern **could actually fill in**.
+ *
+ * For the panels' *"with substitution off, this goes out as literal text"* note, and the filter is
+ * the whole of its usefulness. `tokensUsed` alone reports `$5` in *"the build cost $5 of compute"*
+ * — by the grammar it IS a group reference — so a note built on it fires on prose, and a note
+ * that fires on prose is one users learn to look past. Asking whether the pattern supplies the
+ * token turns it into a much narrower claim: *you wrote something this rule could have filled in,
+ * and it will not*.
+ *
+ * `tokenSupplied` rather than a second reading of the group count, so the note and
+ * `action.unknownToken` can never disagree about what `$2` means — the drift this module's own
+ * header keeps warning about.
+ *
+ * Empty for a pattern that is blank or will not compile: nothing is supplyable then, and
+ * `parse.empty` / `parse.uncompilable` are already saying so on the step that owns it.
+ */
+export function resolvableTokens(message: string, find: string): Token[] {
+    if (find.trim().length === 0 || compilePattern(find) === null) return [];
+    const groups = groupsOf(find);
+    return tokensUsed(message).filter((token) => (
+        token.kind === 'group'
+            ? tokenSupplied(groups, token.n, null)
+            : tokenSupplied(groups, null, token.name)
+    ));
+}
+
 /**
  * `$0` / `$2` / `${name}`, for a clause's own problem message.
  *
@@ -224,6 +264,41 @@ function parseStep(graph: AutomationGraph): AutomationParseStep | null {
     return parse && parse.find.trim().length > 0 ? parse : null;
 }
 
+function webhookSampleValues(groups: { count: number; names: Set<string> }): Record<string, string> {
+    const sample: Record<string, string> = {};
+    for (let index = 0; index <= groups.count; index += 1) {
+        sample[String(index)] = `[g${index}]`;
+    }
+    for (const name of groups.names) {
+        sample[name] = `[${name}]`;
+    }
+    return sample;
+}
+
+function renderWebhookBodyForValidation(
+    webhook: NonNullable<AutomationGraph['webhook']>,
+    parse: AutomationParseStep | null,
+): string {
+    if (!webhook.substitute || !parse || webhook.body.trim().length === 0) {
+        return webhook.body;
+    }
+
+    const groups = groupsOf(parse.find);
+    if (compilePattern(parse.find) === null) {
+        return webhook.body;
+    }
+
+    const sample = webhookSampleValues(groups);
+    const rendered = previewSubstitute(webhook.body, groups, sample);
+    if (!rendered.ok) {
+        return webhook.body;
+    }
+
+    return rendered.parts
+        .map((p) => (p.kind === 'text' ? p.text : p.token))
+        .join('');
+}
+
 /**
  * Everything wrong with the COND step's clause list — §8's four `cond.*` codes (plan 032 §5.3,
  * §5.4).
@@ -414,6 +489,17 @@ export const MINUTES_PER_DAY = 24 * 60;
  * `scheduled` is false, and that code fires only when it is true. One graph can never trip both
  * with contradictory remedies.
  *
+ * **A webhook is a DESTINATION, and it used to be read here as a trigger.** The guard exempted
+ * any graph carrying one, which does nothing for a webhook-only rule — that shape is already
+ * exempt for having no terminal message — and silently exempted the shapes that matter: a rule
+ * with a webhook and nothing to start it reported NO problem at all, so it saved, enabled, and
+ * never fired. Reachable through the REST API and an import from the day the step existed, and
+ * reachable from the editor the moment a card could be deleted (`removalGroup`): take the three
+ * reading steps off a webhook rule with no wait and this is exactly what is left. The two
+ * questions are asked separately now — *can anything trigger it* (`hasInputSteps || scheduled`)
+ * and *is there anything to do* (`hasDestination`) — which is what the message underneath has
+ * always claimed to be about.
+ *
  * The remedy differs by shape, so the message branches on whether a Wait step exists: with one
  * already on the canvas the fix is either add a Watch step or switch that Wait to a schedule; with
  * none at all there is no "switch it" to offer, only "add a Watch step" or "add a Wait step set to
@@ -423,9 +509,13 @@ export const MINUTES_PER_DAY = 24 * 60;
 function neverRunsProblem(graph: AutomationGraph): Problem | null {
     const hasInputSteps = Boolean(graph.monitor) && Boolean(graph.parse) && Boolean(graph.cond);
     const scheduled = Boolean(graph.timer && 'dailyAt' in graph.timer.mode);
-    // A blank message defers to `action.empty` alone — see the Rust mirror's doc for why (a brand
-    // new draft with nothing drawn is not a claim about an undrawn Wait card).
-    if (hasInputSteps || scheduled || graph.action.message.trim().length === 0) return null;
+    // A blank terminal message defers to `action.empty` alone; an absent terminal destination is
+    // valid when a webhook is present, and must not be made into an action to satisfy this guard.
+    const hasTerminalDestination = (graph.action?.message.trim().length ?? 0) !== 0;
+    // **A webhook is a DESTINATION, not a trigger**, and conflating the two is what let an
+    // unrunnable rule report nothing at all — see this function's own doc.
+    const hasDestination = hasTerminalDestination || Boolean(graph.webhook);
+    if (hasInputSteps || scheduled || !hasDestination) return null;
     const message = graph.timer
         ? 'This rule waits, but nothing will ever start the wait: it has no Watch output step to '
             + 'match against. Add one, or switch this Wait to run at a time of day instead.'
@@ -603,7 +693,7 @@ export function patternProblems(graph: AutomationGraph): Problem[] {
  */
 export function problems(rule: AutomationRule): Problem[] {
     const out: Problem[] = [];
-    const { monitor, parse, cond, action } = rule.graph;
+    const { monitor, parse, cond, action, webhook } = rule.graph;
 
     // --- target ----------------------------------------------------------------------------------
     // Only a PINNED rule can be empty in a way validation can see. A criterion rule that currently
@@ -620,15 +710,33 @@ export function problems(rule: AutomationRule): Problem[] {
                 ),
             );
         }
-    } else if (rule.criterion !== 'allTerminals' && rule.criterionValue.trim().length === 0) {
-        out.push(
-            problem(
-                'blocks',
-                'targets',
-                'targets.criterion',
-                'Fill in what the terminals must match, or watch all terminals instead.',
-            ),
-        );
+    } else {
+        if (criterionNeedsValue(rule.criterion) && rule.criterionValue.trim().length === 0) {
+            out.push(
+                problem(
+                    'blocks',
+                    'targets',
+                    'targets.criterion',
+                    'Fill in what the terminals must match, or watch all terminals instead.',
+                ),
+            );
+        }
+
+        if (
+            rule.excludeCriterion !== null
+            && rule.excludeCriterion !== undefined
+            && criterionNeedsValue(rule.excludeCriterion)
+            && (rule.excludeCriterionValue ?? '').trim().length === 0
+        ) {
+            out.push(
+                problem(
+                    'blocks',
+                    'targets',
+                    'targets.excludeValueEmpty',
+                    'Fill in what the exclusion must match, or exclude all terminals instead.',
+                ),
+            );
+        }
     }
 
     // --- interval --------------------------------------------------------------------------------
@@ -694,7 +802,16 @@ export function problems(rule: AutomationRule): Problem[] {
     out.push(...timerProblems(rule.graph));
 
     // --- message ---------------------------------------------------------------------------------
-    if (action.message.trim().length === 0) {
+    if (!action && !webhook) {
+        out.push(
+            problem(
+                'blocks',
+                'action',
+                'rule.noDestination',
+                'Add a terminal message or a webhook destination.',
+            ),
+        );
+    } else if (action?.message.trim().length === 0) {
         out.push(
             problem(
                 'blocks',
@@ -703,7 +820,7 @@ export function problems(rule: AutomationRule): Problem[] {
                 'Enter the message this rule should type.',
             ),
         );
-    } else if (parse && parse.find.trim().length > 0) {
+    } else if (action && parse && parse.find.trim().length > 0) {
         // §2.6's failure, told to the user before it happens. The emptiness guard above is
         // load-bearing: an empty regex matches every position of every string, so without it every
         // draft with a message and no pattern yet is told its message matches a pattern it does not
@@ -727,6 +844,67 @@ export function problems(rule: AutomationRule): Problem[] {
         }
     }
 
+    if (webhook) {
+        if (webhook.url.trim().length === 0) {
+            out.push(
+                problem(
+                    'blocks',
+                    'webhook',
+                    'webhook.urlEmpty',
+                    'Provide a webhook URL.',
+                ),
+            );
+        } else {
+            try {
+                const parsed = new URL(webhook.url.trim());
+                if (parsed.protocol !== 'https:') {
+                    out.push(
+                        problem(
+                            'blocks',
+                            'webhook',
+                            'webhook.urlNotHttps',
+                            'Provide an https webhook URL.',
+                        ),
+                    );
+                }
+            } catch {
+                out.push(
+                    problem(
+                        'blocks',
+                        'webhook',
+                        'webhook.urlMalformed',
+                        'Provide a well-formed webhook URL.',
+                    ),
+                );
+            }
+        }
+
+        if (webhook.body.trim().length === 0) {
+            out.push(
+                problem(
+                    'blocks',
+                    'webhook',
+                    'webhook.bodyEmpty',
+                    'Enter a webhook body.',
+                ),
+            );
+        } else if (webhook.provider === 'custom') {
+            const rendered = renderWebhookBodyForValidation(webhook, parseStep(rule.graph));
+            try {
+                JSON.parse(rendered);
+            } catch {
+                out.push(
+                    problem(
+                        'blocks',
+                        'webhook',
+                        'webhook.bodyNotJson',
+                        'The webhook body must be valid JSON.',
+                    ),
+                );
+            }
+        }
+    }
+
     // --- token substitution ----------------------------------------------------------------------
     // §4.4, opt-in via `ActionStep.substitute` (plan 032 §4.2). Without this, a message naming a
     // token the pattern cannot supply reaches `subst::substitute` only at SEND time, where §4.4's
@@ -740,24 +918,32 @@ export function problems(rule: AutomationRule): Problem[] {
     // toggle claims the message inserts a capture, and a rule with no parse step at all captures
     // nothing, exactly like one whose pattern is still empty. `parseStep` is what makes the two
     // spellings indistinguishable to this check.
-    if (action.substitute) {
+    for (const destination of [
+        action?.substitute ? { field: 'action' as const, message: action.message } : null,
+        webhook?.substitute ? { field: 'webhook' as const, message: webhook.body } : null,
+    ]) {
+        if (!destination) continue;
         const sourcing = parseStep(rule.graph);
         if (!sourcing) {
-            // The toggle itself claims the message inserts a capture, which nothing can be true of
-            // before a pattern exists — asked regardless of whether a token has actually been typed
-            // yet, the same way `cond.incomplete` above is asked regardless of what a clause would
-            // compare against.
+            // **The TOKEN is what claims a capture, not the flag** — and that is a correction.
+            // This used to fire for a flag-on message whatever it contained, on the ground that
+            // the toggle itself claimed the message inserts a capture. True while the flag was an
+            // explicit opt-in a user had to reach for; false the day it became the default, at
+            // which point every schedule rule — which has no parse step by construction (§6.3) —
+            // would have opened blocked by a switch nobody touched. A message naming no token
+            // substitutes to itself, so there is nothing to report.
+            if (tokensUsed(destination.message).length === 0) continue;
             out.push(
                 problem(
                     'blocks',
-                    'action',
+                    destination.field,
                     'action.tokenWithoutParse',
                     'This message inserts captured values, but the rule has no pattern to capture them from.',
                 ),
             );
         } else if (compilePattern(sourcing.find) !== null) {
             const groups = groupsOf(sourcing.find);
-            for (const t of tokensUsed(action.message)) {
+            for (const t of tokensUsed(destination.message)) {
                 const bad = t.kind === 'group'
                     ? !tokenSupplied(groups, t.n, null)
                     : !tokenSupplied(groups, null, t.name);
@@ -765,7 +951,7 @@ export function problems(rule: AutomationRule): Problem[] {
                 out.push(
                     problem(
                         'blocks',
-                        'action',
+                        destination.field,
                         'action.unknownToken',
                         `${t.text} has nothing to stand for. The pattern in Read a value has `
                             + `${groups.count} bracketed group${groups.count === 1 ? '' : 's'}, so the highest you can use is $${groups.count}.`,
@@ -804,6 +990,7 @@ export function problemsFor(list: Problem[], field: ProblemField): Problem[] {
 export const BADGES: Record<ProblemCode, string> = {
     'targets.empty': 'needs terminals',
     'targets.criterion': 'needs something to match',
+    'targets.excludeValueEmpty': 'needs something to exclude',
     'monitor.interval': 'checks too often',
     'parse.empty': 'needs a pattern',
     'parse.uncompilable': 'pattern not understood',
@@ -821,6 +1008,12 @@ export const BADGES: Record<ProblemCode, string> = {
     'timer.scheduleWithMonitor': 'the watch is ignored',
     'timer.neverRuns': 'this rule can never run',
     'action.empty': 'needs a message',
+    'rule.noDestination': 'needs a destination',
+    'webhook.urlEmpty': 'needs a webhook URL',
+    'webhook.urlMalformed': 'needs a valid webhook URL',
+    'webhook.urlNotHttps': 'needs an https webhook',
+    'webhook.bodyEmpty': 'needs a webhook body',
+    'webhook.bodyNotJson': 'webhook body is not valid JSON',
     'action.echo': 'may read its own message',
     'action.tokenWithoutParse': 'needs a pattern to capture from',
     'action.unknownToken': 'names a value the pattern has not got',
diff --git a/src/renderer/components/Automation/panels/ActionPanel.tsx b/src/renderer/components/Automation/panels/ActionPanel.tsx
index 8bfe7bca..2f27c2ed 100644
--- a/src/renderer/components/Automation/panels/ActionPanel.tsx
+++ b/src/renderer/components/Automation/panels/ActionPanel.tsx
@@ -19,8 +19,8 @@ import type { AutomationKeep, AutomationSendTo } from '../../../types/electron';
 import type { AutomationDraft, DraftAction } from '../automationDraft';
 import type { PanelModel } from '../automationDerive';
 import { SEND_PHRASES } from '../automationDerive';
-import { compilePattern, groupsOf } from '../automationValidation';
-import { previewSubstitute } from '../automationTokens';
+import { compilePattern, groupsOf, resolvableTokens } from '../automationValidation';
+import { previewSubstitute, tokensUsed } from '../automationTokens';
 import type { PreviewPart } from '../automationTokens';
 import { sayPattern } from '../automationPresets';
 import { AuCheck, AuField, AuHelp, AuRadio } from './AuFields';
@@ -80,6 +80,7 @@ export function sampleFromPattern(find: string, keep: AutomationKeep): Record<st
 export const ActionPanel: React.FC<ActionPanelProps> = ({ draft, model, dispatch, sample }) => {
     const { parse, action } = draft.rule.graph;
     const messageRef = React.useRef<HTMLInputElement | null>(null);
+    if (!action) return null;
 
     // **This panel survives an absent parse step, and must**: `action` is the one step every rule
     // has (plan 032 §3.1), so a schedule rule reaches here with no pattern behind it. No pattern is
@@ -98,7 +99,14 @@ export const ActionPanel: React.FC<ActionPanelProps> = ({ draft, model, dispatch
     const effectiveSample = sample ?? (parse ? sampleFromPattern(parse.find, parse.keep) : {});
     const substitute = action.substitute === true;
 
-    const preview = !substitute
+    // **Whether the message NAMES a token**, which is not the same question as whether the flag is
+    // on — and the difference started mattering when the flag became the default. A schedule rule
+    // has no pattern by construction, so a flag-on message with no token in it was previewed as
+    // *"Nothing would be sent — there is no pattern yet"* about a send that is perfectly fine.
+    // The same narrowing `action.tokenWithoutParse` took, for the same reason.
+    const usesTokens = tokensUsed(action.message).length > 0;
+
+    const preview = !substitute || !usesTokens
         ? {
             blocked: false as const,
             // From the MODEL (`stepValues(rule,'action').message`), so an empty message previews
@@ -134,14 +142,22 @@ export const ActionPanel: React.FC<ActionPanelProps> = ({ draft, model, dispatch
         { text: groupToken(groups.count + 1), dead: true },
         { text: '$$', dead: false },
     ];
+    // The tokens typed into the message that this pattern COULD fill in — see `resolvableTokens`.
+    // Only asked while substitution is off, the one state they can go out literal in.
+    const typed = substitute ? [] : resolvableTokens(action.message, parse?.find ?? '');
 
+    /**
+     * Insert a token **and turn substitution on**, in one patch — see `WebhookPanel`'s twin, where
+     * the mismatch was reported. The chips and the toggle disagreed: clicking `$1` inserted a
+     * reference into a message sent verbatim, so the rule typed the characters `$1`.
+     */
     function insertToken(token: string) {
         const el = messageRef.current;
-        const value = action.message;
+        const value = action?.message ?? '';
         const start = el?.selectionStart ?? value.length;
         const end = el?.selectionEnd ?? value.length;
         const next = value.slice(0, start) + token + value.slice(end);
-        dispatch({ type: 'action', patch: { message: next } });
+        dispatch({ type: 'action', patch: { message: next, substitute: true } });
         const restoreCaret = () => {
             const input = messageRef.current;
             if (!input) return;
@@ -186,12 +202,24 @@ export const ActionPanel: React.FC<ActionPanelProps> = ({ draft, model, dispatch
                         </>
                     ) : (
                         <>
-                            Click a token to insert it. With <b>Insert captured values</b> off,
-                            below, it types as the literal characters shown — turn that on to
-                            substitute a captured value instead.
+                            Click a token to insert it — that also turns on <b>Insert captured
+                            values</b> below, which is what resolves it.
                         </>
                     )}
                 </AuHelp>
+                {/*
+                  * The case the chips cannot fix, because the token was TYPED. Shown only when the
+                  * message actually names one while the toggle is off, so it stays silent for a
+                  * message that merely contains a dollar sign — and silent for `awk '{print $1}'`
+                  * only once that is what the user meant, which is what the toggle says.
+                  */}
+                {!substitute && typed.length > 0 && (
+                    <AuHelp warn>
+                        {typed.map((t) => t.text).join(', ')} will be typed as literal text.
+                        Turn on <b>Insert captured values</b> below to send what the pattern
+                        captured instead.
+                    </AuHelp>
+                )}
             </AuField>
 
             <AuCheck
diff --git a/src/renderer/components/Automation/panels/AuFields.tsx b/src/renderer/components/Automation/panels/AuFields.tsx
index 18b931b1..bd79dc1d 100644
--- a/src/renderer/components/Automation/panels/AuFields.tsx
+++ b/src/renderer/components/Automation/panels/AuFields.tsx
@@ -6,12 +6,19 @@
  */
 import React from 'react';
 
-export const AuField: React.FC<{ label: string; children: React.ReactNode }> = ({
-    label,
-    children,
-}) => (
+export const AuField: React.FC<{
+    label: string;
+    /** An `AuInfo` for this field, drawn against the label. Optional — most fields say enough. */
+    info?: React.ReactNode;
+    children: React.ReactNode;
+}> = ({ label, info, children }) => (
     <div className="au-fgroup">
-        <span className="au-flabel">{label}</span>
+        {/* Inside the label rather than beside it, so the icon travels with the words it explains
+            and `.au-flabel`'s own block/margin rules keep applying to every field unchanged. */}
+        <span className="au-flabel">
+            {label}
+            {info}
+        </span>
         {children}
     </div>
 );
diff --git a/src/renderer/components/Automation/panels/CondPanel.tsx b/src/renderer/components/Automation/panels/CondPanel.tsx
index 0e76cae7..06ca1c1c 100644
--- a/src/renderer/components/Automation/panels/CondPanel.tsx
+++ b/src/renderer/components/Automation/panels/CondPanel.tsx
@@ -47,6 +47,8 @@ import type { ClauseCaptures, Truth } from '../automationClauseTruth';
 import { automationRowState, describeLastFired } from '../../Settings/Automations/automationState';
 import { AuField, AuHelp, AuRadio } from './AuFields';
 import { sampleFromPattern } from './ActionPanel';
+import { AuSelect } from '../AuSelect';
+import { AuInfo } from '../AuInfo';
 
 export interface CondPanelProps {
     draft: AutomationDraft;
@@ -58,6 +60,48 @@ export interface CondPanelProps {
     dispatch: (action: DraftAction) => void;
 }
 
+
+/**
+ * The worked examples behind the field's ⓘ.
+ *
+ * The distinction the two radios draw is the one people get wrong, and their own subtitles argue it
+ * from the mechanism — *re-arms when the printed value changes* against *re-arms when it leaves the
+ * visible screen*. That is the right thing to say once someone already knows which is which. These
+ * are for before that: three lines a terminal actually prints, per kind, and the question to ask of
+ * a line to place it.
+ */
+const FindsExamples: React.FC = () => (
+    <>
+        <p className="au-infolead">
+            The test is whether the line is still <b>true</b> once it stops being printed.
+        </p>
+        <h4>A reading that stays true</h4>
+        <ul>
+            <li><code>ctx:63%</code> — a context meter a TUI redraws in place</li>
+            <li><code>Battery: 18%</code></li>
+            <li><code>queue depth 412</code></li>
+        </ul>
+        <p>
+            63% is still the usage even if nothing reprints it, so the rule keeps reading back
+            through the last 200 lines and re-arms when a <i>new</i> value is printed.
+        </p>
+        <h4>Something that happened</h4>
+        <ul>
+            <li><code>FAILED 3 tests</code></li>
+            <li><code>error: connection refused</code></li>
+            <li><code>Build succeeded in 41s</code></li>
+        </ul>
+        <p>
+            These happened once. Finding one in scrollback an hour later would not mean it is
+            happening now, so the rule re-arms as soon as it leaves the visible screen.
+        </p>
+        <p className="au-infolead">
+            A line can be both shapes at once: <code>API error 529 . retry in 60s</code> carries a
+            number and is still an <i>event</i>. Pick by the question above, not by whether you can
+            see a digit.
+        </p>
+    </>
+);
 const TEXT_OPS: AutomationTextOp[] = [
     'is',
     'isNot',
@@ -278,7 +322,7 @@ export const CondPanel: React.FC<CondPanelProps> = ({
 
     return (
         <>
-            <AuField label="What this pattern finds">
+            <AuField label="What this pattern finds" info={<AuInfo label="Examples of each kind"><FindsExamples /></AuInfo>}>
                 <AuRadio
                     name="au-condfinds"
                     on={cond.kind === 'number'}
@@ -314,51 +358,44 @@ export const CondPanel: React.FC<CondPanelProps> = ({
                             // eslint-disable-next-line react/no-array-index-key
                             <div className="au-clause" key={i}>
                                 <div className="au-crow">
-                                    <select
-                                        className="au-finput"
-                                        aria-label="Which captured value"
+                                    <AuSelect
+                                        ariaLabel="Which captured value"
                                         value={sourceKey(clause.source)}
-                                        onChange={(e) =>
-                                            updateClause(i, { source: sourceFromKey(e.target.value) })}
-                                    >
-                                        {tokens.map((t) => (
-                                            <option key={t.key} value={t.key}>
-                                                {t.label}
-                                            </option>
-                                        ))}
-                                        {/* A clause can carry a token the pattern no longer produces — a
-                                            group removed after the clause was written. It stays selected
-                                            (never silently swapped for `$0`) so the pattern-vs-clause
-                                            mismatch is what `cond.unknownToken` reports, not something
-                                            this dropdown quietly hid. */}
-                                        {!tokens.some((t) => t.key === sourceKey(clause.source)) && (
-                                            <option value={sourceKey(clause.source)}>
-                                                {sourceText(clause.source)}
-                                            </option>
-                                        )}
-                                    </select>
-                                    <select
-                                        className="au-finput"
-                                        aria-label="How to compare"
+                                        options={[
+                                            ...tokens.map((t) => ({ value: t.key, label: t.label })),
+                                            /* A clause can carry a token the pattern no longer produces — a
+                                               group removed after the clause was written. It stays selected
+                                               (never silently swapped for `$0`) so the pattern-vs-clause
+                                               mismatch is what `cond.unknownToken` reports, not something
+                                               this dropdown quietly hid. */
+                                            ...(tokens.some((t) => t.key === sourceKey(clause.source))
+                                                ? []
+                                                : [{
+                                                    value: sourceKey(clause.source),
+                                                    label: sourceText(clause.source),
+                                                }]),
+                                        ]}
+                                        onChange={(value) =>
+                                            updateClause(i, { source: sourceFromKey(value) })}
+                                    />
+                                    <AuSelect
+                                        ariaLabel="How to compare"
                                         value={opKeyOf(clause.test)}
-                                        onChange={(e) =>
-                                            updateClause(i, { test: withOp(clause.test, e.target.value) })}
-                                    >
-                                        <optgroup label="Text">
-                                            {TEXT_OPS.map((op) => (
-                                                <option key={op} value={`text:${op}`}>
-                                                    {TEXT_OP_LABELS[op]}
-                                                </option>
-                                            ))}
-                                        </optgroup>
-                                        <optgroup label="Number">
-                                            {NUM_OPS.map((op) => (
-                                                <option key={op} value={`number:${op}`}>
-                                                    {NUM_OP_LABELS[op]}
-                                                </option>
-                                            ))}
-                                        </optgroup>
-                                    </select>
+                                        options={[
+                                            ...TEXT_OPS.map((op) => ({
+                                                value: `text:${op}`,
+                                                label: TEXT_OP_LABELS[op],
+                                                group: 'Text',
+                                            })),
+                                            ...NUM_OPS.map((op) => ({
+                                                value: `number:${op}`,
+                                                label: NUM_OP_LABELS[op],
+                                                group: 'Number',
+                                            })),
+                                        ]}
+                                        onChange={(value) =>
+                                            updateClause(i, { test: withOp(clause.test, value) })}
+                                    />
                                     {valueNeeded ? (
                                         <input
                                             className="au-finput"
@@ -485,20 +522,25 @@ export const CondPanel: React.FC<CondPanelProps> = ({
 
             {live && (
                 <AuField label="Right now">
-                    <span className={`au-pill ${live.id}`}>
-                        <span className="au-pd" />
-                        {live.pillText}
-                    </span>
+                    {/* The state and the one action on it, together on a row of their own. The
+                        *Fired …* line moves below both rather than between them: it is detail
+                        about the state, and it was what separated the pill from its own button. */}
+                    <div className="au-nowrow">
+                        <span className={`au-pill ${live.id}`}>
+                            <span className="au-pd" />
+                            {live.pillText}
+                        </span>
+                        {onRearm && (
+                            <button type="button" className="au-btn sm" onClick={onRearm}>
+                                Re-arm now
+                            </button>
+                        )}
+                    </div>
                     {lastFired !== null && (
                         <div className="au-rightnow">
                             Fired {describeLastFired(lastFired, now)}.
                         </div>
                     )}
-                    {onRearm && (
-                        <button type="button" className="au-btn sm" onClick={onRearm}>
-                            Re-arm now
-                        </button>
-                    )}
                 </AuField>
             )}
 
diff --git a/src/renderer/components/Automation/panels/MonitorPanel.tsx b/src/renderer/components/Automation/panels/MonitorPanel.tsx
index d632caeb..164d7097 100644
--- a/src/renderer/components/Automation/panels/MonitorPanel.tsx
+++ b/src/renderer/components/Automation/panels/MonitorPanel.tsx
@@ -6,11 +6,16 @@
  * here, because they are one decision.
  */
 import React from 'react';
-import type { AutomationCriterion, WatchableTerminal } from '../../../types/electron';
+import type {
+    AutomationCriterion,
+    AutomationTargetPreview,
+    WatchableTerminal,
+} from '../../../types/electron';
 import type { AutomationDraft, DraftAction } from '../automationDraft';
 import type { PanelModel } from '../automationDerive';
 import { AuTerminalPicker } from '../AuTerminalPicker';
 import { AuCheck, AuField, AuHelp, AuRadio } from './AuFields';
+import { AuSelect } from '../AuSelect';
 
 const CRITERIA: Array<{ id: AutomationCriterion; label: string }> = [
     { id: 'commandContains', label: 'Command contains' },
@@ -47,7 +52,29 @@ export const MonitorPanel: React.FC<MonitorPanelProps> = ({
 }) => {
     const { rule } = draft;
     const { monitor } = rule.graph;
-    const matching = terminals.filter((t) => t.alive).length;
+    const [targetPreview, setTargetPreview] = React.useState<AutomationTargetPreview | null>(null);
+    const previewTargets = typeof window === 'undefined'
+        ? undefined
+        : window.electronAPI?.previewAutomationTargets;
+
+    React.useEffect(() => {
+        if (rule.targetMode !== 'rule' || !previewTargets) {
+            setTargetPreview(null);
+            return undefined;
+        }
+
+        let current = true;
+        void previewTargets(rule, terminals)
+            .then((preview) => {
+                if (current) setTargetPreview(preview);
+            })
+            .catch(() => {
+                if (current) setTargetPreview(null);
+            });
+        return () => {
+            current = false;
+        };
+    }, [previewTargets, rule, terminals]);
 
     return (
         <>
@@ -72,23 +99,17 @@ export const MonitorPanel: React.FC<MonitorPanelProps> = ({
                 <>
                     <AuField label="Rule">
                         <div className="au-frow">
-                            <select
-                                className="au-finput"
+                            <AuSelect
                                 style={{ flex: 1.15 }}
-                                aria-label="What the terminals must match"
+                                ariaLabel="What the terminals must match"
                                 value={rule.criterion}
-                                onChange={(e) =>
+                                options={CRITERIA.map((c) => ({ value: c.id, label: c.label }))}
+                                onChange={(value) =>
                                     dispatch({
                                         type: 'criterion',
-                                        criterion: e.target.value as AutomationCriterion,
+                                        criterion: value as AutomationCriterion,
                                     })}
-                            >
-                                {CRITERIA.map((c) => (
-                                    <option key={c.id} value={c.id}>
-                                        {c.label}
-                                    </option>
-                                ))}
-                            </select>
+                            />
                             {rule.criterion !== 'allTerminals' && (
                                 <input
                                     className="au-finput"
@@ -112,16 +133,59 @@ export const MonitorPanel: React.FC<MonitorPanelProps> = ({
                         </AuHelp>
                     </AuField>
 
-                    <div className="au-termcount">
-                        Open right now <span className="au-n">{matching}</span>
-                        <span className="au-as"> · refreshed every few seconds</span>
-                    </div>
-                    <AuHelp>
-                        This count is every terminal that is open, not every terminal this rule
-                        matches — matching is decided in the engine, against the command line and
-                        working folder it can see, and the rule&apos;s own row reports what it
-                        actually watches.
-                    </AuHelp>
+                    <AuField label="Except these">
+                        <AuTerminalPicker
+                            rows={terminals}
+                            picked={rule.excludedIds ?? []}
+                            error={terminalsError}
+                            loading={terminalsLoading}
+                            onToggle={(id) => dispatch({ type: 'toggleExcludedTarget', id })}
+                            onSet={(ids) => dispatch({ type: 'excludedTargets', ids })}
+                        />
+                    </AuField>
+
+                    <AuField label="… and anything matching this exception">
+                        <div className="au-frow">
+                            <AuSelect
+                                style={{ flex: 1.15 }}
+                                ariaLabel="What the exception must match"
+                                value={rule.excludeCriterion ?? ''}
+                                options={[
+                                    { value: '', label: 'No matching exception' },
+                                    ...CRITERIA.map((c) => ({ value: c.id, label: c.label })),
+                                ]}
+                                onChange={(value) =>
+                                    dispatch({
+                                        type: 'excludeCriterion',
+                                        criterion: value === ''
+                                            ? null
+                                            : value as AutomationCriterion,
+                                    })}
+                            />
+                            {rule.excludeCriterion != null
+                                && rule.excludeCriterion !== 'allTerminals' && (
+                                <input
+                                    className="au-finput"
+                                    style={{ flex: 1 }}
+                                    aria-label="Value the exception must match"
+                                    value={rule.excludeCriterionValue ?? ''}
+                                    onChange={(e) =>
+                                        dispatch({ type: 'excludeCriterionValue', value: e.target.value })}
+                                />
+                            )}
+                        </div>
+                    </AuField>
+
+                    {targetPreview === null ? (
+                        <div className="au-termcount">Resolving matching terminals…</div>
+                    ) : (
+                        <div className="au-termcount" aria-live="polite">
+                            Matching <span className="au-n">{targetPreview.matched.length}</span>
+                            {' - '}excluded <span className="au-n">{targetPreview.excluded.length}</span>
+                            {' = '}watching <span className="au-n">{targetPreview.watching.length}</span>
+                            {targetPreview.watching.length === 0 && ' — nothing is being watched'}
+                        </div>
+                    )}
                 </>
             ) : (
                 <AuTerminalPicker
@@ -167,6 +231,18 @@ export const MonitorPanel: React.FC<MonitorPanelProps> = ({
                     sub="Re-reads the visible screen each check — better for status lines that update in place"
                     onPick={() => dispatch({ type: 'monitor', patch: { read: 'onScreen' } })}
                 />
+                {/* Under both radios rather than beside one: it narrows whichever of them is
+                    picked, and a shell echoing a half-typed command reaches `newOutput` exactly as
+                    an input box reaches `onScreen`. */}
+                <AuCheck
+                    on={monitor.skipTypedLine === true}
+                    label="Ignore the line being typed"
+                    sub="A command you are still typing is on the screen like anything else. Skips the line the cursor is on, so it cannot fire the rule — everything else is still read, including a status line below it."
+                    onToggle={() => dispatch({
+                        type: 'monitor',
+                        patch: { skipTypedLine: !monitor.skipTypedLine },
+                    })}
+                />
             </AuField>
 
             <AuField label="How often to check">
@@ -185,30 +261,27 @@ export const MonitorPanel: React.FC<MonitorPanelProps> = ({
                 />
                 {monitor.cadence === 'timer' && (
                     <div className="au-frow" style={{ marginTop: 8 }}>
-                        <select
-                            className="au-finput"
-                            aria-label="How often to check"
-                            value={monitor.everyMs}
-                            onChange={(e) =>
+                        <AuSelect
+                            ariaLabel="How often to check"
+                            value={String(monitor.everyMs)}
+                            options={[
+                                /* A stored interval that is not on the list — an older rule, or one
+                                   written by a script — keeps its own row rather than being silently
+                                   snapped to the nearest offered value. */
+                                ...(INTERVALS.some((i) => i.ms === monitor.everyMs)
+                                    ? []
+                                    : [{
+                                        value: String(monitor.everyMs),
+                                        label: `Every ${Math.round(monitor.everyMs / 1000)} seconds`,
+                                    }]),
+                                ...INTERVALS.map((i) => ({ value: String(i.ms), label: i.label })),
+                            ]}
+                            onChange={(value) =>
                                 dispatch({
                                     type: 'monitor',
-                                    patch: { everyMs: Number(e.target.value) },
+                                    patch: { everyMs: Number(value) },
                                 })}
-                        >
-                            {/* A stored interval that is not on the list — an older rule, or one
-                                written by a script — keeps its own row rather than being silently
-                                snapped to the nearest offered value. */}
-                            {!INTERVALS.some((i) => i.ms === monitor.everyMs) && (
-                                <option value={monitor.everyMs}>
-                                    Every {Math.round(monitor.everyMs / 1000)} seconds
-                                </option>
-                            )}
-                            {INTERVALS.map((i) => (
-                                <option key={i.ms} value={i.ms}>
-                                    {i.label}
-                                </option>
-                            ))}
-                        </select>
+                        />
                     </div>
                 )}
             </AuField>
diff --git a/src/renderer/components/Automation/panels/WebhookPanel.tsx b/src/renderer/components/Automation/panels/WebhookPanel.tsx
new file mode 100644
index 00000000..75290a72
--- /dev/null
+++ b/src/renderer/components/Automation/panels/WebhookPanel.tsx
@@ -0,0 +1,215 @@
+/**
+ * The webhook destination inspector.
+ *
+ * The endpoint is a credential, not rule prose. It is bound only to a password input and becomes
+ * visible only after this panel's explicit Reveal action. The request preview deliberately models
+ * the BODY the sender posts, never the endpoint it posts to.
+ */
+import React from 'react';
+import type { AutomationWebhookProvider } from '../../../types/electron';
+import type { AutomationDraft, DraftAction } from '../automationDraft';
+import { compilePattern, groupsOf, resolvableTokens } from '../automationValidation';
+import { previewSubstitute, tokensUsed } from '../automationTokens';
+import { sampleFromPattern } from './ActionPanel';
+import { AuCheck, AuField, AuHelp } from './AuFields';
+import { AuSelect } from '../AuSelect';
+
+export interface WebhookPanelProps {
+    draft: AutomationDraft;
+    dispatch: (action: DraftAction) => void;
+}
+
+type ChipInfo = { text: string; dead: boolean };
+
+const groupToken = (n: number): string => (n < 10 ? `$${n}` : `\${${n}}`);
+
+/**
+ * The renderer's mirror of `automation_webhook.rs`'s private `payload` function.
+ *
+ * Rust remains the sender authority. This shapes exactly its provider wrappers for an on-screen
+ * body preview; Custom preserves the text verbatim just as the sender preserves its bytes.
+ */
+export function previewWebhookPayload(provider: AutomationWebhookProvider, message: string): string {
+    switch (provider) {
+        case 'discord':
+            return JSON.stringify({ content: message });
+        case 'slack':
+            return JSON.stringify({ text: message });
+        case 'teams':
+            // serde_json's default map ordering writes these keys in this order too.
+            return JSON.stringify({
+                '@context': 'http://schema.org/extensions',
+                '@type': 'MessageCard',
+                text: message,
+            });
+        case 'custom':
+            return message;
+    }
+}
+
+export const WebhookPanel: React.FC<WebhookPanelProps> = ({ draft, dispatch }) => {
+    const { parse, webhook } = draft.rule.graph;
+    const bodyRef = React.useRef<HTMLTextAreaElement | null>(null);
+    const [revealed, setRevealed] = React.useState(false);
+    if (!webhook) return null;
+
+    const find = parse?.find ?? '';
+    const patternReady = compilePattern(find) !== null && find.trim().length > 0;
+    const groups = patternReady ? groupsOf(find) : { count: 0, names: new Set<string>() };
+    const substitute = webhook.substitute === true;
+    const sample = parse ? sampleFromPattern(parse.find, parse.keep) : null;
+    // See `ActionPanel`'s twin: the flag being on is not a claim that the body names a token, and
+    // since the flag became the default it is not even a choice the user made.
+    const usesTokens = tokensUsed(webhook.body).length > 0;
+    const rendered = substitute && usesTokens && patternReady
+        ? previewSubstitute(webhook.body, groups, sample)
+        : null;
+    const previewMessage = rendered && rendered.ok
+        ? rendered.parts.map((part) => part.kind === 'text' ? part.text : `⟨${part.token}⟩`).join('')
+        : webhook.body;
+    const blocked = substitute && usesTokens && (!patternReady || (rendered !== null && !rendered.ok));
+    const blockedText = !patternReady
+        ? 'Nothing would be posted — there is no pattern yet to capture values from.'
+        : rendered && !rendered.ok
+            ? `Nothing would be posted — ${rendered.badToken} has nothing to stand for.`
+            : null;
+    const preview = previewWebhookPayload(webhook.provider, previewMessage);
+    const chips: ChipInfo[] = [
+        { text: '$0', dead: !patternReady },
+        ...Array.from({ length: groups.count }, (_, i): ChipInfo => ({ text: groupToken(i + 1), dead: false })),
+        { text: groupToken(groups.count + 1), dead: true },
+        { text: '$$', dead: false },
+    ];
+    const body = webhook.body;
+    // The tokens written in the body that this pattern COULD fill in — see `resolvableTokens`.
+    const typed = substitute ? [] : resolvableTokens(body, find);
+
+    /**
+     * Insert a token **and turn substitution on**, in one patch.
+     *
+     * The chips and the toggle used to disagree: clicking `$0` inserted a token into a body that
+     * was posted verbatim, so the value never left the rule and Discord showed the literal `$0`.
+     * Reported from a live build. A control whose whole purpose is to reference a captured value
+     * cannot leave the switch that resolves it off — that is an affordance for something the rule
+     * will not do.
+     *
+     * One patch rather than two dispatches, so the two fields can never land apart. The toggle is
+     * directly below and visibly moves, so this is not a hidden change of state; the off position
+     * is still one click away for a body that wants a literal `$`.
+     */
+    function insertToken(token: string) {
+        const el = bodyRef.current;
+        const value = body;
+        const start = el?.selectionStart ?? value.length;
+        const end = el?.selectionEnd ?? value.length;
+        dispatch({
+            type: 'webhook',
+            patch: { body: value.slice(0, start) + token + value.slice(end), substitute: true },
+        });
+    }
+
+    return (
+        <>
+            <AuField label="Provider">
+                <AuSelect
+                    ariaLabel="Webhook provider"
+                    value={webhook.provider}
+                    options={[
+                        { value: 'discord', label: 'Discord' },
+                        { value: 'slack', label: 'Slack' },
+                        { value: 'teams', label: 'Microsoft Teams' },
+                        { value: 'custom', label: 'Custom JSON' },
+                    ]}
+                    onChange={(value) => dispatch({
+                        type: 'webhook',
+                        patch: { provider: value as AutomationWebhookProvider },
+                    })}
+                />
+            </AuField>
+
+            <AuField label="Webhook URL">
+                <div className="au-frow">
+                    <input
+                        className="au-finput"
+                        type={revealed ? 'text' : 'password'}
+                        aria-label="Webhook URL"
+                        autoComplete="off"
+                        value={webhook.url}
+                        onChange={(e) => dispatch({ type: 'webhook', patch: { url: e.target.value } })}
+                    />
+                    <button
+                        className="au-mini"
+                        type="button"
+                        aria-label={revealed ? 'Hide webhook URL' : 'Reveal webhook URL'}
+                        onClick={() => setRevealed((visible) => !visible)}
+                    >
+                        {revealed ? 'Hide' : 'Reveal'}
+                    </button>
+                </div>
+                <AuHelp>
+                    This URL is a password. Anyone holding it can post into that channel as this integration.
+                </AuHelp>
+            </AuField>
+
+            <AuField label="Message">
+                <textarea
+                    ref={bodyRef}
+                    className="au-finput"
+                    aria-label="Webhook message"
+                    value={webhook.body}
+                    onChange={(e) => dispatch({ type: 'webhook', patch: { body: e.target.value } })}
+                />
+                <div className="au-tokens" aria-label="Available capture tokens">
+                    {chips.map((chip) => (
+                        <button
+                            type="button"
+                            key={chip.text}
+                            className={`au-token${chip.dead ? ' dead' : ''}`}
+                            title={chip.dead ? `${chip.text} has nothing to stand for yet` : undefined}
+                            onClick={() => insertToken(chip.text)}
+                        >
+                            {chip.text}
+                        </button>
+                    ))}
+                </div>
+                <AuHelp>
+                    {substitute ? (
+                        <>
+                            Click a token to insert it. <code>$$</code> writes a dollar sign.
+                        </>
+                    ) : (
+                        <>
+                            Click a token to insert it — that also turns on <b>Insert captured
+                            values</b> below, which is what resolves it.
+                        </>
+                    )}
+                </AuHelp>
+                {/*
+                  * The case the chips cannot fix, because the token was TYPED. Shown only when the
+                  * body actually names one while the toggle is off, so it never fires on a body
+                  * that simply contains a dollar sign.
+                  */}
+                {!substitute && typed.length > 0 && (
+                    <AuHelp warn>
+                        {typed.map((t) => t.text).join(', ')} will be posted as literal text.
+                        Turn on <b>Insert captured values</b> below to send what the pattern
+                        captured instead.
+                    </AuHelp>
+                )}
+            </AuField>
+
+            <AuCheck
+                on={substitute}
+                label="Insert captured values"
+                sub="Off by default. With it off, capture tokens are posted as literal text."
+                onToggle={() => dispatch({ type: 'webhook', patch: { substitute: !substitute } })}
+            />
+
+            <AuField label="Request body preview (URL masked)">
+                <div className={`au-preview${blocked ? ' blocked' : ''}`} data-testid="webhook-preview">
+                    {blocked ? blockedText : preview}
+                </div>
+            </AuField>
+        </>
+    );
+};
diff --git a/src/renderer/components/Automation/webhookRedaction.ts b/src/renderer/components/Automation/webhookRedaction.ts
new file mode 100644
index 00000000..6063f877
--- /dev/null
+++ b/src/renderer/components/Automation/webhookRedaction.ts
@@ -0,0 +1,31 @@
+/**
+ * Last-resort display redaction for text returned across the automation IPC boundary.
+ *
+ * The Rust producers avoid constructing URL-bearing errors, but a corrupt historical log entry or
+ * a framework-level decode failure must not make the webhook endpoint visible in a toast, inspector,
+ * activity row, or clipboard export.
+ */
+import type { AutomationLogEntry } from '../../types/electron';
+
+export const REDACTED_WEBHOOK_URL = '<redacted webhook URL>';
+
+const WEBHOOK_URL = /\bhttps?:\/\/[^\s<>"'\\]+/giu;
+
+export function redactWebhookText(value: string): string {
+    return value.replace(WEBHOOK_URL, REDACTED_WEBHOOK_URL);
+}
+
+export function redactWebhookError(error: unknown): string {
+    return redactWebhookText(error instanceof Error ? error.message : String(error));
+}
+
+/** Redact every serialised activity field that can reach a display or export surface. */
+export function redactWebhookLogEntry(entry: AutomationLogEntry): AutomationLogEntry {
+    return {
+        ...entry,
+        ruleId: redactWebhookText(entry.ruleId),
+        terminalId: entry.terminalId == null ? entry.terminalId : redactWebhookText(entry.terminalId),
+        terminalName: entry.terminalName == null ? entry.terminalName : redactWebhookText(entry.terminalName),
+        detail: redactWebhookText(entry.detail),
+    };
+}
diff --git a/src/renderer/components/Canvas/Canvas.css b/src/renderer/components/Canvas/Canvas.css
index e281735c..93dd53e1 100644
--- a/src/renderer/components/Canvas/Canvas.css
+++ b/src/renderer/components/Canvas/Canvas.css
@@ -504,9 +504,17 @@
 
 /* Scoped to `.canvas-menu` rather than added to `PaneContextMenu.css`, whose classes these
    menus borrow but do not own — the pane and tab menus share that file and have no
-   destructive row. */
-.canvas-menu .context-menu-item.danger { color: var(--danger-color, #e81123); }
-.canvas-menu .context-menu-item.danger:hover:not(:disabled) { color: var(--danger-color, #e81123); }
+   destructive row.
+
+   NOT `--danger-color`, and that is the point. `#e81123` is a strong red for a FILL — a button
+   whose background it becomes, with white text over it — and it is the wrong red for TEXT on a
+   #2d2d30 menu, where it lands at 3.3:1 and reads as a dim maroon rather than as a warning.
+   Reported on the automation canvas's Delete row, and the Canvas Mode node menu's Close row had
+   it too: one colour, two menus, one fix. #ffaea8 is the red the automation editor already uses
+   for its blocking-problem text (~10 sites in `AutomationEditor.css`), so this borrows an answer
+   rather than inventing an eleventh. 7.8:1 on the menu, 5.5:1 on the #094771 hover. */
+.canvas-menu .context-menu-item.danger { color: #ffaea8; }
+.canvas-menu .context-menu-item.danger:hover:not(:disabled) { color: #ffaea8; }
 
 /* The shell-profile list (items 3 and 4). A workspace can have a dozen profiles configured, so
    it scrolls rather than growing past the window — a menu opened near the bottom edge would
diff --git a/src/renderer/components/Canvas/__tests__/canvasMenuDangerContrast.test.ts b/src/renderer/components/Canvas/__tests__/canvasMenuDangerContrast.test.ts
new file mode 100644
index 00000000..3cd53d7f
--- /dev/null
+++ b/src/renderer/components/Canvas/__tests__/canvasMenuDangerContrast.test.ts
@@ -0,0 +1,74 @@
+/**
+ * A destructive menu row must be READABLE, not merely red.
+ *
+ * `.canvas-menu .context-menu-item.danger` took `--danger-color` (`#e81123`), which is a fill
+ * colour: it is meant to be a button's background with white text on top. As TEXT on the
+ * `#2d2d30` menu it lands at 3.3:1 and reads as a dim maroon — reported on the automation
+ * canvas's *Delete* row, and the Canvas Mode node menu's *Close* row shared it, because both
+ * borrow this one declaration.
+ *
+ * The oracle is the CONTRAST RATIO, computed here, rather than the specific hex. "It is not
+ * `#e81123` any more" passes for every other unreadable red, and the next person reaching for a
+ * brand red would put one back; a ratio fails for all of them. Both backgrounds are checked, since
+ * the danger rule deliberately keeps its colour on hover while every other row turns white — so
+ * the row is read against two grounds, and only one of them was ever looked at.
+ *
+ * jsdom has no cascade, so the stylesheets themselves are the only place this can be asked.
+ */
+import fs from 'fs';
+import path from 'path';
+
+const canvasCss = fs.readFileSync(path.join(__dirname, '..', 'Canvas.css'), 'utf8');
+const menuCss = fs.readFileSync(
+    path.join(__dirname, '..', '..', 'Panes', 'PaneContextMenu.css'),
+    'utf8',
+);
+
+/** WCAG 2.x relative luminance of an `#rrggbb`. */
+function luminance(hex: string): number {
+    const channel = (pair: string) => {
+        const v = parseInt(pair, 16) / 255;
+        return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+    };
+    const [r, g, b] = [hex.slice(1, 3), hex.slice(3, 5), hex.slice(5, 7)].map(channel);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+const contrast = (a: string, b: string): number => {
+    const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+    return (hi + 0.05) / (lo + 0.05);
+};
+
+/** The first `prop: #rrggbb` in the group whose selector is `selector`. */
+function colourOf(css: string, selector: string, prop: string): string {
+    const at = css.indexOf(`${selector} {`);
+    expect(at).toBeGreaterThanOrEqual(0);
+    const body = css.slice(css.indexOf('{', at) + 1, css.indexOf('}', css.indexOf('{', at)));
+    const found = new RegExp(`${prop}:\\s*(#[0-9a-f]{6})`, 'i').exec(body);
+    expect(found).not.toBeNull();
+    return found![1].toLowerCase();
+}
+
+describe('a destructive row in a canvas menu', () => {
+    // The menu's own ground, and the ground it takes on hover — `.context-menu-item:hover` sets a
+    // background while `.danger:hover` holds the red, so the row is read against both.
+    const resting = colourOf(menuCss, '.pane-context-menu', 'background-color');
+    const hovered = colourOf(menuCss, '.context-menu-item:hover:not(:disabled)', 'background-color');
+
+    it.each([
+        ['.canvas-menu .context-menu-item.danger', () => resting],
+        ['.canvas-menu .context-menu-item.danger:hover:not(:disabled)', () => hovered],
+    ])('%s clears 4.5:1 against the ground it is drawn on', (selector, ground) => {
+        const colour = colourOf(canvasCss, selector, 'color');
+        expect(contrast(colour, ground())).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it('does not take the fill red back from the token', () => {
+        // Stated as well as measured: `var(--danger-color, #e81123)` computes to a colour this
+        // file cannot resolve, so a future edit reintroducing the token would make the ratio
+        // check above unreadable rather than red. Naming the shape keeps that failure loud.
+        const at = canvasCss.indexOf('.canvas-menu .context-menu-item.danger {');
+        const body = canvasCss.slice(at, canvasCss.indexOf('}', at));
+        expect(body).not.toContain('--danger-color');
+    });
+});
diff --git a/src/renderer/components/Settings/Automations/ActivityLogView.tsx b/src/renderer/components/Settings/Automations/ActivityLogView.tsx
index cae373a2..be5e1f27 100644
--- a/src/renderer/components/Settings/Automations/ActivityLogView.tsx
+++ b/src/renderer/components/Settings/Automations/ActivityLogView.tsx
@@ -22,6 +22,7 @@ import {
     passesFilter,
     rowTime,
 } from './activityLog';
+import { redactWebhookLogEntry } from '../../Automation/webhookRedaction';
 
 /**
  * How long *Log every check* stays on before it turns itself off again.
@@ -66,15 +67,20 @@ export const ActivityLogView: React.FC<ActivityLogViewProps> = ({
     const isVerbose =
         rule?.verboseUntil !== null && rule?.verboseUntil !== undefined && rule.verboseUntil > now;
 
+    const redactedEntries = useMemo(
+        () => entries.map(redactWebhookLogEntry),
+        [entries],
+    );
+
     const rows = useMemo(
-        () => collapseRuns(entries.filter((e) => passesFilter(e, filter))),
-        [entries, filter],
+        () => collapseRuns(redactedEntries.filter((e) => passesFilter(e, filter))),
+        [redactedEntries, filter],
     );
 
     const copy = () => {
         // Expanded, always: a log pasted into a bug report with seven decisions replaced by the
         // words "7 identical decisions collapsed" has lost the timestamps that made it evidence.
-        void navigator.clipboard?.writeText(logCopyText(entries));
+        void navigator.clipboard?.writeText(logCopyText(redactedEntries));
     };
 
     return (
diff --git a/src/renderer/components/Settings/Automations/AutomationsPanel.tsx b/src/renderer/components/Settings/Automations/AutomationsPanel.tsx
index 9b2e0257..39f9a710 100644
--- a/src/renderer/components/Settings/Automations/AutomationsPanel.tsx
+++ b/src/renderer/components/Settings/Automations/AutomationsPanel.tsx
@@ -16,6 +16,7 @@ import { AutomationRow } from './AutomationRow';
 import { TemplateGallery } from './TemplateGallery';
 import { ActivityLogView } from './ActivityLogView';
 import { AutomationEditor } from '../../Automation/AutomationEditor';
+import { redactWebhookError } from '../../Automation/webhookRedaction';
 import type { CanvasOpening } from '../../Automation/automationDraft';
 import { automationRowState, JUST_FIRED_MS } from './automationState';
 import { useAutomations } from './useAutomations';
@@ -80,7 +81,7 @@ export const AutomationsPanel: React.FC = () => {
             await fn();
             await refresh();
         } catch (e) {
-            setActionError(`${what} failed: ${e instanceof Error ? e.message : String(e)}`);
+            setActionError(`${what} failed: ${redactWebhookError(e)}`);
         }
     };
 
@@ -106,7 +107,7 @@ export const AutomationsPanel: React.FC = () => {
             }
             await refresh();
         } catch (e) {
-            setActionError(`${what} failed: ${e instanceof Error ? e.message : String(e)}`);
+            setActionError(`${what} failed: ${redactWebhookError(e)}`);
         }
     };
 
diff --git a/src/renderer/components/Settings/Automations/__tests__/AutomationsPanel.test.tsx b/src/renderer/components/Settings/Automations/__tests__/AutomationsPanel.test.tsx
index 86e9a38e..7810a716 100644
--- a/src/renderer/components/Settings/Automations/__tests__/AutomationsPanel.test.tsx
+++ b/src/renderer/components/Settings/Automations/__tests__/AutomationsPanel.test.tsx
@@ -629,7 +629,7 @@ describe('AutomationsPanel', () => {
         expect(document.querySelector('.confirm-dialog-overlay')).toBeNull();
     });
 
-    it('the template gallery shows the six templates plus a blank card', async () => {
+    it('the template gallery shows the ten templates plus a blank card', async () => {
         installApi([]);
         await mount();
 
@@ -638,7 +638,7 @@ describe('AutomationsPanel', () => {
                 .find((b) => b.textContent?.includes('New automation'))!
                 .click();
         });
-        expect(container.querySelectorAll('.au-tplcard')).toHaveLength(7);
+        expect(container.querySelectorAll('.au-tplcard')).toHaveLength(11);
         expect(container.querySelectorAll('.au-tplcard.blank')).toHaveLength(1);
     });
 });
diff --git a/src/renderer/components/Settings/Automations/__tests__/automationTemplates.test.ts b/src/renderer/components/Settings/Automations/__tests__/automationTemplates.test.ts
index fbd484a0..cf063235 100644
--- a/src/renderer/components/Settings/Automations/__tests__/automationTemplates.test.ts
+++ b/src/renderer/components/Settings/Automations/__tests__/automationTemplates.test.ts
@@ -1,10 +1,10 @@
 /**
- * §10.26 — the six built-in templates.
+ * §10.26 — the ten built-in templates.
  *
- * Exactly six, unique ids and titles, every draft pointed at **no terminals**, and each template's
+ * Exactly ten, unique ids and titles, every draft pointed at **no terminals**, and each template's
  * values different from every other's. That last one is the guard against the failure mode this
- * whole feature's design keeps circling: a table of six entries that are secretly one entry copied
- * six times, which passes every per-item assertion and ships a gallery of identical rules.
+ * whole feature's design keeps circling: a table of ten entries that are secretly one entry copied
+ * ten times, which passes every per-item assertion and ships a gallery of identical rules.
  *
  * *(Plan §10.26 says "empty `monitor.ids`". The DTO settled targeting as `rule.targetIds` — ids are
  * columns, not part of the graph blob — so that is the field asserted; the plan is corrected in
@@ -13,11 +13,17 @@
 import { AUTOMATION_TEMPLATES, blankDraft, draftFromTemplate } from '../automationTemplates';
 import type { AutomationTemplate } from '../automationTemplates';
 
+const byId = (id: string): AutomationTemplate => {
+    const template = AUTOMATION_TEMPLATES.find((t) => t.id === id);
+    if (!template) throw new Error(`Missing template: ${id}`);
+    return template;
+};
+
 describe('AUTOMATION_TEMPLATES', () => {
-    it('has exactly six, with unique ids and unique titles', () => {
-        expect(AUTOMATION_TEMPLATES).toHaveLength(6);
-        expect(new Set(AUTOMATION_TEMPLATES.map((t) => t.id)).size).toBe(6);
-        expect(new Set(AUTOMATION_TEMPLATES.map((t) => t.title)).size).toBe(6);
+    it('has exactly ten, with unique ids and unique titles', () => {
+        expect(AUTOMATION_TEMPLATES).toHaveLength(10);
+        expect(new Set(AUTOMATION_TEMPLATES.map((t) => t.id)).size).toBe(10);
+        expect(new Set(AUTOMATION_TEMPLATES.map((t) => t.title)).size).toBe(10);
     });
 
     it('names the fields you will change on every card', () => {
@@ -47,14 +53,36 @@ describe('AUTOMATION_TEMPLATES', () => {
         }
     });
 
-    it('gives each template its OWN pattern, comparison and message', () => {
-        const patterns = AUTOMATION_TEMPLATES.map((t) => t.rule.graph.parse.find);
-        const messages = AUTOMATION_TEMPLATES.map((t) => t.rule.graph.action.message);
-        expect(new Set(patterns).size).toBe(6);
-        expect(new Set(messages).size).toBe(6);
-        // At least one of each comparison shape, so the set is not six numeric rules wearing
+    /**
+     * NOT "each its OWN", which this test claimed while asserting something weaker. `backoff` is
+     * deliberately `ratelimit` plus a Teams webhook — spec C4's fan-out — so it shares that
+     * template's pattern AND its message. The old name was true of the original six and quietly
+     * became false when the tenth arrived.
+     *
+     * The counts stay EXACT, so a second collision still fails; and the one permitted duplicate is
+     * named, so `length - 1` cannot be satisfied by some other pair colliding instead.
+     *
+     * Comparisons are left out of the claim because they *cannot* be distinct: every text rule's
+     * comparison is the same `{ text, null, null }` triple. That both kinds occur is the strongest
+     * true statement available, and it is what the assertion below actually makes.
+     */
+    it('gives each template its own pattern and message, bar one deliberate duplicate', () => {
+        const patterns = AUTOMATION_TEMPLATES.flatMap((t) => (
+            t.rule.graph.parse ? [t.rule.graph.parse.find] : []
+        ));
+        const messages = AUTOMATION_TEMPLATES.flatMap((t) => (
+            t.rule.graph.action ? [t.rule.graph.action.message] : []
+        ));
+        expect(new Set(patterns).size).toBe(patterns.length - 1);
+        expect(new Set(messages).size).toBe(messages.length - 1);
+        expect(byId('backoff').rule.graph.parse?.find).toBe(byId('ratelimit').rule.graph.parse?.find);
+        expect(byId('backoff').rule.graph.action?.message)
+            .toBe(byId('ratelimit').rule.graph.action?.message);
+        // At least one of each comparison shape, so the set is not ten numeric rules wearing
         // different names.
-        const kinds = AUTOMATION_TEMPLATES.map((t) => t.rule.graph.cond.kind);
+        const kinds = AUTOMATION_TEMPLATES.flatMap((t) => (
+            t.rule.graph.cond ? [t.rule.graph.cond.kind] : []
+        ));
         expect(kinds).toContain('number');
         expect(kinds).toContain('text');
     });
@@ -63,42 +91,85 @@ describe('AUTOMATION_TEMPLATES', () => {
         // A template that ships an uncompilable pattern is a rule the engine refuses at load, and
         // the gallery would offer it anyway.
         for (const t of AUTOMATION_TEMPLATES) {
-            expect(() => new RegExp(t.rule.graph.parse.find)).not.toThrow();
+            if (t.rule.graph.parse) expect(() => new RegExp(t.rule.graph.parse.find)).not.toThrow();
         }
     });
 
     it('every numeric template captures a group, and every bracket-keeping one has one', () => {
         for (const t of AUTOMATION_TEMPLATES) {
-            if (t.rule.graph.parse.keep !== 'brackets') continue;
+            const parse = t.rule.graph.parse;
+            if (!parse || parse.keep !== 'brackets') continue;
             // `Keep: the number in brackets` reads capture group 1. Without a group the engine has
             // nothing to keep, and the save gate refuses it — so a template must not ship one.
-            expect(new RegExp(t.rule.graph.parse.find).exec('') === null).toBe(true);
-            expect(t.rule.graph.parse.find).toMatch(/\((?!\?)/);
+            expect(new RegExp(parse.find).exec('') === null).toBe(true);
+            expect(parse.find).toMatch(/\((?!\?)/);
         }
     });
 
     it('keeps the literal AND the escaped pattern for an exact-words template', () => {
         // Re-opening the rule must show the user's own text back, not `proceed\?`, which they would
         // then helpfully "fix".
-        const prompt = AUTOMATION_TEMPLATES.find((t) => t.id === 'prompt')!;
-        expect(prompt.rule.graph.parse.literal).toBe('Do you want to proceed?');
-        expect(prompt.rule.graph.parse.find).toBe('Do you want to proceed\\?');
+        const parse = byId('prompt').rule.graph.parse;
+        if (!parse) throw new Error('Prompt template needs a parse step');
+        expect(parse.literal).toBe('Do you want to proceed?');
+        expect(parse.find).toBe('Do you want to proceed\\?');
     });
 
     it('has exactly one template that deliberately does not press Enter', () => {
-        const quiet = AUTOMATION_TEMPLATES.filter((t) => !t.rule.graph.action.submit);
+        const quiet = AUTOMATION_TEMPLATES.filter((t) => t.rule.graph.action?.submit === false);
         expect(quiet.map((t) => t.id)).toEqual(['prompt']);
     });
 
+    it('builddiscord is webhook-only, with a Discord provider and a capturing pattern', () => {
+        const t = byId('builddiscord');
+        expect(t.rule.graph.action).toBeUndefined();
+        expect(t.rule.graph.webhook?.provider).toBe('discord');
+        expect(t.rule.graph.parse?.find).toMatch(/\\d/);
+        expect(t.rule.graph.webhook?.substitute).toBe(true);
+    });
+
+    it('backoff has BOTH destinations', () => {
+        const graph = byId('backoff').rule.graph;
+        expect(graph.action?.message).toBe('/wait 60');
+        expect(graph.webhook?.provider).toBe('teams');
+    });
+
+    it('nightly and settle cover both Wait modes, by id', () => {
+        expect(byId('nightly').rule.graph.timer?.mode).toEqual({
+            dailyAt: { minuteOfDay: 2 * 60, days: 0b0001_1111 },
+        });
+        expect(byId('settle').rule.graph.timer?.mode).toEqual({
+            afterMatch: { delayMs: 30_000 },
+        });
+    });
+
+    it('no template ships a real webhook URL', () => {
+        for (const t of AUTOMATION_TEMPLATES) expect(t.rule.graph.webhook?.url ?? '').toBe('');
+    });
+
     it('hands out a deep copy, so editing one draft cannot poison the next', () => {
-        const first = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
+        const first = draftFromTemplate(byId('ctx'));
+        if (!first.graph.action) throw new Error('Context template needs an action step');
         first.graph.action.message = 'mutated';
         first.targetIds.push('tm-1');
-        const second = draftFromTemplate(AUTOMATION_TEMPLATES[0]);
+        const second = draftFromTemplate(byId('ctx'));
+        if (!second.graph.action) throw new Error('Context template needs an action step');
         expect(second.graph.action.message).not.toBe('mutated');
         expect(second.targetIds).toEqual([]);
     });
 
+    it('clones a template with no action without creating one', () => {
+        const base = byId('ctx');
+        const { action: _action, ...graph } = base.rule.graph;
+        const withoutAction: AutomationTemplate = {
+            ...base,
+            rule: { ...base.rule, graph },
+        };
+
+        expect(() => draftFromTemplate(withoutAction)).not.toThrow();
+        expect(draftFromTemplate(withoutAction).graph).not.toHaveProperty('action');
+    });
+
     /**
      * **A hand-rolled copy that rebuilds a shape field by field drops the next field silently.**
      *
@@ -113,11 +184,12 @@ describe('AUTOMATION_TEMPLATES', () => {
      * says nothing about a key the source has and the copy never mentions.
      */
     it('carries every graph field a rule can have, not just the four a template happens to set', () => {
-        const base = AUTOMATION_TEMPLATES[0];
+        const base = byId('ctx');
         const full: AutomationTemplate = {
             ...base,
             rule: {
                 ...base.rule,
+                excludedIds: ['tm-excluded'],
                 graph: {
                     ...base.rule.graph,
                     cond: {
@@ -129,6 +201,12 @@ describe('AUTOMATION_TEMPLATES', () => {
                     },
                     // The two the field-by-field rebuild dropped.
                     timer: { mode: { afterMatch: { delayMs: 30_000 } } },
+                    webhook: {
+                        provider: 'discord',
+                        url: '',
+                        body: 'Build failed — $1 red',
+                        substitute: true,
+                    },
                     layout: {
                         monitor: { x: 11, y: 12 },
                         parse: { x: 21, y: 22 },
@@ -146,12 +224,21 @@ describe('AUTOMATION_TEMPLATES', () => {
         // **And it is a COPY, which deep equality cannot see.** A nested member left shared with
         // the frozen module-level template satisfies both assertions above and still lets an
         // editor reach back into it — which is the entire reason this function exists.
-        clone.graph.timer!.mode = { afterMatch: { delayMs: 1 } };
-        clone.graph.layout!.monitor.x = 999;
-        clone.graph.cond!.clauses![0].test = { number: { op: 'gt', value: 1 } };
+        const { timer, webhook, layout, cond } = clone.graph;
+        const excludedIds = clone.excludedIds;
+        if (!timer || !webhook || !layout || !cond?.clauses || !excludedIds) {
+            throw new Error('Full graph clone lost a nested step');
+        }
+        timer.mode = { afterMatch: { delayMs: 1 } };
+        webhook.body = 'mutated';
+        layout.monitor.x = 999;
+        cond.clauses[0].test = { number: { op: 'gt', value: 1 } };
+        excludedIds.push('tm-another');
         expect(full.rule.graph.timer).toEqual({ mode: { afterMatch: { delayMs: 30_000 } } });
+        expect(full.rule.graph.webhook!.body).toBe('Build failed — $1 red');
         expect(full.rule.graph.layout!.monitor).toEqual({ x: 11, y: 12 });
         expect(full.rule.graph.cond!.clauses![0].test).toEqual({ number: { op: 'lt', value: 90 } });
+        expect(full.rule.excludedIds).toEqual(['tm-excluded']);
     });
 });
 
diff --git a/src/renderer/components/Settings/Automations/activityLog.ts b/src/renderer/components/Settings/Automations/activityLog.ts
index 312de25d..4267c385 100644
--- a/src/renderer/components/Settings/Automations/activityLog.ts
+++ b/src/renderer/components/Settings/Automations/activityLog.ts
@@ -12,6 +12,7 @@
  * rewrite the past, which is the same mistake as looking a terminal's name up instead of storing it.
  */
 import type { AutomationLogEntry, AutomationLogKind } from '../../../types/electron';
+import { redactWebhookLogEntry } from '../../Automation/webhookRedaction';
 
 /** The word the log column shows, in the mockup's own vocabulary. */
 export const LOG_KIND_LABEL: Record<AutomationLogKind, string> = {
@@ -162,9 +163,10 @@ export function collapsedDetail(row: LogRow): string {
 export function logCopyText(entries: AutomationLogEntry[]): string {
     return entries
         .map((e) => {
-            const who = e.terminalId ?? '—';
-            const name = e.terminalName ? ` ${e.terminalName}` : '';
-            return `${clockTime(e.at)}\t${who}${name}\t${LOG_KIND_LABEL[e.kind]}\t${e.detail}`;
+            const safe = redactWebhookLogEntry(e);
+            const who = safe.terminalId ?? '—';
+            const name = safe.terminalName ? ` ${safe.terminalName}` : '';
+            return `${clockTime(safe.at)}\t${who}${name}\t${LOG_KIND_LABEL[safe.kind]}\t${safe.detail}`;
         })
         .join('\n');
 }
diff --git a/src/renderer/components/Settings/Automations/automationTemplates.ts b/src/renderer/components/Settings/Automations/automationTemplates.ts
index bfb6a1ed..9b41afac 100644
--- a/src/renderer/components/Settings/Automations/automationTemplates.ts
+++ b/src/renderer/components/Settings/Automations/automationTemplates.ts
@@ -1,5 +1,5 @@
 /**
- * The six built-in templates (mockup §02), frozen in the renderer — the `COLOR_SCHEMAS` precedent.
+ * The ten built-in templates (mockup §02), frozen in the renderer — the `COLOR_SCHEMAS` precedent.
  *
  * **A template never reaches the engine until the user switches it on.** It lands as an unsaved
  * draft with `enabled: false`, and that — not validation — is the safety property: nothing a
@@ -11,7 +11,7 @@
  * enableable straight away**, and what the user changes is the threshold or the message.
  *
  * *(This comment used to say a fresh template "always has exactly one problem left to fix", and so
- * did the gallery's own note and plan §10.19. It is not true of any of the six: only a **pinned**
+ * did the gallery's own note and plan §10.19. It was not true of any of the original six: only a **pinned**
  * rule can be empty in a way validation can see, and none of these are pinned. M5's own validation
  * test is what made the claim testable, and it failed on all six.)*
  *
@@ -78,6 +78,7 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     sendTo: 'matched',
                     submit: true,
                     cliType: 'default',
+                    substitute: true,
                 },
             },
         },
@@ -113,6 +114,7 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     sendTo: 'matched',
                     submit: true,
                     cliType: 'default',
+                    substitute: true,
                 },
             },
         },
@@ -143,6 +145,7 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     sendTo: 'matched',
                     submit: true,
                     cliType: 'default',
+                    substitute: true,
                 },
             },
         },
@@ -182,6 +185,7 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     // The whole point of this template: the text lands in the composer unsubmitted.
                     submit: false,
                     cliType: 'default',
+                    substitute: true,
                 },
             },
         },
@@ -212,7 +216,7 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     keep: 'brackets',
                 },
                 cond: { kind: 'number', op: 'lt', threshold: 5 },
-                action: { message: 'df -h', sendTo: 'matched', submit: true, cliType: 'default' },
+                action: { message: 'df -h', sendTo: 'matched', submit: true, cliType: 'default', substitute: true },
             },
         },
     },
@@ -242,7 +246,148 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
                     keep: 'brackets',
                 },
                 cond: { kind: 'number', op: 'lt', threshold: 20 },
-                action: { message: '/compact', sendTo: 'matched', submit: true, cliType: 'default' },
+                action: { message: '/compact', sendTo: 'matched', submit: true, cliType: 'default', substitute: true },
+            },
+        },
+    },
+    {
+        id: 'nightly',
+        title: 'Nightly deploy window',
+        accent: 'action',
+        why:
+            'No pattern and nothing to watch — the clock is the whole trigger. If the machine was '
+            + 'asleep when the minute passed it writes a Held row saying so, rather than delivering a '
+            + 'stale instruction on wake.',
+        youllChange: ['time', 'message'],
+        rule: {
+            name: 'Nightly deploy window',
+            enabled: false,
+            runsOnce: false,
+            targetMode: 'rule',
+            criterion: 'allTerminals',
+            criterionValue: '',
+            followNew: true,
+            targetIds: [],
+            graph: {
+                timer: { mode: { dailyAt: { minuteOfDay: 2 * 60, days: 0b0001_1111 } } },
+                action: {
+                    message: '/run nightly deploy',
+                    sendTo: 'matched',
+                    submit: true,
+                    cliType: 'default',
+                    substitute: true,
+                },
+            },
+        },
+    },
+    {
+        id: 'settle',
+        title: 'Let it settle, then retry',
+        accent: 'action',
+        why:
+            'Gives a flaky endpoint time to come back before trying again, instead of retrying on '
+            + 'the same instant it failed. The wait sits between the verdict and the send, so one '
+            + 'crossing still produces exactly one retry.',
+        youllChange: ['delay', 'message'],
+        rule: {
+            name: 'Let it settle, then retry',
+            enabled: false,
+            runsOnce: false,
+            targetMode: 'rule',
+            criterion: 'allTerminals',
+            criterionValue: '',
+            followNew: true,
+            targetIds: [],
+            graph: {
+                monitor: { read: 'newOutput', cadence: 'onOutput', everyMs: EVERY_30S },
+                parse: {
+                    preset: 'exactWords',
+                    literal: 'connection refused',
+                    find: 'connection refused',
+                    keep: 'whole',
+                },
+                cond: { kind: 'text', op: null, threshold: null },
+                timer: { mode: { afterMatch: { delayMs: EVERY_30S } } },
+                action: { message: '/retry', sendTo: 'matched', submit: true, cliType: 'default', substitute: true },
+            },
+        },
+    },
+    {
+        id: 'builddiscord',
+        title: 'Build failure to Discord',
+        accent: 'parse',
+        why:
+            'Announces the failure in a channel and types nothing at all. The first template with '
+            + 'no terminal send — which is what you want when the build runs unattended and nobody is '
+            + 'watching the tab.',
+        youllChange: ['webhook URL', 'message'],
+        rule: {
+            name: 'Build failure to Discord',
+            enabled: false,
+            runsOnce: false,
+            targetMode: 'rule',
+            criterion: 'allTerminals',
+            criterionValue: '',
+            followNew: true,
+            targetIds: [],
+            graph: {
+                monitor: { read: 'newOutput', cadence: 'onOutput', everyMs: EVERY_30S },
+                parse: {
+                    preset: 'custom',
+                    literal: null,
+                    find: 'FAILED (\\d+) tests?',
+                    keep: 'whole',
+                },
+                cond: { kind: 'text', op: null, threshold: null },
+                webhook: {
+                    provider: 'discord',
+                    url: '',
+                    body: 'Build failed — $1 red',
+                    substitute: true,
+                },
+            },
+        },
+    },
+    {
+        id: 'backoff',
+        title: 'Back off, and tell the team',
+        accent: 'cond',
+        why:
+            'Both destinations off one yes: the agent backs off and the channel learns the provider '
+            + 'is throttling. Either half can fail without disturbing the other — the log gets a row '
+            + 'for each.',
+        youllChange: ['webhook URL', 'message'],
+        rule: {
+            name: 'Back off, and tell the team',
+            enabled: false,
+            runsOnce: false,
+            targetMode: 'rule',
+            criterion: 'commandContains',
+            criterionValue: 'claude',
+            followNew: true,
+            targetIds: [],
+            graph: {
+                monitor: { read: 'newOutput', cadence: 'onOutput', everyMs: EVERY_30S },
+                parse: {
+                    preset: 'exactWords',
+                    literal: '429 Too Many',
+                    find: '429 Too Many',
+                    keep: 'whole',
+                },
+                cond: { kind: 'text', op: null, threshold: null },
+                action: {
+                    message: '/wait 60',
+                    sendTo: 'matched',
+                    submit: true,
+                    cliType: 'default',
+                    substitute: true,
+                },
+                webhook: {
+                    provider: 'teams',
+                    url: '',
+                    body: '429 Too Many',
+                    substitute: true,
+                },
             },
         },
     },
@@ -258,7 +403,8 @@ export const AUTOMATION_TEMPLATES: readonly AutomationTemplate[] = Object.freeze
  *
  * `targetIds` is empty **by construction**, not by omission — but that is not a problem the rule
  * has: every template targets by CRITERION, and only a pinned rule can be empty in a way validation
- * can see. All six report zero problems, which `automationValidation.test.ts` asserts.
+ * can see. Templates without a webhook report zero problems; the two webhook templates report
+ * only their deliberately blank webhook URL.
  */
 export function draftFromTemplate(template: AutomationTemplate): AutomationRule {
     return {
@@ -274,9 +420,9 @@ export function draftFromTemplate(template: AutomationTemplate): AutomationRule
 }
 
 /**
- * A blank draft — the gallery's seventh card.
+ * A blank draft — the gallery's eleventh card.
  *
- * Not a seventh template: it has no starter pattern, no message and no criterion, so the six-item
+ * Not an eleventh template: it has no starter pattern, no message and no criterion, so the ten-item
  * table above stays a table of *rules that already work*.
  */
 export function blankDraft(): AutomationRule {
@@ -298,7 +444,7 @@ export function blankDraft(): AutomationRule {
             monitor: { read: 'newOutput', cadence: 'onOutput', everyMs: EVERY_30S },
             parse: { preset: 'custom', literal: null, find: '', keep: 'whole' },
             cond: { kind: 'text', op: null, threshold: null },
-            action: { message: '', sendTo: 'matched', submit: true, cliType: 'default' },
+            action: { message: '', sendTo: 'matched', submit: true, cliType: 'default', substitute: true },
         },
         createdAt: 0,
         updatedAt: 0,
@@ -330,7 +476,13 @@ function structuredCloneRule(rule: TemplateRule): TemplateRule {
     if (graph.parse) graph.parse = deep(graph.parse);
     if (graph.cond) graph.cond = deep(graph.cond);
     if (graph.timer) graph.timer = deep(graph.timer);
-    graph.action = deep(graph.action);
+    if (graph.action) graph.action = deep(graph.action);
+    if (graph.webhook) graph.webhook = deep(graph.webhook);
     if (graph.layout) graph.layout = deep(graph.layout);
-    return { ...rule, targetIds: [...rule.targetIds], graph };
+    return {
+        ...rule,
+        targetIds: [...rule.targetIds],
+        ...(rule.excludedIds ? { excludedIds: [...rule.excludedIds] } : {}),
+        graph,
+    };
 }
diff --git a/src/renderer/components/Settings/Automations/useAutomations.ts b/src/renderer/components/Settings/Automations/useAutomations.ts
index d1c5b2f6..0eac1c32 100644
--- a/src/renderer/components/Settings/Automations/useAutomations.ts
+++ b/src/renderer/components/Settings/Automations/useAutomations.ts
@@ -20,6 +20,7 @@ import {
     AUTOMATION_STATE,
 } from '../../../services/automationEvents';
 import { mergeEntries } from './activityLog';
+import { redactWebhookError, redactWebhookLogEntry } from '../../Automation/webhookRedaction';
 
 /**
  * The log the panel holds in memory. The store keeps 200 per rule; holding more here would be a
@@ -103,7 +104,7 @@ export function useAutomations(): UseAutomations {
             setError(null);
         } catch (e) {
             if (genRef.current !== gen) return;
-            setError(e instanceof Error ? e.message : String(e));
+            setError(redactWebhookError(e));
         } finally {
             if (genRef.current === gen) setLoading(false);
         }
@@ -124,7 +125,12 @@ export function useAutomations(): UseAutomations {
             // Merged rather than replaced: an `automation:activity` event can arrive while this
             // request is in flight, and the entry it stands for must not be dropped by a response
             // that was assembled before it existed.
-            setLog((prev) => mergeEntries(prev, rows, scope.newestFirst, LOG_BUFFER_MAX));
+            setLog((prev) => mergeEntries(
+                prev,
+                rows.map(redactWebhookLogEntry),
+                scope.newestFirst,
+                LOG_BUFFER_MAX,
+            ));
             setLogError(null);
         } catch (e) {
             if (genRef.current !== gen || scopeRef.current !== scope) return;
@@ -135,7 +141,7 @@ export function useAutomations(): UseAutomations {
             // which is a confident, specific lie about a store that is refusing to answer. §7.8
             // assigns the `Disabled` state to the panel AND the log view, separately, for this
             // reason.
-            setLogError(e instanceof Error ? e.message : String(e));
+            setLogError(redactWebhookError(e));
         }
     }, []);
 
diff --git a/src/renderer/components/UI/ToastContainer.css b/src/renderer/components/UI/ToastContainer.css
index 8b0737d0..774700f0 100644
--- a/src/renderer/components/UI/ToastContainer.css
+++ b/src/renderer/components/UI/ToastContainer.css
@@ -17,6 +17,26 @@
   top: 96px;
 }
 
+/*
+ * The automation editor is a 95vw x 95vh dialog, so there is no margin to hide in: a toast at the
+ * default top-right sits on the editor's own header, over Enabled / Test / Save / Delete. A toast
+ * is transient, so the second of two clicks aimed at one lands on the control it was covering.
+ *
+ * Bottom-LEFT is the corner with nothing to hit: the palette rail ends in the *This rule* summary,
+ * which is text. (When the activity drawer is open it reaches this corner — the drawer is opened
+ * deliberately and closed again, and nothing in its bottom-left is destructive.)
+ *
+ * Declared AFTER `--canvas` and overriding all four offsets, not just `top`: the editor can be
+ * opened from Canvas Mode, so both modifiers can be on the same element, and equal specificity
+ * makes source order the tie-break.
+ */
+.toast-container--automation {
+  top: auto;
+  right: auto;
+  bottom: 24px;
+  left: 24px;
+}
+
 .toast-stack {
   display: flex;
   flex-direction: column;
diff --git a/src/renderer/components/UI/ToastContainer.tsx b/src/renderer/components/UI/ToastContainer.tsx
index 37782d21..c7eaf77c 100644
--- a/src/renderer/components/UI/ToastContainer.tsx
+++ b/src/renderer/components/UI/ToastContainer.tsx
@@ -1,10 +1,14 @@
 import { createPortal } from 'react-dom';
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useEffect, useRef, useState, useSyncExternalStore } from 'react';
 import { useSelector, useDispatch } from 'react-redux';
 import { RootState } from '../../store';
 import { removeToast, dismissAllToasts, Toast as ToastType } from '../../store/slices/uiSlice';
 import { CANVAS_SHELL_TYPE } from '../../services/tabKinds';
 import { runToastAction } from '../../services/toastActions';
+import {
+    isAutomationEditorMounted,
+    subscribeAutomationEditorMounted,
+} from '../../services/automationEditorGuard';
 import './ToastContainer.css';
 
 // Mirrors SearchResults.tsx's formatTimestamp — same thresholds, kept local since toasts
@@ -92,6 +96,20 @@ export const ToastContainer: React.FC = () => {
         const activeTab = tabsState?.tabs?.find(t => t.id === tabsState.activeTabId);
         return activeTab?.shellType === CANVAS_SHELL_TYPE;
     });
+    /*
+     * The automation editor is a 95vw x 95vh dialog whose header carries Enabled, Test, Save and
+     * Delete — under the top-right corner these toasts occupy. Overlapping them is not just untidy:
+     * the toast is transient, so the second of two clicks aimed at it lands on whatever it was
+     * covering, which there is a destructive button.
+     *
+     * Read from the MOUNT registry rather than the open-request host, because the Settings page
+     * opens its editor without going through that host at all — see `automationEditorGuard.ts`.
+     */
+    const isAutomationEditorOpen = useSyncExternalStore(
+        subscribeAutomationEditorMounted,
+        isAutomationEditorMounted,
+        isAutomationEditorMounted,
+    );
     const dispatch = useDispatch();
     const [expanded, setExpanded] = useState(false);
     const stackRef = useRef<HTMLDivElement>(null);
@@ -125,7 +143,11 @@ export const ToastContainer: React.FC = () => {
     }, [isStacked]);
 
     const newestFirst = [...toasts].reverse();
-    const containerClass = `toast-container${isCanvasActive ? ' toast-container--canvas' : ''}`;
+    const containerClass = [
+        'toast-container',
+        isCanvasActive ? 'toast-container--canvas' : '',
+        isAutomationEditorOpen ? 'toast-container--automation' : '',
+    ].filter(Boolean).join(' ');
 
     // Shared between the collapsed and expanded headers so "clear everything" is always
     // one click away — not gated behind first finding and clicking expand.
diff --git a/src/renderer/components/UI/__tests__/ToastContainer.test.tsx b/src/renderer/components/UI/__tests__/ToastContainer.test.tsx
index a1056832..988aa11a 100644
--- a/src/renderer/components/UI/__tests__/ToastContainer.test.tsx
+++ b/src/renderer/components/UI/__tests__/ToastContainer.test.tsx
@@ -20,6 +20,10 @@ jest.mock('../ToastContainer.css', () => ({}));
 
 // eslint-disable-next-line import/first
 import { ToastContainer } from '../ToastContainer';
+import {
+    clearAutomationEditorGuard,
+    registerAutomationEditorGuard,
+} from '../../../services/automationEditorGuard';
 
 function makeStore() {
     return configureStore({ reducer: { ui: uiReducer } });
@@ -300,6 +304,35 @@ describe('ToastContainer — collapsed stack', () => {
         expect(toastRoot().classList.contains('toast-container--canvas')).toBe(true);
     });
 
+    /*
+     * The automation editor is a 95vw x 95vh dialog whose header holds Enabled, Test, Save and
+     * Delete, directly under the toasts' default corner. A toast is transient, so the second of two
+     * clicks aimed at one lands on the control it was covering.
+     *
+     * Driven through `registerAutomationEditorGuard`, which is what the editor itself calls on
+     * mount, rather than through the open-request host: the Settings page opens its editor without
+     * touching that host, so a test keyed on the host would pass while one of the two homes stayed
+     * broken.
+     */
+    it('moves out of the toast corner the automation editor needs, while one is mounted', () => {
+        const store = makeStore();
+        mount(store);
+        addSticky(store, 'solo');
+        expect(toastRoot().classList.contains('toast-container--automation')).toBe(false);
+
+        act(() => {
+            registerAutomationEditorGuard({
+                isDirty: () => false,
+                save: () => Promise.resolve(true),
+                discard: () => {},
+            });
+        });
+        expect(toastRoot().classList.contains('toast-container--automation')).toBe(true);
+
+        act(() => clearAutomationEditorGuard());
+        expect(toastRoot().classList.contains('toast-container--automation')).toBe(false);
+    });
+
     it('shows a relative "time ago" label that updates as time passes', () => {
         const store = makeStore();
         mount(store);
diff --git a/src/renderer/services/automationEditorGuard.ts b/src/renderer/services/automationEditorGuard.ts
index 7abf6df7..7366ebdf 100644
--- a/src/renderer/services/automationEditorGuard.ts
+++ b/src/renderer/services/automationEditorGuard.ts
@@ -40,12 +40,37 @@ export interface AutomationEditorGuard {
 
 let guard: AutomationEditorGuard | null = null;
 
+/**
+ * Subscribers to `isAutomationEditorMounted()`, so a surface OUTSIDE the editor can move out of its
+ * way while it is open — `ToastContainer` does, because the editor's own header controls sit exactly
+ * where the toasts land.
+ *
+ * Separate from the emit in `automationEditorHost.ts`: that one announces which rule was REQUESTED,
+ * and the Settings page's editor is not opened through it at all. Mount is the honest signal for
+ * "an editor is on screen", because it is the editor itself that registers, so both of its homes
+ * are covered without either caller having to remember to say so.
+ */
+const mountedListeners = new Set<() => void>();
+
+function emitMounted(): void {
+    mountedListeners.forEach((listener) => listener());
+}
+
+export function subscribeAutomationEditorMounted(listener: () => void): () => void {
+    mountedListeners.add(listener);
+    return () => {
+        mountedListeners.delete(listener);
+    };
+}
+
 export function registerAutomationEditorGuard(g: AutomationEditorGuard): void {
     guard = g;
+    emitMounted();
 }
 
 export function clearAutomationEditorGuard(): void {
     guard = null;
+    emitMounted();
 }
 
 export function isAutomationEditorDirty(): boolean {
diff --git a/src/renderer/styles/index.css b/src/renderer/styles/index.css
index b6faf69f..893080d8 100644
--- a/src/renderer/styles/index.css
+++ b/src/renderer/styles/index.css
@@ -14,4 +14,58 @@ body {
 #root {
   width: 100vw;
   height: 100vh;
-}
\ No newline at end of file
+}
+/*
+ * ---------------------------------------------------------------- scrollbars ---
+ *
+ * ONE rule for the whole app, and it is deliberately unscoped.
+ *
+ * Ten stylesheets had grown their own near-identical copy — the automation editor, the pane
+ * context menu, the playback viewer, search filters and results, and so on — which meant every
+ * scrollable surface was styled if and only if someone remembered it. The one that got noticed
+ * proves the shape of the failure: `.au-editor ::-webkit-scrollbar` covers everything INSIDE the
+ * editor, and the editor's own dropdown portals to `body` to escape a clipping ancestor, so it
+ * landed outside the selector and drew a bare Win32 scrollbar in the middle of a dark modal.
+ * A descendant selector cannot follow a portal; a global one has nothing to follow.
+ *
+ * Breadth is safe here in a way `* { }` never is: the only thing these pseudo-elements can match
+ * is a scrollbar. The per-component copies that remain are now redundant rather than wrong, and
+ * are left alone — deleting styling that already looks right is churn, and any of them may be
+ * deliberately different.
+ *
+ * `scrollbar-width`/`scrollbar-color` are the standard properties; WebKit ignores them and uses
+ * the pseudo-elements below, so both are stated rather than either alone.
+ */
+* {
+  scrollbar-width: thin;
+  scrollbar-color: #3a3c44 transparent;
+}
+
+::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+/* `border` rather than a narrower `width`: it insets the thumb from the track without shrinking
+   the hit area. Transparent + `background-clip: padding-box` so the inset shows whatever ground
+   the scrolling surface sits on, instead of pinning one panel's background colour app-wide —
+   which is the single thing that stopped the editor's copy from being liftable as it stood. */
+::-webkit-scrollbar-thumb {
+  background: #3a3c44;
+  border: 2px solid transparent;
+  background-clip: padding-box;
+  border-radius: 6px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #4f535e;
+  background-clip: padding-box;
+}
+
+::-webkit-scrollbar-corner {
+  background: transparent;
+}
diff --git a/src/renderer/types/electron.d.ts b/src/renderer/types/electron.d.ts
index 162952b8..917df6b4 100644
--- a/src/renderer/types/electron.d.ts
+++ b/src/renderer/types/electron.d.ts
@@ -385,8 +385,8 @@ export interface ElectronAPI {
   // (the browser host is a no-op).
   setKeepRunningInBackground?: (enabled: boolean) => Promise<void>;
 
-  // Terminal Automations (Plan 028) — the fourteen commands of `automation_commands.rs`.
-  // The first eleven are in the order that file declares them; the three id-only writers
+  // Terminal Automations (Plan 028) — the fifteen commands of `automation_commands.rs`.
+  // The first twelve are in the order that file declares them; the three id-only writers
   // that replaced a whole-rule `saveAutomation` — `addAutomationTarget`,
   // `removeAutomationTarget`, `setAutomationVerbose` — are listed last here as the newest
   // of them. All optional and all Tauri-only: the store is
@@ -403,7 +403,12 @@ export interface ElectronAPI {
   listWatchableTerminals?: (
     ruleId: string | null,
     includeIds: string[] | null,
+    criteria: AutomationCriterion[],
   ) => Promise<WatchableTerminal[]>;
+  previewAutomationTargets?: (
+    rule: AutomationRule,
+    terminals: WatchableTerminal[],
+  ) => Promise<AutomationTargetPreview>;
   dryRunAutomation?: (rule: AutomationRule, terminalId: string) => Promise<DryRunReport>;
   saveAutomation?: (rule: AutomationRule, origin: string) => Promise<AutomationSaveResult>;
   deleteAutomation?: (id: string, origin: string) => Promise<boolean>;
@@ -565,6 +570,14 @@ export interface AutomationMonitorStep {
   cadence: AutomationCadence;
   /** Only meaningful for `cadence: 'timer'`. */
   everyMs: number;
+  /**
+   * Drop the logical line the cursor sits on, so a command still being TYPED cannot fire the rule.
+   *
+   * **Optional, and absent when off** — the backend omits it, so a rule that never ticks the box
+   * keeps a blob an older build reads byte for byte. Only the cursor's own line goes: a TUI's
+   * status line sits BELOW the input box and is usually the very text such a rule watches for.
+   */
+  skipTypedLine?: boolean;
 }
 
 export interface AutomationParseStep {
@@ -607,6 +620,17 @@ export interface AutomationActionStep {
   substitute?: boolean;
 }
 
+export type AutomationWebhookProvider = 'discord' | 'teams' | 'slack' | 'custom';
+
+export interface AutomationWebhookStep {
+  provider: AutomationWebhookProvider;
+  /** Secret credential: carried over persistence and IPC, never rendered, logged, errored, or exported. */
+  url: string;
+  /** Plain message for preset providers; raw request body for `custom`. */
+  body: string;
+  substitute?: boolean;
+}
+
 /**
  * Optional fifth step — "Wait" in every user-facing string. **Never write the bare word "Timer" in
  * UI copy** — `AutomationCadence`'s `'timer'` already means the monitor's poll interval, a
@@ -645,7 +669,10 @@ export interface AutomationGraph {
   cond?: AutomationCondStep;
   /** Absent on every rule saved before this milestone and on every rule that does not use it. */
   timer?: AutomationTimerStep;
-  action: AutomationActionStep;
+  /** Optional terminal destination. Absence must stay absence: an empty action can submit Enter. */
+  action?: AutomationActionStep;
+  /** Optional webhook destination. Its URL is a secret and must never be used as display text. */
+  webhook?: AutomationWebhookStep;
   /**
    * Where the editor's four cards sit on its canvas. View state, and the engine never reads it —
    * it rides in the rule so that ONE save writes the whole document. Absent on any rule written
@@ -668,6 +695,12 @@ export interface AutomationRule {
   followNew: boolean;
   /** Durable `tm-` leaves. Never `pc-` process ids, which are per-run. */
   targetIds: string[];
+  /** Rule-mode terminal ids removed after the criterion resolves. */
+  excludedIds?: string[];
+  /** An optional rule-mode selector whose matches are removed from the watched set. */
+  excludeCriterion?: AutomationCriterion | null;
+  /** The optional selector's value; `allTerminals` deliberately leaves it blank. */
+  excludeCriterionValue?: string;
 
   completedAt?: number | null;
   verboseUntil?: number | null;
@@ -713,7 +746,7 @@ export interface AutomationLogEntry {
  */
 export interface DryRunStep {
   /**
-   * `monitor` | `parse` | `cond` | `timer` | `action` — **not always all five, and not one fixed
+   * `monitor` | `parse` | `cond` | `timer` | `action` | `webhook` — **not always all five, and not one fixed
    * count.** A plain rule (no wait step) reports the original four, in the graph's order. A DELAY
    * rule (`timer.mode.afterMatch`) inserts `timer` between `cond` and `action`, five steps. A
    * SCHEDULE rule (`timer.mode.dailyAt`) has no `monitor`, `parse` or `cond` at all — it reads
@@ -723,7 +756,7 @@ export interface DryRunStep {
    * graph's order": that was already only true for a rule with no wait step, and plan 032 §6–§7 is
    * what made it stop being true for the other two shapes.
    */
-  kind: 'monitor' | 'parse' | 'cond' | 'timer' | 'action';
+  kind: 'monitor' | 'parse' | 'cond' | 'timer' | 'action' | 'webhook';
   /**
    * `skipped` is a step that never ran because an earlier one failed. It is not a pass and must
    * not be drawn as one.
@@ -791,5 +824,16 @@ export interface WatchableTerminal {
   pid?: number | null;
   /** The working folder, from OSC or the process snapshot. `folder` in §7.8's prose. */
   cwd?: string | null;
+  /** The tab/pane label that `Tab name contains` resolves against. */
+  displayLabel?: string | null;
+  /** The foreground process chain that `Command contains` resolves against. */
+  commandLines?: string[];
   alive: boolean;
 }
+
+/** The backend-owned target resolution the editor renders; every field is an id list, never a count. */
+export interface AutomationTargetPreview {
+  matched: string[];
+  excluded: string[];
+  watching: string[];
+}