fix(lanes,reload): count a pipeline run by declarations, and stop the two reload commands merging

Closes #26, #25.

`runs` is the denominator every pass rate on the Workflows page is read
against, and any backwards move opened a new one. Stage detection bounces by
design — one feature reads `implement → tests → implement` as the session
edits, runs the suite and edits again — so a single feature was recorded as
five or six runs, and a lane in constant use reported a handful of passes
spread across dozens of phantom runs. A backwards move now opens a run only
when it is DECLARED; a backwards detection continues the run in flight.
Reaching the final node still closes the run for either, since work after
`done` is new work however it was observed. Replayed over this repo's own lane
the rule takes 26 recorded runs down to the 5 features that actually shipped
through it. The panel itself is unchanged: passes are still declarations only.

`/reload-plugins` and `/reload-skills` were typed back to back. Claude Code
opens its slash-command menu the moment `/` is typed and the Enter that follows
lands on that menu, so the second command was appended to the line still in the
composer and the pane submitted `/reload-plugins/reload-skills` — which Claude
Code runs as `/reload-plugins` with an argument, never reloading skills, and
leaving a stray prompt turn in the scrollback. Reproduced and fixed against a
live pane: SETTLE_MS (1s) between the two sends, which makes
`reloadOpenSessions` async rather than block the event loop, and the same pause
in the detached update-all worker.

server/__tests__/cc-reload.test.js

@@ -103,11 +103,11 @@ describe("reloadableLanes", () => {
 describe("reloadOpenSessions", () => {
   beforeEach(() => tmux.__reset());
 
-  it("types both reload commands, plugins before skills", () => {
+  it("types both reload commands, plugins before skills", async () => {
     // Order matters: a skill shipped BY a plugin only exists on disk once the
     // plugin itself has been reloaded.
     const calls = stubTmux(["agenthub-lane-7"]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
 
     assert.deepEqual(out.commands, ["/reload-plugins", "/reload-skills"]);
     assert.equal(out.lanes_total, 1);
@@ -119,27 +119,45 @@ describe("reloadOpenSessions", () => {
     assert.equal(calls.filter((c) => c[0] === "send-keys" && c[3] === "Enter").length, 2);
   });
 
-  it("honours a narrowed kinds list", () => {
+  it("waits between the two commands so they cannot share one composer line", async () => {
+    // Without the pause the first Enter lands on Claude Code's slash-command
+    // menu, the second command is appended to the line still in the composer,
+    // and the pane submits `/reload-plugins/reload-skills` as a prompt — the
+    // reported bug. Timing is the behaviour, so timing is what is asserted.
     const calls = stubTmux(["agenthub-lane-1"]);
-    const out = reloadOpenSessions({ kinds: ["skills"] });
+    const at = [];
+    const typed = () => calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").length;
+    const before = typed();
+    const started = Date.now();
+    const done = reloadOpenSessions({ settleMs: 40 });
+    at.push(typed() - before);
+    await done;
+
+    assert.equal(at[0], 1, "only the first command is typed before the wait");
+    assert.ok(Date.now() - started >= 35, "the second command waited for the first to submit");
+  });
+
+  it("honours a narrowed kinds list", async () => {
+    const calls = stubTmux(["agenthub-lane-1"]);
+    const out = await reloadOpenSessions({ kinds: ["skills"], settleMs: 0 });
     assert.deepEqual(out.commands, ["/reload-skills"]);
     const typed = calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").map((c) => c[4]);
     assert.deepEqual(typed, ["/reload-skills"]);
   });
 
-  it("ignores an unknown kind rather than typing it into a REPL", () => {
+  it("ignores an unknown kind rather than typing it into a REPL", async () => {
     // The command set is fixed in the module; a pane's stdin is not a place to
     // forward caller-supplied strings.
     const calls = stubTmux(["agenthub-lane-1"]);
-    const out = reloadOpenSessions({ kinds: ["plugins", "rm -rf /"] });
+    const out = await reloadOpenSessions({ kinds: ["plugins", "rm -rf /"], settleMs: 0 });
     assert.deepEqual(out.commands, ["/reload-plugins"]);
     const typed = calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").map((c) => c[4]);
     assert.deepEqual(typed, ["/reload-plugins"]);
   });
 
-  it("types into several lanes in one call", () => {
+  it("types into several lanes in one call", async () => {
     stubTmux(["agenthub-lane-1", "agenthub-lane-2"]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     assert.equal(out.lanes_total, 2);
     assert.deepEqual(
       out.lanes.map((l) => l.laneId).sort((a, b) => a - b),
@@ -147,9 +165,9 @@ describe("reloadOpenSessions", () => {
     );
   });
 
-  it("records a pane that dies mid-send without failing the others", () => {
+  it("records a pane that dies mid-send without failing the others", async () => {
     stubTmux(["agenthub-lane-1", "agenthub-lane-2"], { "agenthub-lane-1": "__send-fails__" });
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     const failed = out.lanes.find((l) => l.id === "agenthub-lane-1");
     const ok = out.lanes.find((l) => l.id === "agenthub-lane-2");
     assert.match(failed.error, /died mid-send/);
@@ -158,9 +176,9 @@ describe("reloadOpenSessions", () => {
     assert.equal(ok.error, undefined);
   });
 
-  it("reports an empty result instead of throwing when nothing is open", () => {
+  it("reports an empty result instead of throwing when nothing is open", async () => {
     stubTmux([]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     assert.equal(out.lanes_total, 0);
     assert.deepEqual(out.lanes, []);
   });

server/__tests__/lane-stage-events.test.js

@@ -93,6 +93,26 @@ describe("lane_stage_events", () => {
     );
   });
 
+  it("keeps the run in flight when a DETECTION moves backwards", () => {
+    // Detection bounces by design: one feature reads implement → tests →
+    // implement as the session edits, runs the suite and edits again. Counting
+    // each bounce as a new run recorded this repo's own lane as 26 features
+    // when 5 had shipped, and `runs` is what every pass rate is divided by.
+    lanesLib.recordDetection(laneId, { nodeId: "implement", signal: "`edit`" });
+    lanesLib.recordDetection(laneId, { nodeId: "tests", signal: "`npm test`" });
+    // The bounce back only reaches the log once the standing detection has aged
+    // past the TTL — forward-only holds while it is fresh (see recordDetection).
+    db.prepare("UPDATE lanes SET detected_at = '2020-01-01T00:00:00.000Z' WHERE id = ?").run(
+      laneId
+    );
+    lanesLib.recordDetection(laneId, { nodeId: "implement", signal: "`edit`" });
+
+    assert.deepEqual(
+      events().map((r) => `${r.node_id}#${r.run_seq}`),
+      ["implement#1", "tests#1", "implement#1"]
+    );
+  });
+
   it("starts a new run when the pipeline's last node is left behind", () => {
     lanesLib.setStage(laneId, { stage: "done" });
     lanesLib.setStage(laneId, { stage: "intake" });