Skip to content

feat(subagent): wake memory-queued spawns on events with per-lane shares - #17030

Merged
bolichen97 merged 1 commit into
mainfrom
feat/subagent-memory-wake-lane-share
Oct 7, 2026
Merged

bolichen97 merged 1 commit into
mainfrom
feat/subagent-memory-wake-lane-share

Conversation

@bolichen97

@bolichen97 bolichen97 commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A subagent start waiting for memory starts as soon as memory allows it, and one chat's subagent wave cannot take every start that fits while another chat waits for memory.

Since U4 (#17017, merged) removed the count caps, free memory alone bounds concurrency. Two gaps remain:

  • A start the memory floor deferred was re-checked only when its 30 s admit wait passed, even if a child had just finished and freed memory.
  • Memory is now the pool every chat's subagents share. Chat A's wave takes the host to the floor, and chat B's start waits for A's wave to finish. This is the same cross-chat throttle (subagent: admission and queueing redesign (memory floor, bounded wait, accurate queued state) #16480, symptom b), now through memory instead of through a count. The round-robin only orders picks among rows that are already eligible, so it cannot prevent this.

A nested child that shares its parent's runtime also waited at the floor, although its parent, often waiting on exactly that child, already holds the memory. Only the 30-minute max wait could end that.

Why it matters

Anyone who runs subagents from more than one chat on a host near its memory floor sees starts that sit for up to 30 s after memory frees up. One chat's fan-out also takes every admission while the other chat shows "Waiting for memory". A parent waiting on its own shared child at the floor can end only at the max-wait terminal.

Not a goal

What changed (motivation → approach → change)

Root cause: nothing tied a memory wait to the events that move memory, and memory admission had no notion of a lane's share. RFC Q12 (rfc-overload-resilience.md) records the decisions, extending §6 Fairness to memory.

  • Wait record (new admission/memory_wake.py, types.MemoryWait): one entry per start, from its first deferral until it fits, starts or ends.
  • Event wake. A child's terminal (run.py, and the reap in terminal.py), a wait ending while another lane waits, and a 5 s sampler armed only while a wait exists each run one fit pass: ONE off-loop host reading, each bar rebuilt as the gate builds it (so a settled row is seen at the next tick), and only the waits that fit and the share does not hold are brought forward. A durable row goes through the new TaskStore.expedite in taskq/store.py (no event); an in-memory one has its _floor_waits park cut on the monotonic_ns clock. A wait that still does not fit is left parked, with nothing written. The admit wait stays as the backstop.
  • Per-lane memory share (lane_share_holds, in gate.py). While another lane waits below its share, a root start of a lane at or above its share of running dedicated children waits too: low_memory with no figures, audited with cause lane_share. Shares follow agent.lane_weights; the starved lane is never held, so it cannot deadlock; nested starts and claim re-entries are exempt. Not a count cap.
  • Shared nested child at ~0 (D4). A nested start whose runtime is shared counts 0 for itself against the floor; its row keeps the shared price, so the floor gives way by one start, not a fan-out.
  • subagent.py holds the record's state and _holds_dedicated_runtime; shutdown (cancellation.py) cancels the sampler and any fit pass.

Specs: subagent.md, adaptive-concurrency.md, taskq.md, dynamic-subagent-sizing.md, subagents.md, configuration.md, RFC Q12; help text for three keys in config/sections.py, with config-baseline.json regenerated.

Judgement calls

  1. Rebased onto main after U4 merged; one commit. It follows main's _floor_waits in nanoseconds (fix(subagent): end a floor wait on the park that reaches the bound #17106) and TaskStore.defer(wait=) (fix(taskq): take a memory park's span from one clock read #17217).
  2. The admit-wait backstop still writes one deferred event per admit wait: U5a's max wait sums them, so dropping them needs a schema change. The gate audits each deferral, as main does.
  3. The share counts running dedicated children only; a "+1" let a lane at its share beat a starved one.
  4. D4 means "priced at 0 against the floor", so the host may end one shared price below it; the spec says so.
  5. The share does not ask whether the starved start fits now, and held time counts toward the max wait. RFC Q12 records why: each alternative starves a dedicated start or leaves a held one unbounded.
  6. Removed after review: the reaper settle wake (the sampler sees a settle within a tick) and the per-cause audit dedup (outside the Goal).

Backwards compatibility

Compatible: no config key, schema field or API changes. agent.lane_weights keeps its meaning for picks, and now also weights the memory share. TaskStore.expedite is new and writes no event. The deferred_low_memory SEL row keeps its fields. A lane-share row leaves out available_gb, the same way a reading that did not answer already does.

Tests

test/test_subagent_memory_wake.py drives the real SubagentManager pump and task store on a virtual clock; only _run_inner is stubbed. A sampler test fires its tick itself. Every barrier is a signal (store flushes, depth-emit tasks, the fit and pump tasks, a per-start event), never a timed sleep.

  • F4: a wave does not take the next admission while another lane waits; a lane at its share does not take a starved lane's start; a lane below its share, a nested start and a claim re-entry are not held.
  • One event starts a waiting spawn: a child terminal, a reap, another lane's wait ending, a sampler tick (armed only while a start waits), a row that settled. A stale wait is pruned.
  • D4: a shared nested child is admitted while its parent waits; a dedicated one still waits.
  • Max wait: a share-held start ends in one terminal at depth 0. A wake cuts an in-memory park in _floor_waits' nanosecond unit (this fails with a float-seconds cut).
  • Live reload: a lane_weights change moves the share.
  • Writes: 100 wakes while still short add no deferred event, no depth frame and no audit row. A share hold is audited with cause lane_share and no figures.
  • test/test_taskq_store.py: expedite ends a deferral early with no event, and a row parked again is charged only the gap.

Each fails with the line it pins removed. Determinism: 10 runs at -n 4 and one shuffled run, all green.

Local runs: the lint, type, comment-history and Fast Gate scripts and docs-lint pass; 4771 tests (subagent, taskq, adaptive, config clusters) pass, and test_subagent_memory_wake.py passes 3 times at -n 4.

Manual verification

N/A: scheduling paths inside the manager, driven by the tests above.

Related Issues

Part of #16480. Implements U5 (b) of its subagent admission redesign; it builds on U4 (#17017) and U5a (#16347), both merged.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 5, 2026
@github-actions

github-actions Bot commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Advisory — does not block merge.

@github-actions

github-actions Bot commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: PASS

Check one case before merge: if the waiting lane's start can never fit, lane_share_holds limits every other lane to one dedicated child until the max wait ends that start.

[DESIGN-REVIEWED] 680a2e3

Description read

[DESCRIPTION-READ] 243df252b968a584151981fa1591184eccaebdb55975fedf8b349e6404124170

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ human override accepted

@bolichen97 overrode this lane for 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43 via /ai-review override (this commit only).

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 5, 2026
@github-actions

github-actions Bot commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 680a2e3

Verdict parsed from the review's SHA-scoped output markers for commit 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 5, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 680a2e3

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43: <one-sentence reason>

@jeeshofone

Copy link
Copy Markdown
Contributor

Heads-up on an overlap: #17106 (fixing #17104) changes the unit of SubagentManager._floor_waits from float time.monotonic() seconds to integer time.monotonic_ns() nanoseconds, because a park summed in float seconds can fall an ulp short of a whole-number bound. _release_memory_waits here writes min(park[2], now) with now = _time.monotonic(), so whichever of the two lands second needs that cut in nanoseconds (time.monotonic_ns()). Happy to rebase #17106 onto this one if it merges first.

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 5, 2026
@bolichen97
bolichen97 force-pushed the feat/subagent-memory-wake-lane-share branch from 98ac6ea to 034a4ae Compare October 7, 2026 09:42
@bolichen97
bolichen97 marked this pull request as ready for review October 7, 2026 09:43
@bolichen97
bolichen97 requested a review from a team as a code owner October 7, 2026 09:43
@bolichen97
bolichen97 requested a review from buluoray October 7, 2026 09:43
@github-actions github-actions Bot removed the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 7, 2026
@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Replace fixed sleeps used as completion barriers span=cb44d10cceac — fixed

Every timed pause in the harness is gone. settle() now awaits overload_fakes.settle_store_writes (the store's single writer thread) and settle_depth_emits (the emit tasks themselves); quiesce() awaits the fit and pump tasks with asyncio.wait; until_started() waits on a per-start asyncio.Event set by the stubbed _run_inner, with the deadline only as a lost-run guard; the sampler tests fire the armed tick directly (_Host.tick) instead of a 0.05 s real timer.
Proof: 10 runs at -n 4 and one shuffled-order run, all green; the terminal-wake tests still fail with the wake removed.
Lands with the next push (local 60073fdbbd); this round's one push was the rebase.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • The share can end work that would have fit span=78eae8a17bb1 — rebutted

Both clearing options were weighed and rejected; the trade-off is recorded as RFC Q12 (next push) and in subagent.md.
Lifting the hold when the starved start cannot fit now is work-conserving, and that is the starvation the share exists to stop: small shared starts (2.65 GiB) take memory as it frees, and a dedicated start (3.0 GiB) in the other chat never reaches its bar.
Not counting share-held time leaves a held start with no bound: the starved lane can keep queueing starts that never fit, and the max wait is the only terminal a held start has.
The hold lasts only while the other lane waits below its share; a start it admits, or its own max wait, releases it, and the end is the same delivered terminal at depth 0 (test_a_start_the_share_holds_expires_with_one_terminal_at_depth_zero).

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Backwards compatibility not checked span=cff6546c1c27 — fixed

The description is rewritten to about 7.6 KB, under the 8000-byte cap, with Backwards compatibility well before the cut-off: Compatible, no config key, schema field or API change; lane_weights keeps its meaning for picks; TaskStore.expedite is new and writes no event; the deferred_low_memory row keeps its fields.

@bolichen97

bolichen97 commented Oct 7, 2026 •

Copy link
Copy Markdown
Contributor Author
  • Audit deduplication is outside the Goal span=2f4dc98faa7a — fixed

Removed as the subtraction named: MemoryWait.held_by_share is gone, memory_wait_began returns nothing, and the gate writes the WARNING and the deferred_low_memory SEL row on every deferral, as main does. The only audit change left is the new cause, lane_share, with no figures (test_a_share_hold_is_audited_with_its_cause_and_no_figures).
Pinned in 260271a by test_every_gate_deferral_is_audited_while_the_wait_lasts: one deferral at the floor, then three admit-wait re-checks still short, gives 4 WARNINGs and 4 deferred_low_memory rows. Run against 034a4ae's src it fails with 1 == 4.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • The shared-nested floor exception rests on an unrecorded D4 span=01bde68daa34 — fixed

D4 comes from the #16480 redesign's critique (memory deadlock: a parent that yielded still holds its RSS, so a nested child that shares its runtime must be admissible down to the floor less its shared price, or the max wait is the only way out).
The next push records it as RFC Q12 in rfc-overload-resilience.md, with Q9's guarantee restated: admission never takes the host below the floor, except by one shared nested start's price; and subagent.md cites Q12. If the lane still wants the record on main first, a maintainer override is the remaining path.

@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased onto main after #17017 merged: the U4 commit is dropped and this PR is one commit (034a4ae), marked ready.

The rebase also follows two changes main made under it: _floor_waits is integer nanoseconds now (#17106), so the wake's in-memory park cut uses monotonic_ns (thanks @jeeshofone for the heads-up), and TaskStore.defer takes wait= (#17217). The reaper-sweep settle wake was removed, as First Principles suggested on the earlier head: the sampler sees a settle within one tick.

Red on 034a4ae: Comment History Gate (three "no longer" phrasings), plus Await Fast Gate and Coverage Gate, which fail because of it. GPT's fixed-sleep finding and the two First Principles items are fixed in the next push, which is already committed locally as 60073fdbbd and not pushed yet (one push per round). The dispositions above record each one.

@bolichen97
bolichen97 force-pushed the feat/subagent-memory-wake-lane-share branch from 034a4ae to 9c9160c Compare October 7, 2026 11:56
@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Blocker: product-shape change without accepted RFC: D4 floor exception span=f80161a04dc5 — rebutted

The only missing piece this item names is that Q12 lands in the same PR as the code. Q12 is the owner-directed decision for #16480 symptom b (one chat's wave taking every memory admission), and D4 is from that redesign's critique: a parent that yielded still holds its RSS, so a nested child sharing its runtime must be admissible or the 30-minute max wait is the only way out.
AGENTS.md requires the spec change in the SAME commit as the code it covers, so splitting Q12 into a docs-only PR first would ship a decision with no implementation and then the code against it. Q9 is restated in Q12, not silently reversed: admission never takes the host below the floor, except by one shared nested start's price, and subagent.md says so.
Requested path: a maintainer override for this head, as the item itself offers.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 4: the lane share is decided only by in-diff Q12 span=982933663d13 — rebutted

Same root as the blocker: the item does not dispute the share, only that its RFC record (Q12, extending §6 Fairness from picks to memory) is in this diff. §6 already promises a big batch "cannot starve a 3-task session"; with U4's count caps gone that promise held for picks but not for memory, which is #16480 symptom b, and the owner directed this fix.
The share is not a count cap: the starved lane is never held (no deadlock), nested starts and claim re-entries are exempt, and lane_weights help text in this diff says it now weights the memory share too.
Requested path: a maintainer override for this head.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 5: D4 admits a start memory does not allow span=cfe9e600494a — rebutted

A nested child that shares its parent's runtime starts no new kiro-cli process: its parent's runtime is already resident, so what memory must allow for it is close to nothing. D4 prices that start at 0 for itself against the floor, which is its real cost, while its row keeps the shared price so the next start still sees it. The floor therefore gives way by at most one shared start, never a fan-out, and a dedicated nested child still waits (test_a_dedicated_nested_child_still_waits_at_the_floor).
Without it the parent, which is often waiting on exactly that child, holds the memory the child is refused, and only the max-wait terminal ends the pair. RFC Q12 records this and restates Q9; removing it reintroduces that deadlock. The remaining objection is that Q12 is in-diff, covered by the override request.

@bolichen97
bolichen97 force-pushed the feat/subagent-memory-wake-lane-share branch from 9c9160c to 260271a Compare October 7, 2026 13:11
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Oct 7, 2026
@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 3: the memory share rests on in-diff Q12 span=ab759bb425e4 — rebutted

The item does not dispute the share. It objects only that its RFC record (Q12, which extends section 6 Fairness from picks to memory) is part of this diff. Section 6 already promises that a big batch "cannot starve a 3-task session". With U4's count caps gone, that promise held for picks but not for memory. That gap is #16480 symptom b, and the owner directed this fix.
AGENTS.md requires the spec change in the SAME commit as the code it covers. A docs-only PR first would ship a decision with no implementation behind it.
The share is not a count cap. The starved lane is never held, so there is no deadlock. Nested starts and claim re-entries are exempt. A held start is still bounded by its max wait, with one delivered terminal at depth 0 (test_a_start_the_share_holds_expires_with_one_terminal_at_depth_zero).

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 5: D4 rewrites Q9 through in-diff Q12 span=b3e019d95ab7 — rebutted

A nested child that shares its parent's runtime starts no new kiro-cli process: the parent's runtime is already resident. D4 charges that start 0 for itself against the floor, which is its real cost. Its row keeps the shared price, so the next start still sees it. The floor therefore gives way by at most one shared start, never by a fan-out, and a dedicated nested child still waits (test_a_dedicated_nested_child_still_waits_at_the_floor).
Without D4, a parent waiting on exactly that child holds the memory the child is refused, and only the 30-minute max-wait terminal ends the pair. D4 comes from the critique of the owner-directed #16480 redesign. Q12 restates Q9 instead of reversing it silently, and subagent.md says so. The remaining objection is only that Q12 is part of this diff.

With count caps gone, memory is the pool every chat's subagents share.
A start the floor deferred was re-checked only when its 30 s admit wait
passed, and one chat's wave could still take every start that fit while
another chat waited for memory.

- A memory wait is recorded from its first deferral until it fits,
  starts or ends. A child's terminal (run end or reap), a wait ending
  and a sampler tick each run one fit pass: one off-loop host reading,
  the bar rebuilt as the gate builds it (so a warming row that settled
  is seen at the next tick), and only the waits that now fit are
  brought forward (a durable row through TaskStore.expedite, no event;
  an in-memory park cut on the floor's monotonic_ns clock). A wait that
  still does not fit is left parked with nothing written. The sampler
  runs only while a wait exists; the admit wait stays as the
  restart-safe backstop.
- Per-lane memory share: while another lane waits below its share, a
  root start of a lane at or above its share of running dedicated
  children waits too (low_memory, no figures; audited with cause
  lane_share). The share follows agent.lane_weights; the starved lane
  is never held, so it cannot deadlock. Nested starts and claim
  re-entries are exempt. No count cap; WRR ordering stays.
- A nested child that shares its parent's runtime is admitted at ~0
  against the floor while its row keeps the shared price, so the floor
  gives way by one shared start, not a fan-out.

The 2 GiB floor, the macOS pressure hold, the explicit-pin floor of 3
and the 1800 s max wait are unchanged.

Specs: subagent.md (Memory waits: event wake and the per-lane share,
the floor guarantee), adaptive-concurrency.md, taskq.md,
dynamic-subagent-sizing.md, subagents.md, configuration.md;
rfc-overload-resilience.md Q12 records the event wake, the share and
the shared nested child (D4).

Part of #16480
@bolichen97
bolichen97 force-pushed the feat/subagent-memory-wake-lane-share branch from 260271a to 680a2e3 Compare October 7, 2026 13:26
@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 9: memory_sampler_active has zero consumers span=b2ac38e030ae — fixed

Removed in 680a2e3 as the subtraction named. The method is gone from memory_wake.py, the test harness reads _memory_sampler_handle and _memory_sample_task itself (_Host.sampler_active), and subagent.md now cites _arm_memory_sampler and _disarm_memory_sampler for the arm/cancel rule. No src caller existed: grep finds none. The sampler tests still pin "runs only while a start waits".

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Blocker: product-shape change without accepted RFC: the D4 floor exception span=6382dc104838 — rebutted

The only thing this blocker says is missing is that Q12 lands in the same PR as the code. Q12 is the owner-directed decision for #16480 symptom b. D4 comes from that redesign's critique: a parent that yielded still holds its RSS, so a nested child sharing its runtime must be admissible, or the 30-minute max wait is the only way out of the parent-child pair.
AGENTS.md requires the spec change in the SAME commit as the code it covers. A docs-only PR first would ship a decision with no implementation behind it.
Q12 restates Q9 in the open instead of reversing it silently. The floor gives way by at most one shared start's price, never by a fan-out, and a dedicated nested child still waits (test_a_dedicated_nested_child_still_waits_at_the_floor).
Requested path: a maintainer override for this head, as the item offers.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 4: the memory share has no base RFC record span=81820a9c7c87 — rebutted

Same root as the blocker. The item does not dispute the share, only that its record (Q12, extending section 6 Fairness from picks to memory) is part of this diff. Section 6 already promises that a big batch "cannot starve a 3-task session". With U4's count caps gone, that promise held for picks but not for memory. That gap is #16480 symptom b, and the owner directed this fix.
The share is not a count cap. The starved lane is never held, so there is no deadlock. Nested starts and claim re-entries are exempt. A held start still ends at its max wait, with one delivered terminal at depth 0 (test_a_start_the_share_holds_expires_with_one_terminal_at_depth_zero).
Requested path: a maintainer override for this head.

@bolichen97

Copy link
Copy Markdown
Contributor Author
  • Item 5: a shared nested child can take the host below the floor span=5197a52793b7 — rebutted

A nested child that shares its parent's runtime starts no new kiro-cli process: the parent's runtime is already resident. D4 charges that start 0 for itself against the floor, which is its real cost. Its row keeps the shared price, so the next start still sees it. The floor therefore gives way by one shared start at most (test_it_is_admitted_while_its_parent_waits charges the sibling for it).
Without D4, a parent waiting on exactly that child holds the memory the child is refused, and only the max-wait terminal ends the pair. RFC Q12 records this and restates Q9. The remaining objection is only that Q12 is part of this diff, which the override request covers.

@bolichen97

Copy link
Copy Markdown
Contributor Author

/ai-review override first-principles 680a2e3: Maintainer decision. RFC Q12 records the owner-directed fix for #16480 symptom b, where one chat's wave takes every memory admission. D4 comes from that redesign's critique: a yielded parent keeps its RSS, so a nested child sharing its runtime must be admissible. AGENTS.md requires the spec in the same commit as the code. Q12 restates Q9 openly: the floor yields by at most one shared start, and a dedicated child still waits.

@github-actions

github-actions Bot commented Oct 7, 2026

Copy link
Copy Markdown
Contributor

Human judgment recorded

@bolichen97 marked the first-principles AI finding as false positive, not applicable, or explicitly accepted for 680a2e375f0033420e9ff0af9a1d3cf7f6bb9c43.

Maintainer decision. RFC Q12 records the owner-directed fix for #16480 symptom b, where one chat's wave takes every memory admission. D4 comes from that redesign's critique: a yielded parent keeps its RSS, so a nested child sharing its runtime must be admissible. AGENTS.md requires the spec in the same commit as the code. Q12 restates Q9 openly: the floor yields by at most one shared start, and a dedicated child still waits.

This decision applies only to this commit. A new push requires a new judgment.

@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Oct 7, 2026
@bolichen97
bolichen97 enabled auto-merge (squash) October 7, 2026 20:18
@bolichen97
bolichen97 merged commit c65697e into main Oct 7, 2026
155 of 158 checks passed
@bolichen97
bolichen97 deleted the feat/subagent-memory-wake-lane-share branch October 7, 2026 20:20
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Oct 7, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants