@@ -1495,7 +1495,13 @@ pub fn phase_judge_need(state: &RuntimeState) -> PhaseJudgeDue {
     let open = phase_judge_open(state);
     if spoke && !open.is_empty() {
         PhaseJudgeDue::Spoken
-    } else if typed && open.contains(&"coding") {
+    } else if typed
+        && (open.contains(&"coding")
+            || (!state.behavioral_round_started
+                && !open.is_empty()
+                && typed_comments(&state.language, &state.code)
+                    != typed_comments(&state.judged_language, &state.judged_code)))
+    {
         PhaseJudgeDue::EditorOnly
     } else {
         PhaseJudgeDue::No
@@ -1570,19 +1576,34 @@ fn quote_words(text: &str) -> String {
         .join(" ")
 }
 
-/// The comments in `code`: what follows a line's leading comment marker. Read
-/// apart from the code, so a step is quoted from an explanation, not from the
-/// code that is Coding's.
-fn typed_comments(code: &str) -> String {
-    code.lines()
-        .filter_map(|line| {
-            let line = line.trim_start();
-            ["//", "#", "/*", "*", "--"]
-                .into_iter()
-                .find_map(|marker| line.strip_prefix(marker))
-        })
-        .collect::<Vec<_>>()
-        .join("\n")
+/// The comments in `code`, as `language` writes them: whole-line `#` comments
+/// in Python, and `//` lines and `/* */` blocks in the others. Read apart from
+/// the code, so a step is quoted from an explanation, not from the code that
+/// is Coding's, and only from lines that cannot be code: a C line beginning
+/// with `*` is a dereference outside a block. A block's leading `*` needs no
+/// stripping, since a quote is matched on its words.
+fn typed_comments(language: &str, code: &str) -> String {
+    let mut comments = Vec::new();
+    let mut in_block = false;
+    for line in code.lines().map(str::trim_start) {
+        let text = if language == "python" {
+            line.strip_prefix('#')
+        } else if in_block {
+            Some(line)
+        } else if let Some(text) = line.strip_prefix("/*") {
+            in_block = true;
+            Some(text)
+        } else {
+            line.strip_prefix("//")
+        };
+        let Some(mut text) = text else { continue };
+        if in_block && let Some((head, _)) = text.split_once("*/") {
+            in_block = false;
+            text = head;
+        }
+        comments.push(text);
+    }
+    comments.join("\n")
 }
 
 /// One speaker's turn, as `speaker_turns` reads the transcript.
@@ -1634,8 +1655,9 @@ fn speaker_turns(state: &RuntimeState) -> Vec<Turn> {
     turns
 }
 
-/// Whether `quote` is the candidate's own: words from one recognized candidate
-/// turn, or for Coding, from what they typed into the editor.
+/// Where `quote` is the candidate's own, if it is: words from one recognized
+/// candidate turn, or what they typed into the editor, its code for Coding and
+/// a comment for another coding-round step.
 ///
 /// Proof of who said it, not that the step was done; that judgment stays with
 /// the model and its prompt. What can be checked mechanically is checked: the
@@ -1648,7 +1670,7 @@ fn quote_is_grounded(
     turns: &[Turn],
     phase: FrameworkPhase,
     quote: &str,
-) -> bool {
+) -> Option<EvidenceSource> {
     let words = quote_words(quote);
 
     // A spoken trace is a sentence like any other answer, though Test is about
@@ -1662,32 +1684,30 @@ fn quote_is_grounded(
         MIN_SPOKEN_QUOTE_WORDS
     };
     if words.split(' ').count() < least {
-        return false;
+        return None;
     }
     let needle = format!(" {words} ");
+    let typed = |text: &str| format!(" {} ", quote_words(text)).contains(&needle);
+    let editor = Some(EvidenceSource::EditorSnapshot);
     if phase == FrameworkPhase::Coding {
-        let typed = |code: &str| format!(" {} ", quote_words(code)).contains(&needle);
-        return typed(&state.code) && !typed(starter(state, &state.language));
+        return editor.filter(|_| typed(&state.code) && !typed(starter(state, &state.language)));
     }
 
     // A candidate whose speech was not recognized is asked to type their
     // explanation as a comment, and at an editor without the evidence tool
     // nobody else can record it from there.
-    let commented =
-        |code: &str| format!(" {} ", quote_words(&typed_comments(code))).contains(&needle);
+    let commented = |code: &str| typed(&typed_comments(&state.language, code));
     if !phase.is_star()
         && !state.interview_mode.is_whiteboard()
         && commented(&state.code)
         && !commented(starter(state, &state.language))
     {
-        return true;
+        return editor;
     }
     let mut said = turns.iter().filter(|turn| turn.words.contains(&needle));
-    let Some(first) = said.clone().next() else {
-        return false;
-    };
+    let first = said.clone().next()?;
     if !said.any(|turn| turn.speaker == CANDIDATE_SPEAKER) {
-        return false;
+        return None;
     }
 
     // A trace the interviewer walked first, or a story they told back before
@@ -1698,7 +1718,7 @@ fn quote_is_grounded(
             FrameworkPhase::Algorithm | FrameworkPhase::Optimizations | FrameworkPhase::Test
         ))
         && first.speaker == INTERVIEWER_SPEAKER;
-    !echo
+    (!echo).then_some(EvidenceSource::CandidateSpeech)
 }
 
 /// Records what the judge found, through the same gate the interviewer's calls
@@ -1778,9 +1798,9 @@ pub fn apply_phase_judgment(state: &mut RuntimeState, text: &str) -> Vec<Framewo
             continue;
         }
         let turns = turns.get_or_insert_with(|| speaker_turns(state));
-        if !quote_is_grounded(state, turns, phase, quote) {
+        let Some(source) = quote_is_grounded(state, turns, phase, quote) else {
             continue;
-        }
+        };
         let summary = step
             .get("summary")
             .and_then(serde_json::Value::as_str)
@@ -1797,16 +1817,11 @@ pub fn apply_phase_judgment(state: &mut RuntimeState, text: &str) -> Vec<Framewo
             ),
             None => format!("Quote: {quoted}"),
         };
-        let source = if phase == FrameworkPhase::Coding {
-            "editor_snapshot"
-        } else {
-            "candidate_speech"
-        };
         if let Ok((evidence, RecordOutcome::Added)) = record_evidence(
             state,
             &serde_json::json!({
                 "phase": id,
-                "source": source,
+                "source": evidence_source_id(source),
                 "kind": "observed",
                 "confidence": 70,
                 "summary": summary,
 
@@ -4086,7 +4086,13 @@ fn a_step_explained_in_a_typed_comment_is_the_candidates_own() {
     let mut typed = with_written_code(RuntimeState::default());
     typed.code = format!("# {quote}\n{}", typed.code);
     let algorithm = |quote: &str| json!([{"step": "algorithm", "quote": quote, "summary": "s"}]);
-    assert_eq!(judge(&mut typed.clone(), algorithm(quote)).len(), 1);
+    let recorded = judge(&mut typed.clone(), algorithm(quote));
+    assert_eq!(recorded.len(), 1);
+    assert_eq!(
+        recorded[0].source,
+        EvidenceSource::EditorSnapshot,
+        "typed, not said"
+    );
     assert!(
         judge(
             &mut typed.clone(),
@@ -4106,12 +4112,65 @@ fn a_step_explained_in_a_typed_comment_is_the_candidates_own() {
         "the starter's"
     );
 
-    let mut board = typed;
+    let mut board = typed.clone();
     board.interview_mode = InterviewMode::Whiteboard;
     assert!(
         judge(&mut board, algorithm(quote)).is_empty(),
         "a whiteboard"
     );
+
+    // In C a line beginning with `*` is a comment only inside a block.
+    let mut c = with_written_code(RuntimeState {
+        language: "c".into(),
+        ..RuntimeState::default()
+    });
+    let body = "int f(int *rest) {\n    *rest = keep_every_other_interval_as_it_was;\n}\n";
+    c.code = body.to_string();
+    let deref = "rest keep every other interval as it was";
+    assert!(
+        judge(&mut c.clone(), algorithm(deref)).is_empty(),
+        "a dereference"
+    );
+    c.code = format!("/*\n * {quote}\n */\n{body}");
+    assert!(
+        judge(&mut c.clone(), algorithm(deref)).is_empty(),
+        "code after the block"
+    );
+    assert_eq!(judge(&mut c, algorithm(quote)).len(), 1, "a block comment");
+
+    // A comment typed after Coding is recorded is judged without waiting for
+    // the candidate to speak again; other edits are not.
+    record_framework_evidence(
+        &mut typed,
+        &json!({"phase": "coding", "source": "editor_snapshot", "kind": "observed",
+            "confidence": 90, "summary": "Wrote it."}),
+    )
+    .unwrap();
+    take_phase_judge_window(&mut typed, get_problem(Some("insert-interval")));
+    typed.code.push_str("x = 1\n");
+    assert_eq!(phase_judge_need(&typed), PhaseJudgeDue::No);
+    typed
+        .code
+        .push_str("# then I insert the new interval in order\n");
+    assert_eq!(phase_judge_need(&typed), PhaseJudgeDue::EditorOnly);
+    let mut behavioral = typed.clone();
+    behavioral.behavioral_round_started = true;
+    assert_eq!(
+        phase_judge_need(&behavioral),
+        PhaseJudgeDue::No,
+        "STAR is not typed"
+    );
+    record_framework_evidence(
+        &mut typed,
+        &json!({"phase": "optimizations", "source": "candidate_speech", "kind": "observed",
+            "confidence": 90, "summary": "O(n)."}),
+    )
+    .unwrap();
+    assert_eq!(
+        phase_judge_need(&typed),
+        PhaseJudgeDue::No,
+        "nothing left open"
+    );
 }
 
 /// A whiteboard interviewer holds the evidence tool and records a hand trace