v0.7.9.5 — two answers to one question, and the copy nobody read

Both faults are in what 0.7.9.4 had just built, and both are the same
shape: a second copy of an answer that agreed with the first until it
didn't.

#96 — the §3.3 vote has no actor, and the screen named one anyway. The
vote is PARALLEL: every un-voted seat may vote at any moment, in any
order, one refusal ends it, and `apply.ts` says where it accepts one that
there is no actor to be. The turn chart named the last seat to move
before the timetable ran out — no more claim on the vote than anybody
else — directly above a tally correctly showing three seats outstanding.

The cause is worth more than the symptom. `currentActor(game)`
(`web/game.ts`) guarded on `status !== 'active'`; `currentActorOfState`
(`sim/view.ts`), added the same day in #95 and the one the frame calls,
did not, so it handed back whatever `clock.currentActor` was left
holding. The view now carries the guard and `currentActor` delegates to
it. That matters more than the tidiness: `currentActor` is what REFUSES
an intent, so a screen answering differently tells the table to wait on a
player the server would turn away.

The fourth of this class after Gitea#21, #22 and #94 — but the first
found by asking a view helper its question in a state the game is not
`active` in, which is the generalisation and is cheaper than finding the
fifth the same way.

#97 — narration reaches a seat once, by one path. `Frame.lines` carried
the whole log on every push to every seat, and nothing read it:
`RemoteSession` accumulates from `push.lines` alone and its `lines()`
returns that accumulator, so the log was serialised into every frame,
grew all game, and was discarded on arrival while `linesSince` sent the
same text correctly beside it.

The duplicate was masking a bug rather than merely wasting bandwidth.
`connect()` cleared `lastFrame` but not `sentLines`, so a reconnecting
seat was told "nothing new since your last push" while the browser it
answered had just reloaded from an EMPTY accumulator — the history panel
came back blank, mid-game, with the server holding the whole log. So the
two halves are one change, and the plan's instruction taken alone ("stop
passing the full game log into `frameFor()`") would have deleted a real
behaviour rather than a duplicate.

Every remaining reader of `Frame.lines` was checked before the field was
emptied: all of them are the solitaire and replay path, which builds
Frames through `snapshot()` directly and never goes near a session.

One test was wrong before the code was. The first draft of the reconnect
test connected inside its own fixture, so both sides of the comparison
were the empty array and it passed against the broken server. Each test
now asserts its premise is non-empty before comparing.

Also: `docs/plans/jitsi-common-board.md` is committed. It was never added
— not ignored, just missed — while TODO.md cites it twice as the plan for
all of v0.8.0 and the last two releases were built from it, so a clone
got a TODO pointing at a file that did not exist.

917 tests pass, up from 909.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5boPxP6JHRYMm8adXaF5R

test/server/session.test.ts

@@ -531,3 +531,79 @@ describe('§3.3 extended play across the server (Gitea#11)', () => {
     assert.deepEqual(b.official, a.official, 'the official result did not survive the replay');
   });
 });
+
+/**
+ * NARRATION HAS ONE PATH, AND A RECONNECT HAS TO GET ALL OF IT (#97, Gitea#20 step 1).
+ *
+ * The common-board plan asks for one thing here: "stop passing the full game log into `frameFor()`;
+ * continue sending sanitized incremental narration through `Push.lines`." Doing only the first half
+ * would have deleted a real behaviour, so this pins the pair.
+ *
+ * WHAT WAS ACTUALLY WRONG. `Frame.lines` carried the WHOLE log on every push, and nothing read it:
+ * `RemoteSession` (`web/session.ts`) accumulates `lines` from `push.lines` alone and its `lines()`
+ * returns that accumulator. So the log was serialised into every frame for every seat, grew all
+ * game, and was thrown away on arrival — while `linesSince` sent the same text again, correctly,
+ * beside it.
+ *
+ * And the duplicate was masking a bug rather than merely wasting bandwidth. `connect()` clears
+ * `lastFrame` but did NOT clear `sentLines`, so a reconnecting seat was told "nothing new since your
+ * last push" — while the browser it was answering had just reloaded and started from an EMPTY
+ * accumulator. The history panel came back blank after a refresh, mid-game, with the server holding
+ * the whole log and shipping it in the one field nobody reads.
+ *
+ * So the two halves are one change: a (re)connect resets the seat's watermark and `Push.lines` on a
+ * connect IS the history, which is what lets the frame stop carrying a second copy.
+ */
+describe('narration reaches a seat exactly once, by one path (#97)', () => {
+  /**
+   * A session with narration already in the log and NO connect yet, so a first connect is a real
+   * "catch me up" rather than a no-op. Connecting inside this helper is what made the first draft of
+   * the reconnect test pass vacuously: both sides of the comparison were the empty array.
+   */
+  const played = (): GameSession => createSession(550943578, config, ['Alice', 'Bob']);
+
+  it('a FIRST connect carries the narration so far in Push.lines', () => {
+    const session = createSession(550943578, config, ['Alice', 'Bob']);
+    const push = session.connect(0 as PlayerIndex);
+    assert.ok(push.lines.length > 0, 'a first connect was given no narration at all');
+    assert.ok(
+      push.lines.some((l) => /players|competitive/i.test(l.text)),
+      'the opening lines are not in what a first connect received',
+    );
+  });
+
+  it('a RECONNECT is given the whole log again, because the browser it answers has none', () => {
+    const session = played();
+    const first = session.connect(0 as PlayerIndex);
+    const again = session.connect(0 as PlayerIndex);
+    // NON-EMPTY first: two empty arrays are deepEqual, and asserting only that is how this test
+    // passed against the broken code on its first draft.
+    assert.ok(first.lines.length > 0, 'the premise is gone: there was no narration to be given');
+    assert.deepEqual(
+      again.lines,
+      first.lines,
+      'a reconnecting seat was told nothing was new, and its history panel would come back empty',
+    );
+  });
+
+  it('the Frame does NOT carry a second copy of the log', () => {
+    const session = played();
+    const push = session.connect(0 as PlayerIndex);
+    assert.deepEqual(
+      (push.frame as unknown as { lines: unknown[] }).lines,
+      [],
+      'the whole narration log is still being serialised into every Frame, where nothing reads it',
+    );
+  });
+
+  it('an ordinary push after a connect carries only what is NEW', () => {
+    const session = played();
+    const opening = session.connect(0 as PlayerIndex);
+    assert.ok(opening.lines.length > 0);
+    // A second connect for the OTHER seat must not re-send seat 0 anything.
+    const other = session.connect(1 as PlayerIndex);
+    assert.ok(other.lines.length > 0, 'the other seat got no history of its own');
+    const third = session.connect(0 as PlayerIndex);
+    assert.deepEqual(third.lines, opening.lines, 'a reconnect is the full log, every time');
+  });
+});