agentwire-dev 1.63.0__tar.gz → 1.64.0__tar.gz

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.63.0
+Version: 1.64.0
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.63.0"
+__version__ = "1.64.0"

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/config.py

@@ -13,6 +13,14 @@ from typing import Optional
 
 import yaml
 
+# Gitignored files a fresh git worktree needs seeded — a worktree can't load
+# its session/task config without them. Single source of truth: referenced
+# by WorktreesConfig's default below, the config-loading fallback further
+# down, AND worktree.py's mandatory (never-omittable) seed set (#803) — a
+# stale `copy_files:` in a user's config.yaml that predates one of these
+# being added here must not silently drop it from every fresh worktree.
+DEFAULT_WORKTREE_COPY_FILES = [".env", ".agentwire.yml", ".agentwire.tasks.yml"]
+
 
 def _get_default_agent_command() -> str:
     """Get the default agent command.
@@ -105,7 +113,7 @@ class WorktreesConfig:
     # tasks can't load their session/task config without them when the project
     # gitignores them (the latter is the protected, host-authored task-exec file —
     # #720).
-    copy_files: list = field(default_factory=lambda: [".env", ".agentwire.yml", ".agentwire.tasks.yml"])
+    copy_files: list = field(default_factory=lambda: list(DEFAULT_WORKTREE_COPY_FILES))
 
 
 @dataclass
@@ -623,7 +631,7 @@ def _dict_to_config(data: dict) -> Config:
         enabled=worktrees_data.get("enabled", True),
         suffix=worktrees_data.get("suffix", "-worktrees"),
         auto_create_branch=worktrees_data.get("auto_create_branch", True),
-        copy_files=worktrees_data.get("copy_files", [".env", ".agentwire.yml", ".agentwire.tasks.yml"]),
+        copy_files=worktrees_data.get("copy_files", list(DEFAULT_WORKTREE_COPY_FILES)),
     )
     projects = ProjectsConfig(
         dir=projects_data.get("dir", "~/projects"),

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/doctor_cli.py

@@ -19,6 +19,7 @@ import shutil
 import socket
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 from .core import (
@@ -475,6 +476,75 @@ def _render_shim_liveness_section() -> int:
     return len(dead)
 
 
+def _scheduler_daemon_started_at() -> float | None:
+    """Epoch seconds the scheduler daemon process started, or ``None`` if not running.
+
+    Reads the daemon's own self-reported ``started_at`` from the live-state
+    file it already writes every loop tick (``scheduler/loop.py`` ->
+    ``_write_live_state`` -> ``read_live_state()``) rather than reimplementing
+    process-start-time discovery via ``ps``/``pgrep`` PID matching, which is
+    both platform-fragile (``ps`` elapsed-time output format varies) and
+    ambiguous if a stray/duplicate daemon process happens to be running.
+    ``tmux_session_exists`` confirms the daemon is actually alive, so a
+    leftover live-state file from a since-stopped daemon doesn't produce a
+    false "stale" reading.
+    """
+    from .scheduler import SCHEDULER_SESSION, read_live_state
+
+    if not tmux_session_exists(SCHEDULER_SESSION):
+        return None
+    state = read_live_state()
+    if not state:
+        return None
+    started_at = state.get("started_at")
+    if not started_at:
+        return None
+    try:
+        from datetime import datetime
+        return datetime.fromisoformat(started_at).timestamp()
+    except (ValueError, TypeError):
+        return None
+
+
+def _newest_installed_source_mtime(pkg_dir: Path | None = None) -> float:
+    """Newest mtime among the installed ``agentwire`` package's ``.py`` files."""
+    if pkg_dir is None:
+        pkg_dir = Path(__file__).resolve().parent
+    try:
+        return max((f.stat().st_mtime for f in pkg_dir.rglob("*.py")), default=0.0)
+    except Exception:
+        return 0.0
+
+
+def _render_scheduler_staleness_section() -> int:
+    """Doctor section: flag a scheduler daemon older than the installed code (#803).
+
+    ``agentwire scheduler serve`` is a long-running Python process — like the
+    MCP server, it imports its modules once at start and never re-reads them.
+    ``agentwire rebuild`` updates the on-disk package but can't touch an
+    already-running interpreter's loaded bytecode, so a daemon that has been
+    up since before the last rebuild is silently executing stale dispatch
+    logic: any bug fixed since then stays live in production until the
+    daemon is restarted.
+    """
+    started_at = _scheduler_daemon_started_at()
+    if started_at is None:
+        print("  [..] Scheduler daemon not running — skipping staleness check")
+        return 0
+
+    newest_src = _newest_installed_source_mtime()
+    if not newest_src or newest_src <= started_at:
+        print("  [ok] Scheduler daemon is current with the installed package")
+        return 0
+
+    age_days = (time.time() - started_at) / 86400
+    print(f"  [!!] Scheduler daemon has been running {age_days:.1f}d — "
+          "predates the most recent `agentwire rebuild`")
+    print("       Any dispatch bug fixed since then is still live in the running daemon.")
+    print("       Fix: agentwire scheduler stop && agentwire scheduler start")
+    return 1
+
+
 def cmd_doctor(args) -> int:
     """Auto-diagnose and fix common issues."""
     from .hooks_cli import _managed_file_state, _managed_hook_files, get_hooks_source
@@ -653,6 +723,14 @@ def cmd_doctor(args) -> int:
         else:
             print("  [ok] Local main up to date with origin/main")
 
+    # 4d. Scheduler daemon staleness — the daemon is a long-running process
+    # that never re-imports its code, so it can silently run a dispatch bug
+    # that's since been fixed on disk (#803). Distinct from the git-drift
+    # check above: that flags an out-of-date CHECKOUT, this flags a
+    # currently-running PROCESS that predates the last install.
+    print("\nChecking scheduler daemon freshness...")
+    issues_found += _render_scheduler_staleness_section()
+
     # Check custom services (registry-driven: built-in notifications bridge
     # + user-defined services from services.custom)
     print("\nChecking custom services...")

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/bash-tool-damage-control.py

@@ -613,8 +613,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -629,6 +629,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/edit-tool-damage-control.py

@@ -609,8 +609,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -625,6 +625,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/mcp-tool-damage-control.py

@@ -621,8 +621,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -637,6 +637,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/read-tool-damage-control.py

@@ -615,8 +615,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -631,6 +631,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/write-tool-damage-control.py

@@ -608,8 +608,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -624,6 +624,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/safety/_core.py

@@ -577,8 +577,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -593,6 +593,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/scheduler/gates.py

@@ -46,7 +46,25 @@ def _check_gate(board, task_name: str) -> bool:
     project = task.project
 
     def _gate_skip(gate_type: str, reason: str, **extra):
-        """Record a gate skip, only logging on first occurrence."""
+        """Record a gate skip. Logs only on first occurrence (spam control),
+        but persists ``last_gate_skip`` on every REASON CHANGE.
+
+        Distinct from ``_gate_error`` below: this is the CLEAN "not ready
+        yet" path (e.g. a ``command`` gate legitimately returning nonzero),
+        not an exception. Recorded so the board can show "waiting on gate"
+        instead of reading as silently-falling-behind overdue (#803).
+        Persisting on reason-change (not just first-occurrence, which
+        ``_gated_tasks`` alone gates) matters for multi-condition gates: if
+        task's blocker shifts from ``git_commit`` to ``command`` without the
+        gate ever fully passing in between, ``task_name`` never leaves
+        ``_gated_tasks``, so a first-occurrence-only write would leave the
+        board showing the ORIGINAL, now-stale reason.
+        """
+        skip_text = f"{gate_type}: {reason}"
+        if state.last_gate_skip != skip_text:
+            state.last_gate_skip = skip_text
+            board.state[task_name] = state
+            _sched.save_board(board)
         if task_name not in _gated_tasks:
             _sched._log_event("task_gated", task=task_name, gate_type=gate_type,
                               reason=reason, **extra)
@@ -69,6 +87,7 @@ def _check_gate(board, task_name: str) -> bool:
             print(f"[{_ts()}] Gate error on {task_name}: {gate_type} "
                   f"({reason}) — failing open")
             state.last_gate_error = f"{gate_type}: {reason}"
+            state.last_gate_skip = ""  # failing open — no longer "waiting on gate"
             board.state[task_name] = state
             _sched.save_board(board)
         _gated_tasks.discard(task_name)
@@ -131,16 +150,20 @@ def _check_gate(board, task_name: str) -> bool:
 
 
 def _clear_gate_error(board, task_name: str) -> None:
-    """Clear a previously-recorded gate error once the gate evaluates cleanly.
+    """Clear a previously-recorded gate error/skip once the gate evaluates cleanly.
 
-    No-op (and no board write) unless this task actually had an error, so
-    the common clean path stays cheap.
+    No-op (and no board write) unless this task actually had something
+    recorded, so the common clean path stays cheap. Clears BOTH
+    ``last_gate_error`` (exception path) and ``last_gate_skip`` (clean
+    "not ready yet" path, #803) — both are stale the moment the gate passes.
     """
     from agentwire import scheduler as _sched
 
     state = board.state.get(task_name)
     had_tracked = _gate_errored.pop(task_name, None) is not None
-    if had_tracked or (state is not None and state.last_gate_error):
-        if state is not None and state.last_gate_error:
+    had_state = state is not None and (state.last_gate_error or state.last_gate_skip)
+    if had_tracked or had_state:
+        if state is not None and (state.last_gate_error or state.last_gate_skip):
             state.last_gate_error = ""
+            state.last_gate_skip = ""
             _sched.save_board(board)

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/scheduler/models.py

@@ -89,6 +89,7 @@ class TaskState:
     run_count: int = 0
     last_summary: str = ""
     last_gate_error: str = ""     # last gate-eval exception reason (failed open)
+    last_gate_skip: str = ""      # currently-blocking gate reason (clean skip, not an error)
     last_gate_commit: str = ""    # HEAD at last dispatch (for gate checks)
     last_dispatch: datetime | None = None  # set BEFORE running (restart safety)
     # Active worktree-PR tracking (set on finalize, cleared by the reaper on

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/scheduler/report.py

@@ -199,6 +199,8 @@ def get_board_display(board: Board) -> list[dict]:
             row["last_summary"] = state.last_summary
         if state.last_gate_error:
             row["last_gate_error"] = state.last_gate_error
+        if state.last_gate_skip:
+            row["last_gate_skip"] = state.last_gate_skip
         rows.append(row)
 
     # Sort: enabled first, then by overdue (most overdue first)

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/scheduler/state.py

@@ -112,6 +112,7 @@ def load_board() -> Board:
                 run_count=int(s.get("run_count", 0)),
                 last_summary=str(s.get("last_summary", "")),
                 last_gate_error=str(s.get("last_gate_error", "")),
+                last_gate_skip=str(s.get("last_gate_skip", "")),
                 last_gate_commit=str(s.get("last_gate_commit", "")),
                 last_dispatch=_parse_datetime_field(s.get("last_dispatch")),
                 worktree_branch=str(s.get("worktree_branch", "")),
@@ -163,6 +164,8 @@ def _state_to_dict(board: Board) -> dict:
             entry["last_summary"] = s.last_summary
         if s.last_gate_error:
             entry["last_gate_error"] = s.last_gate_error
+        if s.last_gate_skip:
+            entry["last_gate_skip"] = s.last_gate_skip
         if s.last_gate_commit:
             entry["last_gate_commit"] = s.last_gate_commit
         if s.last_dispatch:

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/scheduler_cli.py

@@ -148,7 +148,7 @@ def _recent_activity(events: list[dict], limit: int = 5) -> list[dict]:
     glance at `scheduler status` shows recent results — including the
     fail-open gate errors that used to vanish entirely.
     """
-    keep = {"task_completed", "task_failed", "gate_error"}
+    keep = {"task_completed", "task_failed", "gate_error", "task_gated"}
     out: list[dict] = []
     for evt in reversed(events):
         etype = evt.get("event")
@@ -165,6 +165,8 @@ def _recent_activity(events: list[dict], limit: int = 5) -> list[dict]:
             detail = f"{status}" + (f" — {summary}" if summary else "")
         elif etype == "task_failed":
             detail = "failed — " + (evt.get("summary") or evt.get("reason") or "?")
+        elif etype == "task_gated":
+            detail = f"[gated] {evt.get('gate_type', '?')}: {evt.get('reason', '?')}"
         else:  # gate_error
             detail = f"[gate-error] {evt.get('gate_type', '?')}: {evt.get('reason', '?')}"
         if len(detail) > 80:
@@ -254,10 +256,14 @@ def cmd_scheduler_board(args) -> int:
             )
 
             # Surface WHY: a gate-eval error (fail-open, would otherwise be
-            # invisible) takes precedence; else the summary behind a bad status.
+            # invisible) takes precedence; then a currently-blocking gate
+            # (so "+4h11m" reads as "waiting on gate", not silently falling
+            # behind, #803); else the summary behind a bad status.
             detail = ""
             if r.get("last_gate_error"):
                 detail = f"[gate-error] {r['last_gate_error']}"
+            elif r.get("last_gate_skip"):
+                detail = f"[gated] {r['last_gate_skip']}"
             elif status_str in _BAD_STATUSES and r.get("last_summary"):
                 detail = r["last_summary"]
             if detail:

{agentwire_dev-1.63.0 → agentwire_dev-1.64.0}/agentwire/static/css/desktop.css

@@ -5958,8 +5958,12 @@ body.sidebar-pinned .sidebar-tab {
 
 /* ============================================
    Session HUD — top-edge frosted drawer (#776, foundation shell)
-   Two detents (peek 33vh / half 50vh), top-center pull handle. Content is
-   mounted into .session-hud-canvas by a later issue (#777, TopologyView).
+   Two detents, top-center pull handle: "peek" auto-sizes to content, floored
+   and capped at the fixed "half" (50vh) ceiling (#802, session-hud.js's
+   _applyAutoHeight); the 33vh height below is only the pre-JS-measurement
+   fallback for the instant the drawer is created, before content exists.
+   Content is mounted into .session-hud-canvas by a later issue (#777,
+   TopologyView).
    ============================================ */
 
 /* Left offset shared by the drawer and its handle so the two never drift.
@@ -6655,20 +6659,60 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     gap: 6px;
 }
 
-.topology-spark {
-    display: flex;
-    align-items: flex-end;
-    gap: 2px;
-    height: 12px;
+/* Full-width activity pulse strip (#800), replacing the old bar sparkline.
+   The rules below are the `idle` resting state — dim, slow, low-amplitude,
+   still visibly "alive". flow/awaiting/stuck override speed/amplitude/colour
+   further down, keyed off the card's state class. */
+.topology-pulse {
+    position: relative;
+    width: 100%;
+    height: 20px;
+    border-radius: 4px;
 }
 
-.topology-spark i {
+.topology-pulse-svg {
     display: block;
-    width: 2px;
-    height: 3px;
-    border-radius: 1px;
-    background: var(--text-muted);
-    opacity: 0.5;
+    width: 100%;
+    height: 100%;
+}
+
+.topology-pulse-base {
+    stroke: var(--text-muted);
+    stroke-width: 1px;
+    opacity: 0.18;
+}
+
+.topology-pulse-scroll {
+    animation: topology-pulse-scroll 3.2s linear infinite;
+}
+
+.topology-pulse-trace {
+    fill: none;
+    stroke: var(--text-muted);
+    stroke-width: 1.6px;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+    opacity: 0.4;
+    vector-effect: non-scaling-stroke;
+    transform-box: fill-box;
+    transform-origin: center;
+    transform: scaleY(0.32);
+}
+
+.topology-pulse-marker {
+    position: absolute;
+    top: 50%;
+    right: 3px;
+    width: 5px;
+    height: 5px;
+    margin-top: -2.5px;
+    border-radius: 50%;
+    opacity: 0;
+    pointer-events: none;
+}
+
+@keyframes topology-pulse-scroll {
+    to { transform: translateX(-240px); }
 }
 
 .topology-card-machine {
@@ -6785,10 +6829,18 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     opacity: 0.5;
     animation: topology-dot-ring 1.8s ease-out infinite;
 }
-.topology-card--flow .topology-spark i {
-    background: var(--card-tint, var(--lineage-tint-1));
-    opacity: 0.9;
-    animation: topology-spark-eq 1s ease-in-out infinite;
+.topology-card--flow .topology-pulse-base {
+    stroke: var(--card-tint, var(--lineage-tint-1));
+    opacity: 0.22;
+}
+.topology-card--flow .topology-pulse-scroll {
+    animation-duration: 1.15s;
+}
+.topology-card--flow .topology-pulse-trace {
+    stroke: var(--card-tint, var(--lineage-tint-1));
+    opacity: 0.95;
+    transform: scaleY(1);
+    filter: drop-shadow(0 0 3px color-mix(in srgb, var(--card-tint, var(--lineage-tint-1)) 55%, transparent));
 }
 
 /* Failure-state parity (#749): awaiting/stuck override the lineage tint
@@ -6803,9 +6855,19 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     opacity: 0.6;
     animation: topology-dot-ring 1.3s ease-out infinite;
 }
-.topology-card--awaiting .topology-spark i {
+.topology-card--awaiting .topology-pulse-trace {
+    stroke: var(--topology-awaiting);
+    opacity: 0.9;
+    transform: scaleY(0.7);
+}
+.topology-card--awaiting .topology-pulse-scroll {
+    animation-duration: 2s;
+}
+.topology-card--awaiting .topology-pulse-marker {
     background: var(--topology-awaiting);
-    opacity: 0.7;
+    box-shadow: 0 0 5px var(--topology-awaiting-glow);
+    opacity: 1;
+    animation: topology-pulse-blink 1.1s ease-in-out infinite;
 }
 .topology-card--stuck .topology-status-dot {
     background: var(--topology-stuck);
@@ -6816,9 +6878,23 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     opacity: 0.7;
     animation: topology-dot-ring 0.9s ease-out infinite;
 }
-.topology-card--stuck .topology-spark i {
+.topology-card--stuck .topology-pulse-base {
+    stroke: var(--topology-stuck);
+    opacity: 0.3;
+}
+.topology-card--stuck .topology-pulse-trace {
+    stroke: var(--topology-stuck);
+    opacity: 0.9;
+    transform: scaleY(0.16);
+}
+.topology-card--stuck .topology-pulse-scroll {
+    animation-duration: 0.9s;
+}
+.topology-card--stuck .topology-pulse-marker {
     background: var(--topology-stuck);
-    opacity: 0.7;
+    box-shadow: 0 0 6px var(--topology-stuck-glow);
+    opacity: 1;
+    animation: topology-pulse-blink 0.7s steps(2, jump-none) infinite;
 }
 
 /* "You-are-here" self/root card (#778) — the Session HUD's re-rooted view
@@ -6845,9 +6921,9 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     0% { transform: scale(0.6); opacity: 0.7; }
     100% { transform: scale(1.9); opacity: 0; }
 }
-@keyframes topology-spark-eq {
-    0%, 100% { height: 3px; }
-    50% { height: 11px; }
+@keyframes topology-pulse-blink {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.15; }
 }
 
 .topology-link {
@@ -6886,7 +6962,8 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
 
 @media (prefers-reduced-motion: reduce) {
     .topology-status-dot::after,
-    .topology-card--flow .topology-spark i,
+    .topology-pulse-scroll,
+    .topology-pulse-marker,
     .topology-link--flow,
     .topology-link--awaiting,
     .topology-link--stuck {
@@ -6918,7 +6995,11 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
 
 .topology-view--shade .topology-family {
     flex: 0 0 auto;
-    gap: 6px;
+    /* Vertical gap between depth rows — the connector bezier's min bend is 24px
+       (bezierPath in topology-render.js), so give the wires at least that much
+       room to travel between a parent row and its children (#792 was 6px, too
+       tight for the S-curve to sit inside the gap). */
+    gap: 26px;
 }
 
 .topology-view--shade .topology-row {
@@ -7038,7 +7119,8 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
 /* Expanded card hosts a live terminal — the activity sparkline is redundant
    and just steals a row, so hide it, and tighten the card's gap. Reclaims
    vertical space for terminal rows (the card was mostly chrome above it). */
-.topology-card--expanded .topology-card-meta { display: none; }
+.topology-card--expanded .topology-card-meta,
+.topology-card--expanded .topology-pulse { display: none; }
 .topology-card--expanded { gap: 4px; }
 
 /* --- born-from-parent placement (#745, absorbed into the HUD by #780) ---
@@ -7121,6 +7203,21 @@ body.sidebar-pinned { --hud-left: var(--sidebar-width); }
     text-overflow: ellipsis;
 }
 
+/* Read-only git-status badges (#801) — reuses the sidebar's `.sidebar-git-badge`
+   + `.git-*` classes (sidebar/sessions-section.js's `renderGitBadges`) so a
+   worktree reads identically whether it's a live session or a ghost; only the
+   row layout is ghost-specific. Same [hidden]-override gotcha as
+   `.topology-ghost-actions` below — the JS toggles `hidden` every render. */
+.topology-ghost-git[hidden] {
+    display: none;
+}
+.topology-ghost-git {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    flex-wrap: wrap;
+}
+
 /* [hidden] must win over the flex display below (equal specificity, later
    author rule otherwise beats the UA [hidden]{display:none} stylesheet) —
    the JS toggles this element's `hidden` attribute per card every render. */