Take evidence recording off the editor reply path

Two in three spoken replies still waited on a tool round, and nearly
every one was the interviewer calling record_framework_evidence for
Repeat, Example or Algorithm: steps the prompt told it to leave alone
and the phase judge records anyway. Each call holds the reply back by a
second model pass. Neither the prompt nor leaving those steps out of
the tool's schema stopped the calls, so at a typed editor the tool is
no longer declared. The prompt says the platform records each step, and
that the editor is not to be read to learn whether one was: without the
tool's replies the model did that instead, a tool round all the same.
Test events there no longer ask for an evidence call either.

The phase judge now covers what only the tool recorded there. It
records Test from a hand trace while nothing can run the written code,
judged with the code in view and only from speech, and the STAR steps,
quoted only from inside the behavioral round and not from a story the
interviewer told first; it reads the round as new once it holds
something, and again when its start moves back to the interviewer turn
in flight. Repeat, Example and Algorithm stay open after Coding while a
step about the code is, and a coding-round step may be quoted from a
comment the candidate typed, as one whose speech was not recognized is
asked to, recorded as an editor snapshot. It can report a declined
probe, and the platform writes the end-of-session skips for a started
round that the wrap-up used to ask for, except where the probe was
declined. The coding round's routine judgments leave 8 of the 48 for a
behavioral round still to come; the last judgment and a round
transition may spend them. A whiteboard keeps the tool, its wording and
the judge as they were, since the judge is not shown the board.

Author: jserv

docs/interview-contract-versions.md

@@ -195,21 +195,26 @@ rate. `CODETRIAL_MAX_INTERIM_REVIEWS` defaults to 6, accepts `0` to disable
 the reviews, and is capped at 72. This is a quota guard, not a completeness
 limit: the final report still receives the complete transcript and editor state.
 
-The phase judge, which records the conversational REACTO steps from the
-candidate's own words, uses the same report model and keys. Every judgment
-needs a candidate turn or editor it has not read, or the window of a call that
-failed, and a step it records still open: Repeat, Example and Algorithm until
-Coding is recorded, Coding and Optimizations while there is code. On the watch
+The phase judge, which records the interview's steps from the candidate's own
+words and editor, uses the same report model and keys. At a typed editor it is
+their only recorder, since the interviewer has no evidence tool there. Every
+judgment needs a candidate turn or editor it has not read, or the window of a
+call that failed, and a step it records still open: Repeat, Example and
+Algorithm until Coding is recorded, and at a typed editor after it while a step
+about the code is, Coding and Optimizations while there is code, and at a typed
+editor Test while nothing can run the written code and the STAR steps once the
+behavioral round has opened, read from where it opened. On the watch
 tick one starts once the candidate has been quiet and not typing for 2 seconds,
 no more often than every 6 seconds, or every 30 seconds when only the editor
 changed; typing pauses every few seconds while Coding is open, so editor-only
 judgments also take at most 12 of the calls. The end and a held round
 transition may start one sooner: the end waits at most 5 seconds in all for its
 judgments, and a round transition is held at most 5 seconds while the room
 keeps running, or until the resume when the interview is paused. Both share the
-ceiling of 48 calls per interview. Each reads at most 6 KiB of transcript tail
-and 6 KiB of editor. A rate limit on a judgment does not cool the key, so the
-judge cannot leave the final report without one.
+ceiling of 48 calls per interview, of which a coding round at a typed editor
+leaves 8 for a behavioral round still to come. Each reads at most 6 KiB of
+transcript tail and 6 KiB of editor. A rate limit on a judgment does not cool
+the key, so the judge cannot leave the final report without one.
 
 ## What bounds concurrency
 
@@ -408,8 +413,8 @@ and prohibit returning to it merely to recover earlier work. They also omit
 coding-run progress cues. Coding checkpoint output is unchanged by these mode
 guards; no token reduction is claimed for this correctness fix.
 
-Only while a pair is configured do `read_editor`, `log_hint` and
-`record_framework_evidence` answers also carry the latest unanswered candidate
+Only while a pair is configured do `read_editor`, `log_hint` and, at a
+whiteboard, `record_framework_evidence` answers also carry the latest unanswered candidate
 utterance, as quoted data, so a reply owed across a cut is not lost, and only
 while a cut is plausible (as below) and the floor is not held. Without a
 pair these application-level additions are omitted. Provider-default sliding

docs/provider-cost-and-degradation.md

@@ -622,7 +622,11 @@ fn apply_test_results(
     };
 
     if let Some(evidence) = recorded {
-        if let Some(reminder) = super::unrecorded_earlier_phases(state, &evidence) {
+        // The reminder asks for an evidence call, which an editor without the
+        // tool cannot make; the judge records what the candidate did.
+        if super::evidence_tool_declared(state.interview_mode)
+            && let Some(reminder) = super::unrecorded_earlier_phases(state, &evidence)
+        {
             reply.push('\n');
             reply.push_str(&reminder);
         }
@@ -819,6 +823,13 @@ fn control_round_transition(
         state.behavioral_round_prior_turn =
             super::last_speaker_line(&state.transcript, INTERVIEWER_SPEAKER)
                 .map(|(index, line)| (index, line.clone()));
+
+        // The judge reads the round from where it opens, which is here until
+        // the interviewer turn in flight at this packet is seen to change and
+        // moves it back: an answer the coding round's judgments read is then
+        // judged again for STAR, because it is inside the round.
+        state.judged_round_from = state.transcript.len();
+        state.judged_last_turn.clear();
         state
             .evidence_ledger
             .record_lifecycle(receipt_timestamp_ms, LifecycleTransition::BehavioralStarted);
@@ -830,7 +841,7 @@ fn control_round_transition(
     } else {
         DataEventResult {
             round_changed: Some("skipped"),
-            generate_reply: Some(round_skipped()),
+            generate_reply: Some(round_skipped(state.interview_mode)),
             ..DataEventResult::default()
         }
     }
@@ -878,10 +889,15 @@ fn control_end_interview(
     payload: &serde_json::Value,
     receipt_timestamp_ms: u64,
 ) -> DataEventResult {
-    // Only for a round that never opened. Once it has, a step left without a
-    // row may be one the candidate declined, which stays unassessed rather than
-    // skipped, and only the conversation can tell the two apart.
-    if !state.behavioral_round_started {
+    // A round that never opened is closed here. Once it has, a step left
+    // without a row may be one the candidate declined, which stays unassessed
+    // rather than skipped, and only the conversation can tell the two apart. An
+    // interviewer holding the evidence tool reads it and records the skips at
+    // the wrap-up. Without the tool the phase judge has read it: the end waits
+    // for its last judgment, which says whether the probe was declined.
+    if !state.behavioral_round_started
+        || (!super::evidence_tool_declared(state.interview_mode) && !state.star_declined)
+    {
         super::skip_unassessed_star(state, "The session ended before assessment.");
     }
     let prior_code = state.code.clone();