nornir 0.4.20

//! 🗂 **Funnel** tab — the idea→plan DAG (DAG 2) as an interactive
//! [`egui_snarl`] node graph.
//!
//! A plan is literally a DAG: nodes carrying a `kind` + `status`, wired by
//! dependency edges. We lay it out **topologically** (longest-path layering →
//! one column per rank, deps strictly left of dependents) and render it with
//! egui-snarl, so it pans/zooms/drags like a modern node editor while the
//! topology stays readable. Node + pin tint encode lifecycle
//! (pending/ready/in-progress/done/blocked/failed).
//!
//! Data is read **embedded** (open the funnel `Store` locally) or **remote**
//! (the `Funnel.Show` gRPC RPC), collapsing into [`FunnelView`] — exactly the
//! local-or-remote split the call-graph + warehouse tabs use. Writing the
//! funnel stays where it belongs: the `nornir funnel` CLI and the `funnel_*`
//! MCP tools. This tab is the read/observe surface.

use std::collections::{BTreeMap, HashMap, VecDeque};
use std::path::PathBuf;

use eframe::egui::{self, Pos2};
use egui_snarl::ui::{PinInfo, SnarlStyle, SnarlViewer};
use egui_snarl::{InPin, InPinId, NodeId, OutPin, OutPinId, Snarl};

use super::facett_theme::{Theme, RED};
use super::funnel_view::{FunnelView, NodeStat, PlanView};

/// Horizontal gap between topological ranks, vertical gap between siblings.
const X_SPACING: f32 = 250.0;
const Y_SPACING: f32 = 120.0;

enum Src {
    Local(PathBuf),
    Remote { endpoint: String, token: String },
}

/// One snarl node = one plan node (the bits the viewer renders).
struct FunnelNode {
    id: String,
    kind: String,
    title: String,
    status: NodeStat,
    targets: Vec<String>,
}

pub struct FunnelTabState {
    src: Src,
    /// Selected workspace (the `nornir-workspace` gRPC header); empty for local.
    workspace: String,
    loaded: bool,
    error: Option<String>,
    view: Option<FunnelView>,
    sel_plan: Option<String>,
    /// The laid-out graph for `built_for`.
    snarl: Snarl<FunnelNode>,
    built_for: Option<String>,
    style: SnarlStyle,
    /// E1 demo control: `--size N` for `🌱 Run demo` (local mode only).
    demo_size: usize,
    /// Two-click confirm guard for `🗑 Nuke disk`: `true` after the first click,
    /// reset on the second (which actually nukes) or when leaving the tab.
    nuke_confirm_pending: bool,
    /// Last demo/nuke outcome line, surfaced in the panel + `state_json`.
    demo_status: Option<String>,
    /// Active facett palette (broadcast from the picker).
    theme: Theme,
}

impl FunnelTabState {
    pub fn local(root: PathBuf) -> Self {
        Self::with(Src::Local(root), String::new())
    }
    pub fn remote(endpoint: String, token: String, workspace: String) -> Self {
        Self::with(Src::Remote { endpoint, token }, workspace)
    }
    fn with(src: Src, workspace: String) -> Self {
        Self {
            src,
            workspace,
            loaded: false,
            error: None,
            view: None,
            sel_plan: None,
            snarl: Snarl::new(),
            built_for: None,
            style: SnarlStyle::new(),
            demo_size: 1,
            nuke_confirm_pending: false,
            demo_status: None,
            theme: Theme::default(),
        }
    }

    /// Re-skin this pane with a facett palette (broadcast from the picker).
    pub fn set_palette(&mut self, t: Theme) {
        self.theme = t;
    }

    /// Local warehouse root this tab reads (and the demo writes to), or `None`
    /// in remote mode (where the demo controls are disabled).
    fn local_root(&self) -> Option<PathBuf> {
        match &self.src {
            Src::Local(root) => Some(root.clone()),
            Src::Remote { .. } => None,
        }
    }

    /// Force a re-read of the funnel on the next frame (after a demo/nuke wrote
    /// to the warehouse).
    fn invalidate(&mut self) {
        self.loaded = false;
        self.view = None;
        self.built_for = None;
    }

    /// Re-scope to a different workspace (the picker switched).
    pub(crate) fn set_workspace(&mut self, workspace: String) {
        self.workspace = workspace;
        self.loaded = false;
        self.error = None;
        self.view = None;
        self.sel_plan = None;
        self.built_for = None;
        self.snarl = Snarl::new();
        self.nuke_confirm_pending = false;
        self.demo_status = None;
    }

    fn load_view(&self) -> Result<FunnelView, String> {
        match &self.src {
            Src::Local(root) => crate::funnel::Store::open(root)
                .map(|mut store| {
                    // Derive the Pending→Ready frontier so the rendered DAG shows
                    // the same readiness the CLI's `next`/`show` compute (the
                    // persisted status is always Pending — readiness is a derived
                    // projection, never stored).
                    store.funnel.promote_ready();
                    FunnelView::from_funnel(&store.funnel)
                })
                .map_err(|e| format!("{e:#}")),
            Src::Remote { endpoint, token } => {
                super::remote::funnel_show(endpoint, token, &self.workspace)
                    .map_err(|e| format!("{e:#}"))
            }
        }
    }

    fn ensure_loaded(&mut self, log: &super::action_log::ActionLog) {
        if self.loaded {
            return;
        }
        self.loaded = true;
        match self.load_view() {
            Ok(v) => {
                if self.sel_plan.is_none() {
                    self.sel_plan = v.plans.first().map(|p| p.id.clone());
                }
                self.view = Some(v);
            }
            Err(e) => {
                // Surface the load failure into the 🐞 action-trail + stderr
                // (Kind::Error already writes stderr) — only on the transition
                // into error (this runs once per load, not every frame), so the
                // funnel red text is never invisible again.
                log.push(
                    super::action_log::Kind::Error,
                    format!("funnel load failed (workspace={}): {e}", self.workspace),
                );
                self.error = Some(e);
            }
        }
    }

    pub fn draw(&mut self, ui: &mut egui::Ui, log: &super::action_log::ActionLog) {
        let theme = self.theme;
        self.ensure_loaded(log);

        if let Some(err) = self.error.clone() {
            ui.colored_label(RED, err);
            return;
        }
        let plans_empty = match self.view.as_ref() {
            Some(v) => v.plans.is_empty(),
            None => {
                ui.label("loading funnel…");
                return;
            }
        };
        if plans_empty {
            // Demo controls still show in the empty state (the whole point of
            // 🌱 Run demo is to fill an empty funnel), then the CLI hint.
            egui::TopBottomPanel::top("funnel_demo_controls").show_inside(ui, |ui| {
                self.demo_panel(ui, log);
            });
            ui.vertical_centered(|ui| {
                ui.add_space(40.0);
                ui.heading("🗂 Funnel — no plans yet");
                ui.label("Feed the funnel from the CLI, then it appears here:");
                ui.monospace("nornir funnel submit \"<krav / prompt>\"");
                ui.monospace("nornir funnel plan <idea-id> \"<summary>\"");
                ui.monospace("nornir funnel node <plan-id> --kind … --needs …");
                ui.add_space(8.0);
                ui.label("…or click 🌱 Run demo above to inject a fake dep-graph plan.");
            });
            return;
        }
        let view = self.view.as_ref().expect("view present (checked above)");

        // Decide the selected plan, then (re)build the snarl graph if it changed.
        let sel = self
            .sel_plan
            .clone()
            .filter(|s| view.plans.iter().any(|p| &p.id == s))
            .unwrap_or_else(|| view.plans[0].id.clone());
        let to_build = if self.built_for.as_deref() != Some(sel.as_str()) {
            view.plans.iter().find(|p| p.id == sel).cloned()
        } else {
            None
        };
        if let Some(plan) = to_build {
            self.snarl = build_snarl(&plan);
            self.built_for = Some(plan.id.clone());
        }
        self.sel_plan = Some(sel.clone());

        egui::TopBottomPanel::top("funnel_controls").show_inside(ui, |ui| {
            ui.horizontal_wrapped(|ui| {
                ui.label("plan:");
                let cur = self
                    .view
                    .as_ref()
                    .and_then(|v| v.plans.iter().find(|p| p.id == sel))
                    .map(|p| format!("{} · {}", p.id, p.status))
                    .unwrap_or_else(|| sel.clone());
                egui::ComboBox::from_id_salt("funnel_plan")
                    .selected_text(cur)
                    .show_ui(ui, |ui| {
                        let plans: Vec<(String, String)> = self
                            .view
                            .as_ref()
                            .map(|v| v.plans.iter().map(|p| (p.id.clone(), p.status.clone())).collect())
                            .unwrap_or_default();
                        for (id, status) in plans {
                            if ui
                                .selectable_label(
                                    self.sel_plan.as_deref() == Some(&id),
                                    format!("{id} · {status}"),
                                )
                                .clicked()
                            {
                                self.sel_plan = Some(id);
                            }
                        }
                    });
                if ui.button("↻ reload").on_hover_text("re-read the funnel").clicked() {
                    self.loaded = false;
                    self.view = None;
                    self.built_for = None;
                }
                ui.separator();
                legend(ui, &theme);
            });
            self.demo_panel(ui, log);
        });

        egui::CentralPanel::default().show_inside(ui, |ui| {
            // Plan header: summary + originating idea + DAG size.
            if let Some(plan) = self.view.as_ref().and_then(|v| v.plans.iter().find(|p| p.id == sel)) {
                let edges: usize = plan.nodes.iter().map(|n| n.deps.len()).sum();
                ui.horizontal(|ui| {
                    ui.strong(&plan.summary);
                    ui.weak(format!("· {} nodes, {} deps", plan.nodes.len(), edges));
                });
                if !plan.idea_text.is_empty() {
                    ui.label(
                        egui::RichText::new(format!("💡 {}", plan.idea_text))
                            .italics()
                            .size(11.0)
                            .color(theme.text_dim),
                    );
                }
                ui.add_space(2.0);
            }
            // The DAG. egui-snarl owns pan/zoom/drag; topology is preset by
            // the layered insert positions.
            let mut viewer = FunnelViewer { theme };
            self.snarl.show(&mut viewer, &self.style, "funnel_snarl_canvas", ui);
        });
    }

    /// E1 demo control strip: `🌱 Run demo` (+ size) and a two-click
    /// confirm-guarded `🗑 Nuke disk`. Local mode only — in remote mode the
    /// buttons are disabled with an explanatory tooltip (the warehouse the demo
    /// writes to lives on the server, not the viz host).
    fn demo_panel(&mut self, ui: &mut egui::Ui, log: &super::action_log::ActionLog) {
        let theme = self.theme;
        let root = self.local_root();
        // `NORNIR_FUNNEL_DEMO_DISABLED` lets the headless crash-hunt click the
        // demo buttons without performing real disk/warehouse I/O on the live
        // workspaces — the buttons render + respond but are disabled.
        let demo_disabled = std::env::var_os("NORNIR_FUNNEL_DEMO_DISABLED").is_some();
        let is_local = root.is_some();
        let enabled = is_local && !demo_disabled;
        ui.horizontal_wrapped(|ui| {
            ui.label("demo:");
            ui.add_enabled_ui(enabled, |ui| {
                let run = ui
                    .button("🌱 Run demo")
                    .on_hover_text("Inject a fake dep-graph plan into the funnel + create fake repos on disk")
                    .on_disabled_hover_text("Demo is local-mode only (remote warehouse lives on the server)");
                ui.add(
                    egui::DragValue::new(&mut self.demo_size)
                        .range(1..=64)
                        .prefix("size "),
                );
                if run.clicked() {
                    if let Some(root) = &root {
                        match crate::funnel::demo::run_demo(root, self.demo_size) {
                            Ok(m) => {
                                let msg = format!(
                                    "🌱 demo ran: {} fake repo(s), funnel DAG injected",
                                    m.repos.len()
                                );
                                log.push(super::action_log::Kind::Click, msg.clone());
                                self.demo_status = Some(msg);
                                self.invalidate();
                            }
                            Err(e) => {
                                let msg = format!("demo failed: {e:#}");
                                log.push(super::action_log::Kind::Error, msg.clone());
                                self.demo_status = Some(msg);
                            }
                        }
                    }
                    self.nuke_confirm_pending = false;
                }

                ui.separator();

                // Two-click nuke guard: first click arms, second click fires.
                if self.nuke_confirm_pending {
                    let confirm = ui
                        .button(egui::RichText::new("⚠ Confirm nuke (disk only)").color(RED))
                        .on_hover_text("Click again to delete the fake repos on disk");
                    let cancel = ui.button("✖ cancel").clicked();
                    if confirm.clicked() {
                        if let Some(root) = &root {
                            match crate::funnel::demo::nuke_disk(root) {
                                Ok(removed) => {
                                    let msg = format!(
                                        "🗑 nuked {} fake repo(s) on disk (warehouse funnel kept)",
                                        removed.len()
                                    );
                                    log.push(super::action_log::Kind::Click, msg.clone());
                                    self.demo_status = Some(msg);
                                }
                                Err(e) => {
                                    let msg = format!("nuke failed: {e:#}");
                                    log.push(super::action_log::Kind::Error, msg.clone());
                                    self.demo_status = Some(msg);
                                }
                            }
                        }
                        self.nuke_confirm_pending = false;
                    } else if cancel {
                        self.nuke_confirm_pending = false;
                    }
                } else if ui
                    .button("🗑 Nuke disk")
                    .on_hover_text("Delete the fake demo repos on disk (two-click confirm)")
                    .on_disabled_hover_text("Demo is local-mode only")
                    .clicked()
                {
                    self.nuke_confirm_pending = true;
                }
            });
        });
        ui.label(
            egui::RichText::new("Deletes fake repos on disk only — warehouse funnel data is kept.")
                .size(10.0)
                .color(theme.text_dim),
        );
        if let Some(status) = &self.demo_status {
            ui.label(egui::RichText::new(status).size(10.0).color(theme.text_dim));
        }
    }

    /// LAW 6 — the Funnel tab's readable state for `app.rs::state_json()`:
    /// selected plan, per-plan node/edge/ready counts, and a `demo` block
    /// (size, confirm-pending, last status). "See what the user sees" as data.
    pub fn state_json(&self) -> serde_json::Value {
        let plans: Vec<serde_json::Value> = self
            .view
            .as_ref()
            .map(|v| {
                v.plans
                    .iter()
                    .map(|p| {
                        let edges: usize = p.nodes.iter().map(|n| n.deps.len()).sum();
                        let ready = p
                            .nodes
                            .iter()
                            .filter(|n| n.status == NodeStat::Ready)
                            .count();
                        serde_json::json!({
                            "id": p.id,
                            "status": p.status,
                            "nodes": p.nodes.len(),
                            "edges": edges,
                            "ready_count": ready,
                        })
                    })
                    .collect()
            })
            .unwrap_or_default();
        let is_local = matches!(self.src, Src::Local(_));
        serde_json::json!({
            "palette": self.theme.name,
            "selected_plan": self.sel_plan,
            "plan_count": plans.len(),
            "plans": plans,
            "error": self.error,
            "demo": {
                "available": is_local,
                "size": self.demo_size,
                "confirm_pending": self.nuke_confirm_pending,
                "status": self.demo_status,
            },
        })
    }

    /// Test hook: run the demo exactly as the `🌱 Run demo` button does (inject
    /// the funnel DAG + materialise fake repos), then invalidate so the next
    /// `state_json`/`draw` re-reads the warehouse. Local mode only.
    pub fn run_demo_for_test(&mut self, size: usize) -> anyhow::Result<()> {
        let root = self.local_root().ok_or_else(|| anyhow::anyhow!("not local"))?;
        self.demo_size = size;
        crate::funnel::demo::run_demo(&root, size)?;
        // Re-read the warehouse now so the caller can assert state_json() at
        // once (mirrors what the next draw frame would do after invalidate()).
        self.reload_now();
        Ok(())
    }

    /// Re-read the funnel view from its source immediately (no draw frame
    /// needed). Used by the test hooks so `state_json()` reflects fresh data.
    fn reload_now(&mut self) {
        self.built_for = None;
        match self.load_view() {
            Ok(v) => {
                if self.sel_plan.is_none() {
                    self.sel_plan = v.plans.first().map(|p| p.id.clone());
                }
                self.view = Some(v);
                self.loaded = true;
                self.error = None;
            }
            Err(e) => {
                self.error = Some(e);
            }
        }
    }

    /// Test hook: first click on `🗑 Nuke disk` (arms the two-click guard).
    pub fn arm_nuke_for_test(&mut self) {
        self.nuke_confirm_pending = true;
    }

    /// Test hook: the confirming second click — actually nukes the disk repos.
    pub fn confirm_nuke_for_test(&mut self) -> anyhow::Result<Vec<std::path::PathBuf>> {
        let root = self.local_root().ok_or_else(|| anyhow::anyhow!("not local"))?;
        let removed = crate::funnel::demo::nuke_disk(&root)?;
        self.nuke_confirm_pending = false;
        Ok(removed)
    }

    /// Test hook: whether the two-click nuke guard is currently armed.
    pub fn nuke_confirm_pending(&self) -> bool {
        self.nuke_confirm_pending
    }

    /// Test hook: re-read the funnel from the warehouse now (so `state_json()`
    /// immediately reflects it).
    pub fn reload_for_test(&mut self) {
        self.reload_now();
    }
}

/// Longest-path layering (Kahn): `layer[n] = 0` for roots, else
/// `1 + max(layer[dep])`. Returns a layer per node, index-aligned with
/// `plan.nodes`. A cycle (shouldn't happen — `apply` rejects them) leaves the
/// unreached nodes at layer 0, which is still drawable.
fn topo_layers(plan: &PlanView) -> Vec<usize> {
    let n = plan.nodes.len();
    let idx: HashMap<&str, usize> =
        plan.nodes.iter().enumerate().map(|(i, nd)| (nd.id.as_str(), i)).collect();

    // dependents[u] = nodes that depend on u; indeg[v] = #known deps of v.
    let mut dependents: Vec<Vec<usize>> = vec![Vec::new(); n];
    let mut indeg = vec![0usize; n];
    for (v, node) in plan.nodes.iter().enumerate() {
        for dep in &node.deps {
            if let Some(&u) = idx.get(dep.as_str()) {
                dependents[u].push(v);
                indeg[v] += 1;
            }
        }
    }

    let mut layer = vec![0usize; n];
    let mut queue: VecDeque<usize> = (0..n).filter(|&i| indeg[i] == 0).collect();
    while let Some(u) = queue.pop_front() {
        for &v in &dependents[u] {
            layer[v] = layer[v].max(layer[u] + 1);
            indeg[v] -= 1;
            if indeg[v] == 0 {
                queue.push_back(v);
            }
        }
    }
    layer
}

/// Lay the plan out as a left→right topological DAG and wire its edges.
fn build_snarl(plan: &PlanView) -> Snarl<FunnelNode> {
    let mut snarl = Snarl::new();
    let layers = topo_layers(plan);

    // Group node indices by layer, preserving id order within a layer.
    let mut by_layer: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
    for (i, &l) in layers.iter().enumerate() {
        by_layer.entry(l).or_default().push(i);
    }
    let max_rows = by_layer.values().map(|v| v.len()).max().unwrap_or(1) as f32;
    let mid = (max_rows - 1.0) * 0.5 * Y_SPACING;

    let mut sid: HashMap<String, NodeId> = HashMap::new();
    for (layer, members) in &by_layer {
        let count = members.len() as f32;
        for (row, &ni) in members.iter().enumerate() {
            let node = &plan.nodes[ni];
            let x = 40.0 + *layer as f32 * X_SPACING;
            // Center each column around the canvas mid-line.
            let y = 40.0 + mid + (row as f32 - (count - 1.0) * 0.5) * Y_SPACING;
            let id = snarl.insert_node(
                Pos2::new(x, y),
                FunnelNode {
                    id: node.id.clone(),
                    kind: node.kind.clone(),
                    title: node.title.clone(),
                    status: node.status,
                    targets: node.targets.clone(),
                },
            );
            sid.insert(node.id.clone(), id);
        }
    }

    // Edge dep -> node: wire dep's single output into node's single input.
    for node in &plan.nodes {
        let Some(&to) = sid.get(&node.id) else { continue };
        for dep in &node.deps {
            if let Some(&from) = sid.get(dep) {
                snarl.connect(OutPinId { node: from, output: 0 }, InPinId { node: to, input: 0 });
            }
        }
    }
    snarl
}

/// Status legend row.
fn legend(ui: &mut egui::Ui, theme: &Theme) {
    for st in [
        NodeStat::Pending,
        NodeStat::Ready,
        NodeStat::InProgress,
        NodeStat::Done,
        NodeStat::Blocked,
        NodeStat::Failed,
    ] {
        ui.colored_label(st.color_themed(theme), st.glyph());
        ui.weak(st.label());
        ui.add_space(4.0);
    }
}

/// egui-snarl renderer for funnel nodes. One input pin (incoming deps) and one
/// output pin (dependents); both tinted by status so the wire colours read as
/// progress. Read-only: editing is the CLI/MCP's job, so `connect`/`disconnect`
/// are left as no-ops (the default trait impls would mutate the graph).
struct FunnelViewer {
    theme: Theme,
}

impl SnarlViewer<FunnelNode> for FunnelViewer {
    fn title(&mut self, node: &FunnelNode) -> String {
        node.id.clone()
    }

    fn inputs(&mut self, _node: &FunnelNode) -> usize {
        1
    }
    fn outputs(&mut self, _node: &FunnelNode) -> usize {
        1
    }

    fn show_header(
        &mut self,
        node: NodeId,
        _inputs: &[InPin],
        _outputs: &[OutPin],
        ui: &mut egui::Ui,
        snarl: &mut Snarl<FunnelNode>,
    ) {
        let n = &snarl[node];
        ui.horizontal(|ui| {
            ui.colored_label(n.status.color_themed(&self.theme), n.status.glyph());
            ui.strong(&n.id);
            if !n.kind.is_empty() {
                ui.label(egui::RichText::new(&n.kind).monospace().size(11.0).color(self.theme.text_dim));
            }
        });
    }

    fn has_body(&mut self, node: &FunnelNode) -> bool {
        !node.title.is_empty() || !node.targets.is_empty()
    }

    fn show_body(
        &mut self,
        node: NodeId,
        _inputs: &[InPin],
        _outputs: &[OutPin],
        ui: &mut egui::Ui,
        snarl: &mut Snarl<FunnelNode>,
    ) {
        let n = &snarl[node];
        ui.vertical(|ui| {
            ui.set_max_width(190.0);
            if !n.title.is_empty() {
                ui.label(egui::RichText::new(&n.title).size(11.0));
            }
            if !n.targets.is_empty() {
                ui.label(
                    egui::RichText::new(format!("→ {}", n.targets.join(", ")))
                        .size(10.0)
                        .color(self.theme.text_dim),
                );
            }
            ui.colored_label(n.status.color_themed(&self.theme), n.status.label());
        });
    }

    fn show_input(
        &mut self,
        pin: &InPin,
        _ui: &mut egui::Ui,
        snarl: &mut Snarl<FunnelNode>,
    ) -> impl egui_snarl::ui::SnarlPin + 'static {
        let color = snarl.get_node(pin.id.node).map(|n| n.status.color_themed(&self.theme)).unwrap_or(self.theme.text_dim);
        PinInfo::circle().with_fill(color)
    }

    fn show_output(
        &mut self,
        pin: &OutPin,
        _ui: &mut egui::Ui,
        snarl: &mut Snarl<FunnelNode>,
    ) -> impl egui_snarl::ui::SnarlPin + 'static {
        let color = snarl.get_node(pin.id.node).map(|n| n.status.color_themed(&self.theme)).unwrap_or(self.theme.text_dim);
        PinInfo::triangle().with_fill(color)
    }

    // Read-only canvas: ignore user-drawn wires.
    fn connect(&mut self, _from: &OutPin, _to: &InPin, _snarl: &mut Snarl<FunnelNode>) {}
}

#[cfg(test)]
mod tests {
    use super::*;
    use super::super::funnel_view::NodeView;

    fn node(id: &str, deps: &[&str]) -> NodeView {
        NodeView {
            id: id.into(),
            kind: "test".into(),
            title: String::new(),
            status: NodeStat::Pending,
            targets: Vec::new(),
            deps: deps.iter().map(|s| s.to_string()).collect(),
        }
    }

    /// Longest-path layering: a dependent sits one rank past its deepest dep.
    #[test]
    fn topo_layers_longest_path() {
        // n1,n2 roots; n3←n1; n4←n2; n5←{n3,n2} (so n5 = max(1,0)+1 = 2).
        let plan = PlanView {
            id: "p-001".into(),
            summary: String::new(),
            status: "active".into(),
            idea_text: String::new(),
            nodes: vec![
                node("n-1", &[]),
                node("n-2", &[]),
                node("n-3", &["n-1"]),
                node("n-4", &["n-2"]),
                node("n-5", &["n-3", "n-2"]),
            ],
        };
        let layers = topo_layers(&plan);
        assert_eq!(layers, vec![0, 0, 1, 1, 2]);
    }

    /// Unknown dep ids are ignored (never panic, treated as no edge).
    #[test]
    fn topo_layers_tolerates_dangling_dep() {
        let plan = PlanView {
            id: "p-002".into(),
            summary: String::new(),
            status: "draft".into(),
            idea_text: String::new(),
            nodes: vec![node("n-1", &["nope"]), node("n-2", &["n-1"])],
        };
        let layers = topo_layers(&plan);
        assert_eq!(layers, vec![0, 1]);

        // And the graph builds with the right node + wire counts.
        let snarl = build_snarl(&plan);
        assert_eq!(snarl.nodes().count(), 2);
        assert_eq!(snarl.wires().count(), 1);
    }
}