agentic-dev-loop 1.0.0a49__tar.gz → 1.0.0a51__tar.gz

{agentic_dev_loop-1.0.0a49/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a49
+Version: 1.0.0a51
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -169,7 +169,10 @@ engine-owned object to its owning run and a `live`, `orphaned`,
 registry-owned orphans whose owner pid is dead (never unregistered names).
 A SIGTERM to a running pipeline still closes the sandbox (the graph's
 `finally` runs); SIGKILL is unhandleable, so its containers are reclaimed by
-the startup reaper on the next run or by `containers --reap`. Pass
+the startup reaper on the next run or by `containers --reap`. The reaper
+and `--reap` prune a registry entry only after the daemon confirms the
+object is gone; a surviving object (a failed removal) keeps its entry so
+the next startup retries it. Pass
 `--state-dir` to point at a custom `isolation.state_dir`.
 
 **What a run looks like** (the shipped self-loop example):

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/README.md

@@ -125,7 +125,10 @@ engine-owned object to its owning run and a `live`, `orphaned`,
 registry-owned orphans whose owner pid is dead (never unregistered names).
 A SIGTERM to a running pipeline still closes the sandbox (the graph's
 `finally` runs); SIGKILL is unhandleable, so its containers are reclaimed by
-the startup reaper on the next run or by `containers --reap`. Pass
+the startup reaper on the next run or by `containers --reap`. The reaper
+and `--reap` prune a registry entry only after the daemon confirms the
+object is gone; a surviving object (a failed removal) keeps its entry so
+the next startup retries it. Pass
 `--state-dir` to point at a custom `isolation.state_dir`.
 
 **What a run looks like** (the shipped self-loop example):

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a49"
+version = "1.0.0a51"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/src/agentic_dev_loop/engine/graph.py

@@ -8,6 +8,7 @@ steer the retry cycle, and a SQLite checkpointer makes runs crash-resumable
 from __future__ import annotations
 
 import operator
+import time
 import uuid
 import webbrowser
 from pathlib import Path
@@ -279,12 +280,14 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
         if bus is not None:
             start_state = initial if initial is not None \
                 else graph.get_state(config).values
+            run_start = time.monotonic()
             bus.publish({
                 "type": "run_started",
                 "subject": start_state["subject"],
                 "max_attempts": start_state["max_attempts"],
                 "thread_id": thread_id,
                 "attempt": start_state["attempt"],
+                "started_at": time.time(),
             })
             watch = viz.NodeWatch()
             capture = viz.ConsoleCapture(bus, watch)
@@ -292,6 +295,7 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
             heartbeat = viz.HeartbeatThread(watch, bus)
             heartbeat.start()
             final = None
+            step_starts: dict[str, float] = {}
             try:
                 for part in graph.stream(initial, config,
                                          stream_mode=["tasks", "updates"],
@@ -299,8 +303,13 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
                     for event in viz.translate(part):
                         if event["type"] == "node_started":
                             watch.start(event["node"])
+                            step_starts[event["node"]] = time.monotonic()
                         elif event["type"] == "node_finished":
                             watch.finish(event["node"])
+                            if event["node"] in step_starts:
+                                event["elapsed_seconds"] = max(
+                                    0, int(round(time.monotonic()
+                                                - step_starts[event["node"]])))
                         bus.publish(event)
                 final = graph.get_state(config).values
             finally:
@@ -317,8 +326,13 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
                 else:
                     success = False
                     attempts = 0
-                bus.publish({"type": "run_finished",
-                             "success": success, "attempts": attempts})
+                bus.publish({
+                    "type": "run_finished",
+                    "success": success,
+                    "attempts": attempts,
+                    "elapsed_seconds": max(
+                        0, int(round(time.monotonic() - run_start))),
+                })
                 capture.detach()
         else:
             final = graph.invoke(initial, config)

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/src/agentic_dev_loop/engine/isolation.py

@@ -1632,23 +1632,12 @@ class DockerBackend(Sandbox):
         _write_registry(self._iso_state_dir, remaining)
 
     def _container_gone(self, name: str) -> bool:
-        """True only when the daemon confirms the container no longer exists.
-        A nonzero daemon exit keeps the entry."""
-        res = self._runner.run(
-            ["docker", "ps", "-a", "--filter", f"name={name}",
-             "--format", "{{.Names}}"], timeout=30)
-        if res.exit_code != 0:
-            return False
-        return name not in res.stdout.splitlines()
+        """Thin delegation to the module-level confirm helper (050 D2)."""
+        return _container_gone(self._runner, name)
 
     def _network_gone(self, name: str) -> bool:
-        """True only when the daemon reports the network is missing. Any
-        other inspect failure (daemon unreachable) keeps the entry."""
-        res = self._runner.run(
-            ["docker", "network", "inspect", name], timeout=30)
-        if res.exit_code == 0:
-            return False
-        return "No such network" in f"{res.stderr} {res.stdout}"
+        """Thin delegation to the module-level confirm helper (050 D2)."""
+        return _network_gone(self._runner, name)
 
     # -- internal -----------------------------------------------------------
 
@@ -1882,6 +1871,28 @@ def _pid_alive_matches(pid: int, recorded_start: str | None) -> bool:
     return current == recorded_start
 
 
+def _container_gone(runner: CommandRunner, name: str) -> bool:
+    """True only when the daemon confirms the container no longer exists.
+    A nonzero daemon exit keeps the entry."""
+    res = runner.run(
+        ["docker", "ps", "-a", "--filter", f"name={name}",
+         "--format", "{{.Names}}"], timeout=30)
+    if res.exit_code != 0:
+        return False
+    return name not in res.stdout.splitlines()
+
+
+def _network_gone(runner: CommandRunner, name: str) -> bool:
+    """True only when the daemon reports the network is missing. Any
+    other inspect failure (daemon unreachable) keeps the entry."""
+    res = runner.run(
+        ["docker", "network", "inspect", name], timeout=30)
+    if res.exit_code == 0:
+        return False
+    return "No such network" in f"{res.stderr} {res.stdout}"
+
+
+
 def reap_orphaned_containers(state_dir: str | Path,
                              runner: CommandRunner | None = None,
                              *, announce: bool = True) -> list[str]:
@@ -1889,7 +1900,9 @@ def reap_orphaned_containers(state_dir: str | Path,
     and the per-run internal network whose owning CLI process is gone (crashed
     before close()). Exact by construction - only engine registry names are
     touched, and a live owner (pid alive with the same start time) is left
-    alone. Best-effort: never raises."""
+    alone. A surviving object (rm failure) keeps its entry so the next
+    startup reaper retries; only a daemon-confirmed absence prunes it (050
+    D1). Best-effort: never raises."""
     runner = runner or _default_runner
     entries = _read_registry(Path(state_dir))
     if not entries:
@@ -1909,6 +1922,9 @@ def reap_orphaned_containers(state_dir: str | Path,
                 remaining.append(entry)
                 continue
             runner.run(["docker", "network", "rm", name], timeout=60)
+            if not _network_gone(runner, name):
+                remaining.append(entry)
+                continue
             if announce:
                 _announce(f"reaped orphaned sandbox network {name}")
             reaped.append(name)
@@ -1924,6 +1940,9 @@ def reap_orphaned_containers(state_dir: str | Path,
             remaining.append(entry)
             continue
         runner.run(["docker", "rm", "-f", name], timeout=60)
+        if not _container_gone(runner, name):
+            remaining.append(entry)
+            continue
         if announce:
             _announce(f"reaped orphaned sandbox container {name}")
         reaped.append(name)

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/src/agentic_dev_loop/viz/server.py

@@ -466,7 +466,7 @@ PAGE = """<!doctype html>
   #thread code { font: 12px ui-monospace, SFMono-Regular, Menlo, monospace;
                  background: #f5f5f5; padding: 2px 6px; border-radius: 4px;
                  cursor: pointer; user-select: all; }
-  #elapsed { font-size: 14px; color: #1976d2; display: none; }
+  #total { font-size: 14px; color: #1976d2; display: none; }
   #verdicts { display: flex; flex-wrap: wrap; gap: 6px; }
   .badge { font-size: 12px; padding: 3px 8px; border-radius: 10px;
            background: #f0f0f0; color: #333; }
@@ -477,12 +477,15 @@ PAGE = """<!doctype html>
   #stages { flex: 1 1 auto; min-height: 0; overflow-y: auto; display: flex;
             flex-direction: column; gap: 8px; }
   .stage { border: 1px solid #e0e0e0; border-radius: 6px; overflow: hidden; }
-  .stage-header { display: block; width: 100%; text-align: left; cursor: pointer;
+  .stage-header { display: flex; align-items: baseline; width: 100%;
+                  text-align: left; cursor: pointer;
                   font: 13px/1.4 -apple-system, BlinkMacSystemFont, "Segoe UI",
                   Roboto, Helvetica, Arial, sans-serif; padding: 6px 10px;
                   border: 0; background: #f7f7f7; }
   .stage-glyph { display: inline-block; width: 1.1em; }
   .stage-status { margin-left: 0.4em; }
+  .stage-time { margin-left: auto; color: #555;
+                font-variant-numeric: tabular-nums; }
   .status-pending { color: #555; }
   .status-running { color: #1976d2; }
   .status-pass { color: #2e7d32; }
@@ -531,7 +534,7 @@ PAGE = """<!doctype html>
     <h2 id="subject">agentic-dev-loop pipeline</h2>
     <div id="attempt">attempt ?/?</div>
     <div id="thread">thread id: <code id="thread-id" title="click to select">\u2014</code></div>
-    <div id="elapsed"></div>
+    <div id="total"></div>
     <div id="verdicts"></div>
     <div id="stages"></div>
     <ul id="run-log"></ul>
@@ -554,6 +557,10 @@ PAGE = """<!doctype html>
   var renderCount = 0;
   var mermaidFailed = !!window.__mermaidFailed;
   var pendingCompletion = null;
+  var stepTimes = {};
+  var liveElapsed = {};
+  var runStartWall = null;
+  var totalTimer = null;
   var topologyReady = false;
   var pendingEvents = [];
   var MAX_CONSOLE = 500;
@@ -602,10 +609,16 @@ PAGE = """<!doctype html>
     return m + ":" + (s < 10 ? "0" : "") + s;
   }
 
-  function clearElapsed() {
-    var line = el("elapsed");
-    line.textContent = "";
-    line.style.display = "none";
+  function renderTotal() {
+    var line = el("total");
+    if (runStartWall === null) {
+      line.textContent = "";
+      line.style.display = "none";
+      return;
+    }
+    line.textContent = "total " + mmss(Math.max(0,
+      Math.round(Date.now() / 1000 - runStartWall)));
+    line.style.display = "block";
   }
 
   function statusOf(n) {
@@ -723,6 +736,9 @@ PAGE = """<!doctype html>
     header.appendChild(glyph);
     header.appendChild(name);
     header.appendChild(status);
+    var time = document.createElement("span");
+    time.className = "stage-time";
+    header.appendChild(time);
 
     var console = document.createElement("pre");
     console.className = "stage-console";
@@ -768,6 +784,10 @@ PAGE = """<!doctype html>
       else if (v === "env") { suffix = " (verdict: ENV)"; }
     }
     status.textContent = (word ? " " + word : "") + suffix;
+    header.querySelector(".stage-time").textContent =
+      (word === "completed" && stepTimes[node]) ? mmss(stepTimes[node])
+      : (word === "running" && liveElapsed[node] !== undefined)
+        ? mmss(liveElapsed[node]) : "";
     header.className = "stage-header status-" + renderStatusOf(node);
   }
 
@@ -1033,6 +1053,13 @@ PAGE = """<!doctype html>
     switch (ev.type) {
       case "run_started":
         flushPending();
+        stepTimes = {};
+        liveElapsed = {};
+        if (totalTimer !== null) { clearInterval(totalTimer); totalTimer = null; }
+        runStartWall = (typeof ev.started_at === "number")
+          ? ev.started_at : null;
+        if (runStartWall !== null) { totalTimer = setInterval(renderTotal, 1000); }
+        renderTotal();
         clearConsoles();
         resetVerdicts();
         if (ev.attempt !== undefined) {
@@ -1051,14 +1078,18 @@ PAGE = """<!doctype html>
         if (!nodeIds.has(ev.node)) { break; }
         nodeStatus[ev.node] = "running";
         stageWord[ev.node] = "running";
+        liveElapsed = {};
+        liveElapsed[ev.node] = 0;
         Array.from(nodeIds).forEach(function (n) {
           if (n === ev.node) { expandStage(n); } else { collapseStage(n); }
         });
         renderGraph();
         break;
       case "node_finished":
-        clearElapsed();
         if (!nodeIds.has(ev.node)) { break; }
+        if (ev.elapsed_seconds !== undefined) {
+          stepTimes[ev.node] = (stepTimes[ev.node] || 0) + ev.elapsed_seconds;
+        }
         if (!fatalNodes.has(ev.node)) {
           nodeStatus[ev.node] = ev.ok ? "pass" : "fail";
         }
@@ -1071,9 +1102,9 @@ PAGE = """<!doctype html>
         renderGraph();
         break;
       case "heartbeat":
-        if (nodeStatus[ev.node] === "running") {
-          el("elapsed").textContent = ev.node + " running \u2014 " + mmss(ev.elapsed_seconds) + " elapsed";
-          el("elapsed").style.display = "block";
+        if (nodeIds.has(ev.node) && nodeStatus[ev.node] === "running") {
+          liveElapsed[ev.node] = ev.elapsed_seconds;
+          renderStageHeader(ev.node);
         }
         break;
       case "state":
@@ -1106,7 +1137,12 @@ PAGE = """<!doctype html>
         updateAttempt();
         break;
       case "run_finished":
-        clearElapsed();
+        if (totalTimer !== null) { clearInterval(totalTimer); totalTimer = null; }
+        if (ev.elapsed_seconds !== undefined) {
+          runStartWall = null;
+          el("total").textContent = "total " + mmss(ev.elapsed_seconds);
+          el("total").style.display = "block";
+        }
         flushPending();
         if (!ev.success) {
           Object.keys(nodeStatus).forEach(function (n) {

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a49
+Version: 1.0.0a51
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -169,7 +169,10 @@ engine-owned object to its owning run and a `live`, `orphaned`,
 registry-owned orphans whose owner pid is dead (never unregistered names).
 A SIGTERM to a running pipeline still closes the sandbox (the graph's
 `finally` runs); SIGKILL is unhandleable, so its containers are reclaimed by
-the startup reaper on the next run or by `containers --reap`. Pass
+the startup reaper on the next run or by `containers --reap`. The reaper
+and `--reap` prune a registry entry only after the daemon confirms the
+object is gone; a surviving object (a failed removal) keeps its entry so
+the next startup retries it. Pass
 `--state-dir` to point at a custom `isolation.state_dir`.
 
 **What a run looks like** (the shipped self-loop example):

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/tests/test_containers.py

@@ -123,7 +123,11 @@ class TestReapReturnValue:
         _write(tmp_path / "state", [_entry(name, proc.pid, None)])
         runner = FakeRunner(ok(""))
         assert reap_orphaned_containers(tmp_path / "state", runner) == [name]
-        assert runner.calls == [["docker", "rm", "-f", name]]
+        assert runner.calls == [
+            ["docker", "rm", "-f", name],
+            ["docker", "ps", "-a", "--filter", f"name={name}",
+             "--format", "{{.Names}}"],
+        ]
 
     def test_reap_live_owner_returns_empty(self, tmp_path):
         name = f"{'b' * 32}-exec"

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/tests/test_graph.py

@@ -7,6 +7,7 @@ everything else - files, git, checkpoints - is real."""
 
 import argparse
 import queue
+import time
 import sqlite3
 import subprocess
 from pathlib import Path
@@ -453,6 +454,25 @@ class TestVizStream:
         assert events[-1]["success"] is True
         assert events[-1]["attempts"] == 1
 
+    def test_run_events_carry_timings(self, repo, fake_agents):
+        script_all_pass(fake_agents)
+        before = time.time()
+        bus = VizBus()
+        ok, attempts = run_pipeline("pipeline.yaml", args(), viz_bus=bus)
+        after = time.time()
+        assert (ok, attempts) == (True, 1)
+        events = drain_events(bus)
+        run_started = next(e for e in events if e["type"] == "run_started")
+        assert isinstance(run_started["started_at"], (int, float))
+        assert before <= run_started["started_at"] <= after
+        run_finished = next(e for e in events if e["type"] == "run_finished")
+        assert isinstance(run_finished["elapsed_seconds"], int)
+        assert run_finished["elapsed_seconds"] >= 0
+        for event in events:
+            if event["type"] == "node_finished":
+                assert isinstance(event["elapsed_seconds"], int)
+                assert event["elapsed_seconds"] >= 0
+
     def test_stream_path_failure_returns_same(self, repo, fake_agents):
         fake_agents.set("check", [("write", "ci-fix.md", "VERDICT: FAIL")])
         bus = VizBus()

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/tests/test_isolation.py

@@ -2251,7 +2251,11 @@ class TestReaper:
         runner = FakeRunner()
         reaped = reap_orphaned_containers(tmp_path / "state", runner)
         assert reaped == [name]
-        assert runner.calls == [["docker", "rm", "-f", name]]
+        assert runner.calls == [
+            ["docker", "rm", "-f", name],
+            ["docker", "ps", "-a", "--filter", f"name={name}",
+             "--format", "{{.Names}}"],
+        ]
         assert self._read(tmp_path / "state") == []
 
     def test_live_pid_left_alone(self, tmp_path):
@@ -2282,9 +2286,13 @@ class TestReaper:
             "run_id": "r", "name": name, "kind": "network",
             "pid": proc.pid, "process_start": None, "created_at": "now",
         }])
-        runner = FakeRunner()
-        reap_orphaned_containers(tmp_path / "state", runner)
-        assert runner.calls == [["docker", "network", "rm", name]]
+        runner = FakeRunner(ok(""), fail(1, "No such network"))
+        reaped = reap_orphaned_containers(tmp_path / "state", runner)
+        assert reaped == [name]
+        assert runner.calls == [
+            ["docker", "network", "rm", name],
+            ["docker", "network", "inspect", name],
+        ]
         assert self._read(tmp_path / "state") == []
 
     def test_malformed_name_skipped(self, tmp_path):
@@ -2300,11 +2308,65 @@ class TestReaper:
         proc.wait()
         name = f"{'e' * 32}-exec"
         self._write(tmp_path / "state", [self._entry(name, proc.pid)])
-        runner = FakeRunner(fail(1, "No such container"))
-        reap_orphaned_containers(tmp_path / "state", runner)
-        assert runner.calls == [["docker", "rm", "-f", name]]
+        runner = FakeRunner(fail(1, "No such container"), ok(""))
+        reaped = reap_orphaned_containers(tmp_path / "state", runner)
+        assert reaped == [name]
+        assert runner.calls == [
+            ["docker", "rm", "-f", name],
+            ["docker", "ps", "-a", "--filter", f"name={name}",
+             "--format", "{{.Names}}"],
+        ]
         assert self._read(tmp_path / "state") == []
 
+    def test_rm_failure_container_survives_retained(self, tmp_path):
+        proc = subprocess.Popen([sys.executable, "-c", "pass"])
+        proc.wait()
+        name = f"{'a' * 32}-exec"
+        entry = self._entry(name, proc.pid)
+        self._write(tmp_path / "state", [entry])
+        runner = FakeRunner(fail(1, "daemon busy"), ok(name + "\n"))
+        reaped = reap_orphaned_containers(tmp_path / "state", runner)
+        assert reaped == []
+        assert self._read(tmp_path / "state") == [entry]
+        assert runner.calls == [
+            ["docker", "rm", "-f", name],
+            ["docker", "ps", "-a", "--filter", f"name={name}",
+             "--format", "{{.Names}}"],
+        ]
+
+    def test_rm_failure_network_survives_retained(self, tmp_path):
+        proc = subprocess.Popen([sys.executable, "-c", "pass"])
+        proc.wait()
+        name = f"{'a' * 32}-net"
+        entry = {"run_id": "r", "name": name, "kind": "network",
+                 "pid": proc.pid, "process_start": None, "created_at": "now"}
+        self._write(tmp_path / "state", [entry])
+        runner = FakeRunner(fail(1, "daemon busy"), ok(name))
+        reaped = reap_orphaned_containers(tmp_path / "state", runner)
+        assert reaped == []
+        assert self._read(tmp_path / "state") == [entry]
+        assert runner.calls == [
+            ["docker", "network", "rm", name],
+            ["docker", "network", "inspect", name],
+        ]
+
+    def test_missing_network_tolerated(self, tmp_path):
+        proc = subprocess.Popen([sys.executable, "-c", "pass"])
+        proc.wait()
+        name = f"{'a' * 32}-net"
+        entry = {"run_id": "r", "name": name, "kind": "network",
+                 "pid": proc.pid, "process_start": None, "created_at": "now"}
+        self._write(tmp_path / "state", [entry])
+        runner = FakeRunner(fail(1, "No such network"),
+                            fail(1, "No such network"))
+        reaped = reap_orphaned_containers(tmp_path / "state", runner)
+        assert reaped == [name]
+        assert self._read(tmp_path / "state") == []
+        assert runner.calls == [
+            ["docker", "network", "rm", name],
+            ["docker", "network", "inspect", name],
+        ]
+
     def test_no_registry_is_a_noop(self, tmp_path):
         runner = FakeRunner()
         reap_orphaned_containers(tmp_path / "state", runner)

{agentic_dev_loop-1.0.0a49 → agentic_dev_loop-1.0.0a51}/tests/test_viz.py

@@ -764,9 +764,22 @@ class TestServer:
         assert "elapsed_seconds" in PAGE
         assert "elapsed" in PAGE
 
-    def test_page_constant_clears_elapsed(self):
-        assert "clearElapsed" in PAGE
-        assert 'id="elapsed"' in PAGE
+    def test_page_constant_has_total(self):
+        assert 'id="total"' in PAGE
+        assert "total " in PAGE
+
+    def test_page_constant_has_step_time(self):
+        assert "stepTimes" in PAGE
+        assert ".stage-time" in PAGE
+        assert "stage-time" in PAGE
+        assert "liveElapsed" in PAGE
+
+    def test_page_constant_has_loop_total(self):
+        assert "renderTotal" in PAGE
+        assert "started_at" in PAGE
+        assert "setInterval" in PAGE
+        assert "clearInterval" in PAGE
+        assert "total " in PAGE
 
     def test_page_constant_buffers_sse_until_topology_ready(self):
         assert "topologyReady" in PAGE
@@ -933,7 +946,7 @@ El.prototype.querySelectorAll = function (sel) {
 };
 El.prototype.scrollIntoView = function () {};
 
-var STATIC_IDS = ["subject", "attempt", "thread-id", "elapsed", "verdicts",
+var STATIC_IDS = ["subject", "attempt", "thread-id", "total", "verdicts",
                   "stages", "run-log", "mermaid-container", "run-banner",
                   "divider", "sidebar"];
 STATIC_IDS.forEach(function (id) { registry[id] = new El(id); });
@@ -961,6 +974,7 @@ var esInstance = null;
 globalThis.document = document;
 globalThis.window = window;
 var copiedText = null;
+var intervalFn = null;
 // node 21+ ships a read-only `navigator` global, so defineProperty is needed
 Object.defineProperty(globalThis, "navigator", {
   configurable: true,
@@ -990,6 +1004,10 @@ globalThis.fetch = function () {
 };
 globalThis.requestAnimationFrame = function (fn) { fn(); };
 globalThis.setTimeout = function () { return 0; };
+globalThis.setInterval = function (fn) { intervalFn = fn; return 1; };
+globalThis.clearInterval = function () {};
+var fakeNow = 0;
+Date.now = function () { return fakeNow; };
 globalThis.EventSource = function (url) {
   this.url = url;
   this.onmessage = null;
@@ -1012,15 +1030,37 @@ function nodeClasses() {
 }
 function fire(ev) { esInstance.onmessage({ data: JSON.stringify(ev) }); }
 
+function stageTimes() {
+  var out = {};
+  ["dev", "test", "review"].forEach(function (n) {
+    var section = document.getElementById("stage-" + n);
+    var header = section.querySelector(".stage-header");
+    var t = header.querySelector(".stage-time");
+    out[n] = t ? t.textContent : null;
+  });
+  return out;
+}
+function totalText() {
+  var total = document.getElementById("total");
+  return { text: total.textContent, display: total.style.display };
+}
+
 var snapshots = [];
 async function main() {
   // let the topology fetch microtask chain resolve so events are handled
   // live (synchronously inside es.onmessage) instead of buffered
   await new Promise(function (res) { setImmediate(res); });
   EVENTS.forEach(function (ev) {
+    if (ev.type === "__tick") {
+      fakeNow = ev.now;
+      if (intervalFn) { intervalFn(); }
+      return;
+    }
     fire(ev);
     if (ev.type === "state") {
-      snapshots.push({ ev: ev, badges: badges(), classes: nodeClasses() });
+      snapshots.push({ ev: ev, badges: badges(), classes: nodeClasses(),
+                       times: stageTimes(), total: totalText(),
+                       timer: intervalFn !== null });
     }
   });
   // exercise the copy button on the dev console
@@ -1029,7 +1069,9 @@ async function main() {
   copyBtn.listeners["click"]();
   await new Promise(function (res) { setImmediate(res); });
   snapshots.push({ copy: { text: copiedText,
-                           title: copyBtn.getAttribute("title") } });
+                           title: copyBtn.getAttribute("title") },
+                   times: stageTimes(), total: totalText(),
+                   timer: intervalFn !== null });
   console.log(JSON.stringify(snapshots));
 }
 main();
@@ -1167,6 +1209,71 @@ main();
         assert snaps[-1]["copy"]["title"] == "Nothing to copy"
 
 
+    def test_step_header_shows_accumulated_time(self, node, tmp_path):
+        events = [
+            {"type": "run_started", "subject": "s", "max_attempts": 5,
+             "attempt": 1, "thread_id": "t", "started_at": 1000},
+            {"type": "node_started", "node": "dev"},
+            {"type": "node_finished", "node": "dev", "ok": True,
+             "elapsed_seconds": 135},
+            {"type": "state", "attempt": 1, "failed": False},
+            {"type": "node_finished", "node": "dev", "ok": True,
+             "elapsed_seconds": 45},
+            {"type": "state", "attempt": 1, "failed": False},
+        ]
+        snaps = self._run_page(node, events, tmp_path)
+
+        assert snaps[-1]["times"]["dev"] == "3:00"
+        assert snaps[-1]["times"]["test"] == ""
+        assert snaps[-1]["times"]["review"] == ""
+
+    def test_running_stage_shows_live_heartbeat_time(self, node, tmp_path):
+        events = [
+            {"type": "run_started", "subject": "s", "max_attempts": 5,
+             "attempt": 1, "thread_id": "t", "started_at": 1000},
+            {"type": "node_started", "node": "dev"},
+            {"type": "heartbeat", "node": "dev", "elapsed_seconds": 27},
+            {"type": "state", "attempt": 1, "failed": False},
+            {"type": "node_finished", "node": "dev", "ok": True,
+             "elapsed_seconds": 28},
+            {"type": "state", "attempt": 1, "failed": False},
+        ]
+        snaps = self._run_page(node, events, tmp_path)
+
+        assert snaps[0]["times"]["dev"] == "0:27"
+        assert snaps[1]["times"]["dev"] == "0:28"
+
+    def test_loop_total_ticks_then_freezes(self, node, tmp_path):
+        events = [
+            {"type": "run_started", "subject": "s", "max_attempts": 5,
+             "attempt": 1, "thread_id": "t", "started_at": 1000},
+            {"type": "__tick", "now": 1065000},
+            {"type": "state", "attempt": 1, "failed": False},
+            {"type": "run_finished", "success": True, "attempts": 1,
+             "elapsed_seconds": 200},
+        ]
+        snaps = self._run_page(node, events, tmp_path)
+
+        assert snaps[0]["total"]["text"] == "total 1:05"
+        assert snaps[0]["total"]["display"] == "block"
+        assert snaps[-1]["total"]["text"] == "total 3:20"
+
+    def test_loop_total_fallback_without_started_at(self, node, tmp_path):
+        events = [
+            {"type": "run_started", "subject": "s", "max_attempts": 5,
+             "attempt": 1, "thread_id": "t"},
+            {"type": "state", "attempt": 1, "failed": False},
+            {"type": "run_finished", "success": True, "attempts": 1,
+             "elapsed_seconds": 95},
+        ]
+        snaps = self._run_page(node, events, tmp_path)
+
+        assert snaps[0]["timer"] is False
+        assert snaps[0]["total"] == {"text": "", "display": "none"}
+        assert snaps[-1]["total"]["text"] == "total 1:35"
+        assert snaps[-1]["total"]["display"] == "block"
+
+
 class TestDemo:
     def test_run_started_carries_attempt(self, monkeypatch):
         import viz_demo