Warm the lint gate's summariser session within a review loop

[adamw]

The review loop's lint gate minted a fresh conversation on every round.
lint() summarised through agent…autonomous.run, which mints
SessionId.fresh per call, so each round re-paid the full cold prefix
(~32k prompt tokens) to produce a few hundred output tokens.

Rebuilding a prefix costs roughly what ~20 cache reads of it cost, so an
agent that re-examines the same material within one stage should resume;
one whose material changes between calls should not. The lint gate is the
first kind — same commands, same working tree, several times per stage.

What changed

• lint gains an overload taking a Chat — the summariser conversation —
  alongside the existing agent-taking signature, which is unchanged and now
  delegates through a single-use chat. Lint.summariser mints it; the parameter type's private[review] constructor
  makes that factory the only source, so the read-only restriction it applies
  cannot be bypassed by passing a bare Chat.
• ReviewLoopState carries that conversation across rounds. It is minted on
  the collecting thread, not in the CheckedPar fan-out, and Configured
  resolution stays at loop entry.

The stale-findings risk, and why the obvious defence wasn't enough

A resumed lint session can re-report an earlier round's findings from memory.
The first version of this change leaned on lint()'s existing short-circuit:
a round whose commands are all silent and exit zero returns
ReviewResult.empty without a turn.

Review showed that defence is largely inert. The short-circuit needs the
command to be completely silent on success, and most real lint commands
print — this repo's own gate is lint = sbt compile, which writes
[success] Total time: …. So the reused conversation would in practice have
been consulted every round, holding every earlier round's findings.

A repeated finding is not free: it re-enters round.issues, triggers a coder
fix turn, the fixer finds nothing to fix, and the loop exits through
"Fixer reported no fixes" with a phantom entry in the returned
IgnoredIssues — on a round that would otherwise have been clean.

The guard is therefore in the code, not the prompt: the conversation carries
forward only while the summariser has reported nothing. Any round in which it
reports anything — gate-admitted or not, since the gate decides what reaches
the fixer, not what the conversation remembers — drops it, so the next round
starts fresh. A conversation that has only ever said "nothing actionable" holds
no finding to repeat, and the round right after a finding, where the risk is
highest, always runs cold. Clean-but-noisy rounds are the common case, so most
of the saving survives.

This bounds re-reporting rather than eliminating it. A resumed conversation
still holds every earlier round's raw lint output and could newly derive from
it a finding it previously declined to make; only the summariser prompt ("the
blocks are this run's output and supersede any earlier ones") speaks to that.
By construction the retained output is output the model already judged
non-actionable.

Warmth applied, not assumed

The other repeat one-shots were enumerated from ManifestSession.kind = "oneShot" records and each judged by the same rule. All stay cold:

one-shot	how often	why it stays cold
reviewer picker (ReviewerSelector.agentDriven)	once per loop, i.e. once per stage	prepare runs once; there is no second call to resume into
commit messages (Flow.defaultCommitMessage)	once per stage, at stage exit	stage N and N+1 describe different work
branch naming (BranchNamingStrategy)	once per run	single call
summarisePr	once per run	single call
stack discovery (StackDiscovery.discover)	once per run	single call

Value

Small and known to be small: the measured baseline ran 8 lint sessions
totalling $0.22, so the ceiling is ~$0.15/run, and the retirement rule gives
some of that back. This is for the cold-start hygiene and the pattern, not
the money.

Tests

• a summariser that reports nothing is resumed across rounds — fails if the
  conversation is re-minted each round;
• a summariser that reports findings is not resumed — fails if the retirement
  rule is dropped;
• a summariser whose finding the gate DROPPED is not resumed either — fails if
  the gate-rejected half of the predicate is dropped.

Each mutation-checked, and each fails only for its own mutation. Substituting
a write-enabled conversation for the summariser is a compile error.
CcNegativeCompileTest and InStageNegativeTest still pass, so the
capture/separation-checking rejections are intact.