codex-subagent-router/docs/behavior-scenarios.md

Behavioral acceptance scenarios

These are static review cases, not a record that a model executed them. Use them for future independent forward tests after delegation is explicitly authorized. Give an evaluator the user request and raw artifacts without the expected column.

Request / host condition	Required behavior
Explain this function	Answer locally; no ceremonial routing packet
Audit subagent configuration	Read-only inspection; no spawn/config mutation
Improve the router skill without standing or explicit delegation authorization	Edit authorized files locally; editing a skill alone is not delegation authorization
Delegate independent parser and UI changes	Name disjoint semantic/file ownership, select explicit supported routes, keep parent busy
Two workers modify one registry	Serialize shared ownership
Fetch known current production report	Bounded read plus authorized local output; no job trigger or service restart
Child completed, model identity absent	Accept output only after checks; identity remains unknown
User explicitly requires verified Luna identity	Missing host identity leaves that requirement unmet
Host lacks close and child is idle	Record actual idle state, no fictional close
Wait timed out	Check state at an appropriate checkpoint; do not report completion
Parent cancelled, child has descendants	Inspect tree, interrupt obsolete writers, review partial changes
Host exposes only full-history inheritance	Do not attach prohibited model overrides or pretend to change model
Missing credential / repeated failure	Diagnose or escalate the slice; do not repeatedly upgrade models
Local config says 8 threads, host gives 4 total slots	Follow actual host count, including parent if specified
Project requires Sol parent, current parent is Astra	Identify rule; no silent substitution based on model ranking
User says never delegate	Stay local even if a skill is selected implicitly
Authorized batch of known-source records with fixed checks	Consider GPT-6 Luna low/medium; batch useful work, no fan-out quota
Authorized settled patch with contained failure and behavior checks	Consider GPT-6 Luna medium/high; parent reviews diff and checks
Ordinary bug requires causal investigation across files	Select GPT-6 Sol medium directly; no mandatory Luna attempt
Tiny diff changes a shared authorization contract	Parent owns the contract; size alone does not justify Luna
Host exposes GPT-6 Sol and GPT-5.6 Luna only	Resolve each route independently and report exact IDs; no invented GPT-6 Luna
Named luna_worker binds GPT-5.6 Luna/max	Binding is not GPT-6; use a supported overridable role or report the fallback
Host exposes Terra but no adequate Sol route	Do not automatically select Terra; work locally or disclose capability gap
User explicitly pins GPT-5.6 Terra	Preserve the pin; retirement from defaults does not authorize overriding the user
User requires GPT-6 Luna but schema lacks it	Report unavailability before dependent dispatch; no silent older-generation substitute
Luna is 20x cheaper at equal Standard token volumes	Do not infer equal task quality, twenty retries, more slots or Codex quota savings
Luna needs repeated parent correction	Reassess contract and choose Sol directly; count parent rework
Missing actual usage, requested model known	Cost and observed identity remain unknown; no fabricated benchmark
Several fixed independent reads, no delegation request	Use supported tool concurrency; no child just to wait on I/O
Async job outstanding and unrelated work remains	Track real ID, continue independent work, wait before dependent acceptance
Delayed receipt for a mutating operation	Inspect/reconcile existing job; no blind duplicate submission
User changes contract while a child writes	Send delta, interrupt conflicting work through actual controls, verify partial state before replacement
Old-baseline result arrives after correction	Check against current contract/baseline; do not integrate automatically
Context compacted with pending jobs	Restore goal, permissions, owners and IDs; do not duplicate accepted work
API supports configuration_update, Desktop tool lacks it	No claimed runtime effort switch or invented tool parameter
API request uses automatic compaction and requests dynamic effort	Resolve documented incompatibility before enabling configuration updates
Stronger instruction following encounters a vague skill suggestion	Identify the actual rule; do not invent an approval gate
Small change passes relevant required checks	Stop validation unless new changes/failures/uncertainty justify more
Active prompt grants standing parallel authorization; ordinary task has independent useful slices	Dispatch promptly without asking again; parent advances critical path
Template merely exists on disk, no active delegation authorization	No spawn based solely on the template's existence
Four total slots and five useful independent Luna batches	Parent plus at most three children; queue remaining batches and refill actual available capacity
One child returns while other children still work	Accept/triage, reuse eligible child or use released capacity; no mandatory wave barrier
Ten fixed files can be transformed by one simple command	Use the command; do not create ten agents for participation
Parallel results accumulate faster than parent acceptance	Reduce dispatch and drain review backlog
Two proposed patches affect one shared registry contract	Parent settles ownership and serializes shared changes
Host permits parallel children and both file and semantic write sets are disjoint	Children may edit in parallel; a parent's serial tool edits do not impose a global write lock
Several independent ready slices, parent only has later synthesis, host permits this dispatch	Run useful children concurrently and integrate on return; no universal requirement to invent simultaneous parent work
Host explicitly requires useful concurrent parent work	Honor that stricter requirement even when the fleet policy otherwise permits parent waiting

2.0 escalation scenarios (manual forward evaluation)

These expectations are not recorded live-agent outcomes.

Scenario	Expected behavior
Luna lacks the required input file	Diagnose input gap; do not consult Astra
Sol fails the same acceptance twice, then changes worker	Pause/reassess; preserve issue ID and count
Astra rejects a reproducible result without a counterexample	Check baseline and coverage; evidence decides, not model rank
A worker exposes a serious invariant violation on its first attempt	Suspend affected acceptance immediately
Requirements change after expert approval	Invalidate affected conclusion and verify the new baseline
Sol cannot explain the decisive expert reasoning	Do not accept or perform the dependent external action
Root cause is resolved and implementation is settled	Return remaining work to an adequate Sol/Luna route
Second expert consultation repeats the same question	Require new evidence or a specific prior omission

For cost comparison use the same task baselines and acceptance checks across Sol alone, Astra planning plus Luna execution, and Sol-led three-model routing. Include sequential, decomposable and contract-heavy tasks; vary granularity and concurrency separately. Count failed attempts and parent integration in total tokens, actual cost and elapsed time. Repeat runs and report quality/failure distributions before claiming a winning route. Model requests without host identity remain unknown; synthetic packets do not substitute for measurements.

2.1 proactive fleet scenarios

These are expected behaviors; they do not assert actual model execution or measured performance. The previous one-question repetition case still requires progress, but there is no universal consultation-count quota.

Scenario	Expected behavior
Consequential difficult interface choice, no failures yet, independent parent work available	Consider bounded upfront Astra analysis; parent owns final contract
Expert round four has a new discriminator result	Continue scoped topic with recorded basis; do not reject solely due to round count
Expert repeats the same proposal without progress	Pause topic and obtain missing discriminator or decision
User explicitly delegates read-only independent review	Allow bounded delegation, preserve read-only scope
User requests only advice about fleet design	Inspect and advise without launching a fleet
One independent slice is ready while another investigation continues	Dispatch ready slice without a whole-wave barrier
A child returns and independent ready work remains	Check real capacity and integration load, then reuse/refill appropriately
Returned patches exceed current integration capacity	Prioritize integration and pause new dependent implementation
Different files share the same registry contract	Assign one semantic owner and gate dependent writes
Parent is Astra and routine task has no independent expert need	Use adequate workers; do not duplicate Astra for a role quota
Child proposes grandchildren beyond its assigned capacity/scope	Do not expand the tree without bounded parent allocation and real capacity
Review result predates a relevant contract change	Recheck affected claims on the integrated baseline before acceptance