Files
codex/codex-rs/app-server/src/request_processors/feedback_thread_index.rs
T
jif 2e5ee418ad Improve Guardian report diagnostics (#42033)
## Why

Reports from a large thread tree can exceed the rollout attachment limit, making
the threads involved in a failed Guardian review harder to diagnose.

## What changed

- Prioritize descendants with retained failed reviews when selecting bounded
  report rollouts, while always preserving the reported thread.
- Include each selected thread's available Guardian trunk rollout alongside its
  conversation rollout.
- Add a thread index attachment with selected filenames, bounded omission details,
  retained failure threads, and the process-wide discarded-record count.
- Link failed-review records to their reviewed turn and target item when available.

## Testing

- Cover failed-review prioritization, bounded omission metadata, discarded-record
  accounting, and turn/item linkage in Guardian report records.

GitOrigin-RevId: ae7916c27a3c279e899cd5a6ead8a4b7e0cc26a1
2026-09-01 11:14:20 +00:00

91 lines
3.5 KiB
Rust

//! Selects a bounded feedback subtree, preserving the reported thread and prioritizing
//! children with retained failed reviews. The index describes selection, not delivery.
use codex_feedback::FeedbackAttachment;
use codex_feedback::GuardianReviewFailures;
use codex_protocol::ThreadId;
use serde::Serialize;
use std::cmp::Reverse;
use std::collections::HashSet;
const MAX_FEEDBACK_TREE_THREADS: usize = 8;
const MAX_LISTED_OMISSIONS: usize = 64;
#[derive(Serialize)]
pub(super) struct FeedbackThreadIndex {
pub threads: Vec<FeedbackThread>,
retained_failure_thread_ids: Vec<ThreadId>,
omitted_thread_ids: Vec<ThreadId>,
unlisted_omitted_thread_count: usize,
process_discarded_review_records: usize,
notes: &'static str,
}
#[derive(Serialize)]
pub(super) struct FeedbackThread {
pub thread_id: ThreadId,
pub rollout_filename: Option<String>,
pub guardian_rollout_filename: Option<String>,
}
impl FeedbackThreadIndex {
pub fn new(
reported_thread_id: ThreadId,
mut subtree: Vec<ThreadId>,
failures: &GuardianReviewFailures,
) -> Self {
// UUIDv7 ordering provides a deterministic newest-child fallback.
subtree.sort_unstable_by_key(|id| Reverse(id.to_string()));
subtree.dedup();
subtree.retain(|id| *id != reported_thread_id);
let descendants = subtree.iter().copied().collect::<HashSet<_>>();
let mut selected = HashSet::from([reported_thread_id]);
let mut thread_ids = vec![reported_thread_id];
for id in failures.thread_ids.iter().chain(&subtree) {
if thread_ids.len() == MAX_FEEDBACK_TREE_THREADS {
break;
}
if descendants.contains(id) && selected.insert(*id) {
thread_ids.push(*id);
}
}
let omitted_count = subtree.len().saturating_sub(thread_ids.len() - 1);
let omitted_thread_ids = subtree
.into_iter()
.filter(|id| !selected.contains(id))
.take(MAX_LISTED_OMISSIONS)
.collect::<Vec<_>>();
Self {
threads: thread_ids
.into_iter()
.map(|thread_id| FeedbackThread {
thread_id,
rollout_filename: None,
guardian_rollout_filename: None,
})
.collect(),
retained_failure_thread_ids: failures.thread_ids.clone(),
unlisted_omitted_thread_count: omitted_count - omitted_thread_ids.len(),
omitted_thread_ids,
process_discarded_review_records: failures.process_discarded_records,
notes: "Selection only, not an upload receipt. Null filenames mean no path was available. \
Omitted threads exceeded the rollout thread limit; their retained reviews are \
still in auto-review-failures.jsonl. Review evidence is process-local and bounded; \
missing evidence does not imply no denial. The discarded-record count is \
process-wide, not specific to this tree, and resets on restart.",
}
}
pub fn attachment(&self) -> serde_json::Result<FeedbackAttachment> {
Ok(FeedbackAttachment {
filename: "feedback-thread-index.json".to_string(),
buffer: serde_json::to_vec(self)?,
content_type: Some("application/json".to_string()),
})
}
}
#[cfg(test)]
#[path = "feedback_thread_index_tests.rs"]
mod tests;