Add DAG progress visualization with glyph system and terminal renderer

[briansrls]

Summary

This PR introduces a comprehensive progress visualization system for DAG execution, replacing verbose line-dump shell output with a live, animated display that shows nodes and data flow in real-time — inspired by SimCity's power grid visualization.

The implementation follows a four-layer architecture:

1. Glyph System (core/ir): Semantic visual vocabulary with multi-tier encoding (emoji/unicode/ASCII)
2. Progress Observer (core/exec): Execution hooks that emit state change events
3. DagProgress Model (core/exec): Renderer-agnostic state machine tracking node/edge states
4. Terminal Renderer: Carriage-return based live display using the glyph system

Key Changes

Layer 1: Glyph System (core/ir/src/glyph.rs)

• New Tier enum: Emoji (default), Unicode, ASCII for environment-aware rendering
• New SemanticColor enum: Meaning-based colors (Success, Error, Warning, etc.) that renderers map to actual colors
• New GlyphId enum: 40+ semantic identifiers covering node states, edge states, DAG phases, structural elements, and data summaries
• New Glyph struct: Multi-tier visual representation with color metadata
• New GlyphSet struct: Themed collection of glyphs with lookup and rendering methods
• STANDARD static GlyphSet: Default visual vocabulary (e.g., ✅/●/[x] for completion, ⚡/═/= for data flow)
• Display width utilities for terminal layout calculations
• State-to-glyph bridge functions for mapping execution states to visual symbols

Why in core/ir? It's a foundational vocabulary like the language module's format-specific concerns. Any display code across the codebase can reference semantic GlyphIds without hardcoding emoji strings.

Layer 2: Progress Observer (core/exec/src/progress.rs)

• New ProgressObserver trait: Plugs into execute_flat() with callbacks for dag_start, node_start, node_complete, node_failed, node_skipped, node_intercepted, dag_complete
• New DagSnapshot struct: Captures DAG topology (nodes, edges, topo order) for layout computation
• New OutputSummary struct: Compact representation of node outputs with field kinds (Scalar, List, Map, Secret, Url, etc.) and truncated previews
• Integration point in execute_flat(): Minimal changes to wire observer callbacks around existing execution logic

Layer 3: DagProgress State Machine (core/exec/src/progress.rs)

• New DagProgress struct: Renderer-agnostic state tracking nodes, edges, phases, and elapsed time
• New NodeState enum: Pending, Running, Completed, Failed, Skipped, Intercepted
• New EdgeState enum: Idle, Flowing, Done, Dead
• New DagPhase enum: NotStarted, Running, Completed, Failed
• State transitions implement the "power flow" effect: edges transition to Flowing when source completes, then to Done when target starts

Key insight: The Flowing state is the visual moment where data travels along edges — renderers show this with animated glyphs (⚡ emoji, ═ unicode, = ASCII).

Layer 4: Terminal Renderer (design documented)

• Carriage-return based rendering using \r and ANSI cursor-up (\x1b[{N}A) to rewrite the same screen area
• No TUI framework dependency — just print/println with ANSI escapes
• Graceful fallback to append-only output when not a TTY
• Layout algorithm: Leveled topological layout with horizontal packing and edge routing via glyph connectors
• Visual design across all three tiers with emoji as default (🚀 DAG start, ✅ completion, ⚡ data flow, etc.)

Implementation Details

Design Decisions

Glyph System Pattern: Mirrors TypeId/TypeRegistry — GlyphId is semantic identity, Glyph is concrete definition, GlyphSet is collection + lookup. This

https://claude.ai/code/session_01FsBvUwjfkbNrvStq6p4t3i