From a41032db86e064d55ee0aa734d89916edb288820 Mon Sep 17 00:00:00 2001 From: archae0pteryx Date: Fri, 13 Nov 2026 10:45:18 -0800 Subject: [PATCH 1/2] Assign exchange ids and queue places in one graph admission. --- docs/common-format.md | 4 +- docs/tap-records.md | 8 +++- src/exchange/exchanges.rs | 16 ++------ src/exchange/tests.rs | 79 ++++++++++++++++++++++++++++++++++++++- src/graph/mod.rs | 12 ++++-- src/graph/place.rs | 2 +- src/graph/steps.rs | 62 +++++++++++++++++------------- 7 files changed, 136 insertions(+), 47 deletions(-) diff --git a/docs/common-format.md b/docs/common-format.md index 4e9c319..efcdf62 100644 --- a/docs/common-format.md +++ b/docs/common-format.md @@ -69,11 +69,13 @@ Topology nodes are `project` (a git repository, the root), `session` (one run of | `in_session` | implemented | thread belongs to a session | `x-claude-code-session-id` | `session-id` header, `client_metadata.session_id` | | `in_thread` | implemented | exchange belongs to a thread | main agent when no `x-claude-code-agent-id`, else that agent id | `thread-id` header, `client_metadata.thread_id` | | `spawned` | implemented | child thread to the parent thread that launched it | child sends `x-claude-code-request-class: subagent`, `x-claude-code-agent-id`, `x-claude-code-agent-type`, and `x-claude-code-parent-agent-id` when launched by another subagent (observed two levels) | child sends `x-codex-parent-thread-id` and `x-openai-subagent: collab_spawn`; the child has a new `thread-id` and the parent's `session-id`; also `parent_thread_id` in `x-codex-turn-metadata` (observed two levels) | -| `continues` | implemented | step follows the previous step of its thread | `diagnostics.previous_message_id` against the earlier reply's `message.id` (both ids are captured in the tap as `previous_message_id` on `conversation` and `message_id` on `reply_end`; equal in one live run: the second request of a `claude -p --continue` pair named the first reply) | same `thread-id`, ordered by reply completion, not arrival (a socket carries many); an exchange's first record waits for the earlier exchanges of its thread to write their first record or end (at most 2 s), so a held-up record does not let a later step go first | +| `continues` | implemented | step follows the previous step of its thread | `diagnostics.previous_message_id` against the earlier reply's `message.id` (both ids are captured in the tap as `previous_message_id` on `conversation` and `message_id` on `reply_end`; equal in one live run: the second request of a `claude -p --continue` pair named the first reply) | same adapter and `thread-id`; without a previous message id, continues the last step linked by the graph. First records respect exchange admission order within a bounded wait; later records of a socket follow reply completion | | `turn` | implemented | exchanges answering one user prompt | `x-claude-code-prompt-id` | `turn_id` in the `x-codex-turn-metadata` header and `client_metadata` | | `calls` | implemented | `tool_call` to its `tool_result` | `id` to `call_id` | `call_id` | | `follows`, `contains` | no new data | order of messages, nesting of blocks | by position | by position | +Exchange order means graph admission order, not entry into `Exchanges::begin` or connection arrival. After adapter identity extraction, one short graph-owned critical section assigns the exchange id and registers its thread queue place together. Adapter code, project lookup, parsing and sink writes run outside that section. The first record waits up to 2 s for earlier admitted exchanges of the same adapter/thread to write their first record and step edges or end; later records of that exchange do not wait again. This is distinct from live-line emission order and the writer's delivery sequence; see [exchange admission order](tap-records.md#exchange-admission-order). + - Each exchange sets `thread_role` from its own headers, with no state shared across exchanges. Claude Code: `subagent` is `x-claude-code-request-class: subagent` with `x-claude-code-agent-id`; `main` is `request-class: main` with no agent id; anything else, including a subagent class with no agent id and class `main` with an agent id, is `unknown`. Codex: `subagent` is `x-codex-parent-thread-id`, or a non-empty `x-openai-subagent` (observed `collab_spawn`); `main` is `thread-id` equal to `session-id` with neither subagent header; anything else, including a missing id, is `unknown`. `unknown` is never promoted to `main`. Basis: a live probe (probe 2026-10-29) saw 3 main and 1 subagent Claude Code exchanges and 1 main and 1 subagent Codex exchange, so Codex main rests on a one-exchange sample. It is the top-level `thread_role` of every line that carries `thread`. - The subagent shares its parent's session id in both harnesses, so `in_session` alone does not separate agents. `in_thread` and `spawned` do. - Claude Code has no thread id. A subagent is told apart by its agent id, and the main agent is the session itself. A subagent request with no agent id has no parent, so it writes no `spawned` edge: its thread would be the session itself. diff --git a/docs/tap-records.md b/docs/tap-records.md index d35e1c2..d075029 100644 --- a/docs/tap-records.md +++ b/docs/tap-records.md @@ -22,6 +22,12 @@ Record-order waits, continuation history and tool-call matching use `(adapter, t The capture identity is independent of native harness sessions and wrapper run attribution. Diagnostic `--shape-file` output has its own format and carries none of `run_id`, `schema_version` or `sequence`. +## Exchange admission order + +Exchange ids follow graph admission order, not connection arrival or entry into `Exchanges::begin`. Adapter identity is extracted first. One graph-owned critical section then assigns the id and registers a queue place for a known `(adapter, thread)` together, so no assigned earlier exchange is invisible to the thread's queue. Adapter code, project lookup, parsing and sink writes run outside that section. Anonymous and note-only exchanges share the counter but reserve no thread queue place. + +An exchange's first record waits up to 2 s for earlier admitted exchanges of its adapter/thread to write their first record and step edges or end. After that record and its edges are written, the exchange releases its place; its later records do not wait again. The timeout still allows progress past an unfinished earlier exchange. Without a `previous_message_id`, a step continues the most recently linked step of its adapter/thread. Exchange ids do not order live-line emission or replace the writer's delivery sequence. + ## Delivery cursor Every emitted tap envelope carries a `sequence`: a strictly increasing, 1-based integer scoped to its `run_id`. The single tap writer assigns it after dequeue, before encoding, so `(run_id, sequence)` describes emission/file order across all exchanges, including reliable writes that waited for queue space. A new proxy run starts at sequence 1 with a fresh `run_id`, even when appending to the same file. No sequence allocation, locks or waits are added to forwarding. @@ -45,7 +51,7 @@ Every emitted tap envelope carries a `sequence`: a strictly increasing, 1-based | `error` | `{error_type}` | The upstream reports an error. No message text. | | `unparsed` | `{side}` where side is `request` or `reply` | The request or reply could not be read (too large, or still compressed) | | `unsupported` | `{host, path, label?}` | A claimed host's adapter declined to read the request. The bytes were relayed untouched. No content. | -| `edge` | `{kind, from, to, branch?}` | One relation of the exchange, written after `exchange_start`: `in_project` (session to project, with the branch), `in_session` (thread to session), `in_thread` (exchange to thread), `spawned` (thread to parent thread; a Claude Code subagent request with no agent id has no parent and writes none). Nodes are named `project:`, `session:`, `thread:`, `exchange:`. Only ids from request headers; an edge whose ends are unknown is not written. After each `record` the exchange also writes, per step, `turn` (`step:.` to `turn:`) and `continues` (the step to the step before it on the thread: the one whose reply `message_id` equals this request's `previous_message_id`, else the thread's last step). A step whose request carries a `tool_result` that answers an open `tool_call` of the same thread also writes `calls` (`call:` to `result:`); the call then closes, so a result resent in later requests adds nothing, and at most 4096 calls stay open across the whole run, forgetting the oldest first. A step with no known thread, an empty id, or a call whose reply was never recorded writes no `calls` edge; a result that reaches the tracker before its call's record is written is paired on a later resend. The thread state is bounded at 1024 threads, dropping the one seen first; a thread keeps at most 1024 reply ids. Without a `previous_message_id` the step before is the last step to finish writing its record, so overlapping requests on one thread are ordered by reply completion, not arrival. A record without a request has no `step` and writes no step edges. A step that names no turn gets the header turn only when it is step 1. | +| `edge` | `{kind, from, to, branch?}` | One relation of the exchange, written after `exchange_start`: `in_project` (session to project, with the branch), `in_session` (thread to session), `in_thread` (exchange to thread), `spawned` (thread to parent thread; a Claude Code subagent request with no agent id has no parent and writes none). Nodes are named `project:`, `session:`, `thread:`, `exchange:`. Only ids from request headers; an edge whose ends are unknown is not written. After each `record` the exchange also writes, per step, `turn` (`step:.` to `turn:`) and `continues` (the step to the step whose reply `message_id` equals this request's `previous_message_id`; an unknown reply id gives no edge, and only a request with no previous id uses the thread's last linked step). A step whose request carries a `tool_result` that answers an open `tool_call` of the same adapter/thread also writes `calls` (`call:` to `result:`); the call then closes, so a result resent in later requests adds nothing, and at most 4096 calls stay open across the whole run, forgetting the oldest first. A step with no known thread, an empty id, or a call whose reply was never recorded writes no `calls` edge; a result that reaches the tracker before its call's record is linked is paired on a later resend. The thread state is bounded at 1024 threads, dropping the one seen first; a thread keeps at most 1024 reply ids. First records use the bounded admission-order wait above; later records of an exchange do not wait again. A record without a request has no `step` and writes no step edges. A step that names no turn gets the header turn only when it is step 1. | | `tunnel` | `{host, port, label?}` | A connection to a host no adapter claims was tunnelled, unread. Adapter name `none`. | `exchange_start` and `tunnel`/`unsupported` carry `label: {command, dir}` only when the connection told the proxy which agent command and directory started it (see the wrappers in the README); it is metadata, not message content. diff --git a/src/exchange/exchanges.rs b/src/exchange/exchanges.rs index 1f21a86..f6a5e85 100644 --- a/src/exchange/exchanges.rs +++ b/src/exchange/exchanges.rs @@ -3,13 +3,12 @@ use super::recorder::Recorder; use super::tap::Recording; use super::{Clock, ExchangeTap, TapOutput}; use crate::adapter::{Adapter, ExchangeParser, RequestHead}; -use crate::graph::{Steps, Tracker}; +use crate::graph::Tracker; use crate::line::Entry; use crate::note::{ExchangeStart, Label, Note}; use crate::project::ProjectLookups; use crate::shape::{ShapeLog, ShapedParser}; use std::path::PathBuf; -use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; /// One request an adapter claimed, as `Exchanges::begin` takes it. @@ -24,7 +23,6 @@ pub struct Opening<'a> { /// Gives every exchange its id, its record and its edges. Nothing here waits for the project lookup or the sink. pub struct Exchanges { - next_exchange: AtomicU64, clock: Clock, output: TapOutput, shapes: Option>, @@ -35,7 +33,6 @@ pub struct Exchanges { impl Exchanges { pub fn new(output: TapOutput, shapes: Option>, projects: ProjectLookups) -> Self { Self { - next_exchange: AtomicU64::new(1), clock: Clock::start(), output, shapes, @@ -47,10 +44,9 @@ impl Exchanges { /// Starts tapping one exchange: writes `exchange_start` now, and the edges once the project is found. pub fn begin(&self, opening: Opening<'_>) -> ExchangeTap { let start = exchange_start(&opening); - let exchange = self.next_exchange(); let identity = opening.adapter.identity(opening.head); - // Joined before the parser is built, so nothing widens the gap between the id and the place in line - let steps = Steps::join(&self.threads, exchange, &identity, opening.adapter.name()); + let steps = self.threads.admit(opening.adapter.name(), &identity); + let exchange = steps.exchange_id(); let recorder = Recorder::start(self.output.clone(), exchange, opening.adapter.name(), identity.clone()); let parser: Box = match &self.shapes { Some(log) => Box::new(ShapedParser::new(log.clone(), opening.parser, exchange, opening.head)), @@ -75,13 +71,9 @@ impl Exchanges { /// Writes one line under an exchange id of its own, for something that happened without an exchange. pub fn note_alone(&self, adapter: &'static str, note: Note) { - let recorder = Recorder::new(self.output.clone(), self.next_exchange(), adapter); + let recorder = Recorder::new(self.output.clone(), self.threads.note_exchange(), adapter); recorder.write(self.clock.stamp(), Entry::Note(note), (0, 0), None); } - - fn next_exchange(&self) -> u64 { - self.next_exchange.fetch_add(1, Ordering::Relaxed) - } } fn exchange_start(opening: &Opening<'_>) -> Note { diff --git a/src/exchange/tests.rs b/src/exchange/tests.rs index 551c295..5538d90 100644 --- a/src/exchange/tests.rs +++ b/src/exchange/tests.rs @@ -1063,7 +1063,7 @@ fn written_edges(lines: &[Value]) -> Vec { edges } -/// Begins one exchange of thread `t1` per entry of `replies` at once, all recording through one `Exchanges`. +/// Admits one exchange of thread `t1` per entry of `replies` sequentially, then records them concurrently. /// The exchange numbered `late` (counting from 0) has its project lookup held back briefly, so either order can win. async fn race_one_thread(replies: Vec>, late: Option) -> Vec { let slow_lookup = ProjectCache::locating_with(|_| { @@ -1089,6 +1089,58 @@ fn which_exchange_is_late(run: usize, exchanges: usize) -> Option { (run % (exchanges + 1)).checked_sub(1) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn concurrent_exchanges_get_ids_and_continuation_edges_in_admission_order() { + // A paused identity reserves no invisible earlier ID; the exchange admitted first records first. + let Capture { + exchanges, mut drained, .. + } = Capture::new(); + let exchanges = Arc::new(exchanges); + let (entered, paused) = std::sync::mpsc::channel(); + let (release, resume) = std::sync::mpsc::channel(); + let delayed = PausingIdentity { + who: on_thread("t1"), + entered, + resume: Mutex::new(resume), + }; + let shared = exchanges.clone(); + let delayed_begin = tokio::task::spawn_blocking(move || { + begin_with( + &shared, + &delayed, + None, + Box::new(Emits { + events: closed_reply(), + release: None, + }), + ) + }); + paused.recv_timeout(WAIT).unwrap(); + + let ahead = begin_with( + &exchanges, + &on_thread("t1"), + None, + Box::new(Emits { + events: closed_reply(), + release: None, + }), + ); + ahead.end(Side::Response); + drop(ahead); + let first = drain_ended(&mut drained, 1).await; + release.send(()).unwrap(); + let behind = delayed_begin.await.unwrap(); + behind.end(Side::Response); + drop(behind); + let second = drain_ended(&mut drained, 1).await; + + assert_eq!(record_of(&first)["exchange"], 1); + assert_eq!(record_of(&second)["exchange"], 2); + assert!(step_edges(&first).is_empty()); + assert_eq!(step_edges(&second), [edge("continues", "step:2.1", "step:1.1")]); +} + #[tokio::test(flavor = "multi_thread", worker_threads = 4)] async fn two_claude_exchanges_of_one_thread_continue_by_message_id_however_the_first_record_is_held_up() { // Whichever exchange's record is held up, the step naming m1 continues the reply with m1 and pairs c1 @@ -1131,7 +1183,7 @@ async fn two_claude_exchanges_of_one_thread_continue_by_message_id_however_the_f } #[tokio::test(flavor = "multi_thread", worker_threads = 4)] -async fn codex_exchanges_of_one_thread_form_one_chain_in_the_order_their_exchanges_began() { +async fn codex_exchanges_of_one_thread_form_one_chain_in_admission_order() { // With no previous message id each step continues the one before it, however the records are held up for run in 0..50 { let replies = vec![closed_reply(), closed_reply(), closed_reply()]; @@ -1401,6 +1453,29 @@ async fn a_stalled_parser_gives_an_incomplete_record_that_counts_the_dropped_inp struct Identifying(Identity); +struct PausingIdentity { + who: Identifying, + entered: std::sync::mpsc::Sender<()>, + resume: Mutex>, +} + +impl Adapter for PausingIdentity { + fn name(&self) -> &'static str { + self.who.name() + } + fn hosts(&self) -> &[String] { + &[] + } + fn claim(&self, _head: &RequestHead) -> Option> { + None + } + fn identity(&self, head: &RequestHead) -> Identity { + self.entered.send(()).unwrap(); + self.resume.lock().unwrap().recv_timeout(WAIT).unwrap(); + self.who.identity(head) + } +} + struct Named(&'static str, Identifying); impl Adapter for Named { diff --git a/src/graph/mod.rs b/src/graph/mod.rs index c4fcde7..31f0319 100644 --- a/src/graph/mod.rs +++ b/src/graph/mod.rs @@ -73,10 +73,11 @@ impl Thread { } } -/// Remembers the last step and the open tool calls of each thread, bounded, so a step can say which -/// step it continues and which call its results answer. +/// Owns exchange admission and bounded thread history, so a step can say which step it continues +/// and which call its results answer. #[derive(Default)] struct Threads { + last_exchange: u64, seen: HashMap, order: VecDeque, calls: Calls, @@ -84,6 +85,11 @@ struct Threads { } impl Threads { + fn next_exchange(&mut self) -> u64 { + self.last_exchange += 1; + self.last_exchange + } + /// Puts an exchange in line among the exchanges of its thread, so its records can wait for earlier ones. fn join(&self, thread: &Thread, exchange: u64) -> Place { self.queue.join(thread, exchange) @@ -251,7 +257,7 @@ mod tests { #[test] fn a_later_step_on_a_thread_continues_the_one_before_it() { - // Without a previous message id it follows arrival order, across exchanges and within a socket + // Without a previous message id it follows record-link order, across exchanges and within a socket let mut threads = Threads::default(); let first = threads.edges(&step("t1", 7, 1)); diff --git a/src/graph/place.rs b/src/graph/place.rs index 3f4238d..f82e0d7 100644 --- a/src/graph/place.rs +++ b/src/graph/place.rs @@ -7,7 +7,7 @@ use tokio::sync::Notify; use tokio::time::timeout; /// The exchanges of each thread that have not yet written their first record, so records can be -/// written in the order their exchanges began. +/// written in the order their exchanges were admitted. #[derive(Default)] pub(super) struct Queue { waiting: Mutex>>, diff --git a/src/graph/steps.rs b/src/graph/steps.rs index 8ad0ee1..ae0c6fa 100644 --- a/src/graph/steps.rs +++ b/src/graph/steps.rs @@ -10,7 +10,7 @@ use std::time::Duration; /// How long a record waits for the earlier exchanges of its thread before it goes ahead regardless. const TURN_WAIT: Duration = Duration::from_secs(2); -/// What the exchanges of one proxy share: the threads seen so far and each exchange's place in line. +/// What one proxy shares: exchange admission order, thread history and each exchange's place in line. #[derive(Clone, Default)] pub(crate) struct Tracker(Arc>); @@ -24,19 +24,18 @@ pub(crate) struct Steps { open: Option, } -impl Steps { - /// Puts the exchange in line among the exchanges of its thread, so its records wait for earlier ones. - pub(crate) fn join(tracker: &Tracker, exchange: u64, identity: &Identity, adapter: &'static str) -> Self { +impl Tracker { + /// Assigns an id and a place in line together, after the adapter has supplied its identity. + pub(crate) fn admit(&self, adapter: &'static str, identity: &Identity) -> Steps { let thread = identity.thread.as_deref().map(|id| Thread::new(adapter, id)); - let place = thread.as_ref().map(|thread| { - tracker - .0 - .lock() - .unwrap_or_else(PoisonError::into_inner) - .join(thread, exchange) - }); - Self { - tracker: tracker.clone(), + let (exchange, place) = { + let mut threads = self.0.lock().unwrap_or_else(PoisonError::into_inner); + let exchange = threads.next_exchange(); + let place = thread.as_ref().map(|thread| threads.join(thread, exchange)); + (exchange, place) + }; + Steps { + tracker: self.clone(), place, thread, header_turn: identity.turn.clone(), @@ -45,6 +44,17 @@ impl Steps { } } + /// Names a standalone note without reserving a place in any thread's record queue. + pub(crate) fn note_exchange(&self) -> u64 { + self.0.lock().unwrap_or_else(PoisonError::into_inner).next_exchange() + } +} + +impl Steps { + pub(crate) fn exchange_id(&self) -> u64 { + self.exchange + } + /// The step of the record a live line is folded into, taken before the line is folded. pub(crate) fn of_line(&mut self, event: &Event) -> Option { match event { @@ -130,7 +140,7 @@ mod tests { #[test] fn a_live_line_carries_the_step_of_the_request_it_is_folded_into() { // The request line and every line up to its reply end show its step; a line with no request open shows none - let mut steps = Steps::join(&Tracker::default(), 7, &Identity::default(), "test"); + let mut steps = Tracker::default().admit("test", &Identity::default()); let usage = Event::Usage(Default::default()); let before = steps.of_line(&usage); @@ -148,7 +158,7 @@ mod tests { #[test] fn a_request_that_states_no_step_opens_step_one() { // A Claude exchange is one request, so its lines show step 1 - let mut steps = Steps::join(&Tracker::default(), 7, &Identity::default(), "test"); + let mut steps = Tracker::default().admit("test", &Identity::default()); assert_eq!(steps.of_line(&Event::Conversation(request(None, None))), Some(1)); } @@ -156,7 +166,7 @@ mod tests { #[tokio::test] async fn a_request_that_states_its_step_and_turn_gives_them_to_the_record() { // It copies the step and turn of the conversation onto the record - let steps = Steps::join(&Tracker::default(), 7, &header_turn("h1"), "test"); + let steps = Tracker::default().admit("test", &header_turn("h1")); let mut record = record_of(Some(request(Some(3), Some("u2")))); steps.link(&mut record).await; @@ -167,8 +177,8 @@ mod tests { #[tokio::test] async fn a_request_that_states_no_step_is_step_one_of_the_header_turn() { // A Claude exchange is one request, so the record is step 1 in the turn its headers name, or none - let named = Steps::join(&Tracker::default(), 7, &header_turn("h1"), "test"); - let unnamed = Steps::join(&Tracker::default(), 7, &Identity::default(), "test"); + let named = Tracker::default().admit("test", &header_turn("h1")); + let unnamed = Tracker::default().admit("test", &Identity::default()); let mut in_turn = record_of(Some(request(None, None))); let mut no_turn = record_of(Some(request(None, None))); @@ -182,14 +192,12 @@ mod tests { #[tokio::test] async fn a_record_without_a_request_names_no_step_and_no_turn() { // An unparsed request leaves no step, so it cannot collide with the real first one, and links nothing - let steps = Steps::join( - &Tracker::default(), - 7, + let steps = Tracker::default().admit( + "test", &Identity { thread: Some("t1".into()), ..header_turn("h1") }, - "test", ); let mut record = record_of(None); @@ -203,8 +211,8 @@ mod tests { async fn a_later_exchange_of_a_thread_continues_the_step_of_an_earlier_one() { // Exchanges that share a tracker link their steps across exchanges let tracker = Tracker::default(); - let first = Steps::join(&tracker, 1, &on_thread("t1"), "test"); - let second = Steps::join(&tracker, 2, &on_thread("t1"), "test"); + let first = tracker.admit("test", &on_thread("t1")); + let second = tracker.admit("test", &on_thread("t1")); first.link(&mut record_of(Some(request(None, None)))).await; first.leave(); @@ -217,18 +225,18 @@ mod tests { async fn the_thread_bound_is_shared_across_adapters() { // Activity across both adapters evicts the oldest thread under one global bound. let tracker = Tracker::default(); - let first = Steps::join(&tracker, 1, &on_thread("first"), "claude"); + let first = tracker.admit("claude", &on_thread("first")); first.link(&mut record_of(Some(request(None, None)))).await; first.leave(); for exchange in 2..=super::super::THREAD_BOUND as u64 + 1 { let adapter = if exchange % 2 == 0 { "claude" } else { "codex" }; let identity = on_thread(&format!("t{}", exchange / 2)); - let steps = Steps::join(&tracker, exchange, &identity, adapter); + let steps = tracker.admit(adapter, &identity); steps.link(&mut record_of(Some(request(None, None)))).await; steps.leave(); } - let revisited = Steps::join(&tracker, 9999, &on_thread("first"), "claude"); + let revisited = tracker.admit("claude", &on_thread("first")); let edges = revisited.link(&mut record_of(Some(request(None, None)))).await; assert!(edges.is_empty()); From f921ade8a2da79589cbe34684e4e1c64e63182f4 Mon Sep 17 00:00:00 2001 From: archae0pteryx Date: Fri, 13 Nov 2026 10:55:36 -0800 Subject: [PATCH 2/2] Require local reviews without triggering GitHub review bots. --- AGENTS.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index d985646..3ab6ea2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -70,8 +70,9 @@ Integrate by rebasing the lane onto `main`, running the gate, and opening a pull only after all CI checks pass. Commit and code push require the user's request; report proposed commands at handoff otherwise. Beads data stays local; do not push Beads or Dolt state. -To get a pull request reviewed, use the `independent-review` skill -(`killall-skills:independent-review`); it holds the review rules. +Use local independent reviews, not GitHub-triggered reviews. Never post `/review` or other bot +review commands, trigger review bots, or dispatch review workflows. Read existing automatic +CodeRabbit feedback without retriggering it; fix and resolve its findings when the user asks. ## Beads