Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
feat(agentic-ide): route a fleet brief to the panes it names
rubenluetke10-beep4cc140dcbecc
diff --git a/jarvis/agentic_ide/intent.py b/jarvis/agentic_ide/intent.pyindex 60a1e0d561..789e86ec49 100644--- a/jarvis/agentic_ide/intent.py+++ b/jarvis/agentic_ide/intent.py@@ -2258,8 +2258,14 @@ def spawn_includes_task(user_text: str) -> bool:_TASK_AFTER_BRIEF_RE = re.compile(r"\b(?:prompt\w*|brief\w*|instruct\w*|assign\w*|tell\w*|"r"anweis\w*|beauftrag\w*)\b\s*"- r"(?:,?\s*(?:dass|damit|that|to|que)\s*)?"- r"(?:(?:sie|er|es|they|it|each(?:\s+one)?|cada\s+uno)\s+)?",+ r"(?:,?\s*(?:dass|damit|that|to|que)\s*)?" # i18n-allow: input vocab+ # The pronoun standing for the fleet. "them" was missing, so "prompt+ # them, one fixes …" handed fresh agents a task that OPENED with the+ # word "them," — a fragment of the address baked into their work.+ r"(?:(?:sie|er|es|they|it|them(?:\s+all)?|those|" # i18n-allow: input vocab+ r"each(?:\s+one|\s+of\s+them)?|all(?:\s+of\s+them)?|everyone|"+ r"beiden?|allen?|cada\s+uno|todos|todas|ellos|ellas)" # i18n-allow: input vocab+ r"[\s,:]+)?",re.IGNORECASE,)@@ -2317,6 +2323,154 @@ def spawn_instruction(user_text: str) -> str:return remainder or text+# --------------------------------------------------------------------------- #+# "prompt the five Claudes to X, the two Codexes to Y, the OpenCode to Z" #+# --------------------------------------------------------------------------- #+# A mixed fleet is regularly briefed BY KIND in the same breath that asks for+# it — the counts and the product names are how the user tells the groups+# apart, so they are also how the work is handed out. ``spawn_instruction``+# cannot represent that: it returns ONE string, so every pane of an 8-pane+# fleet received the entire enumeration ("the five claudes to fix the login+# bug, prompt the two codexes to write tests …") as its own task, and each+# agent then picked whatever slice it liked (maintainer report 2026-08-12).+#+# Deterministic on purpose, like the fleet parse above: the user has already+# SAID which group gets which work, so there is nothing for a model to decide —+# routing it is string work, and string work must not cost a provider call.++#: The verbs that hand a GROUP its work. Broader than ``_BRIEFING_VERB_RE`` —+#: "tell"/"sag" and "ask"/"frag" are unambiguous here because this vocabulary+#: is only ever consulted in the remainder BEHIND a fleet request, where a+#: status-question reading does not exist.+_GROUP_BRIEF_VERB_RE = re.compile(+ r"\b(?:prompt\w*|anprompt\w*|instruct\w*|instruy\w*|anweis\w*|" # i18n-allow: input vocab+ r"beauftrag\w*|brief\w*|assign\w*|encarga\w*|tell\w*|sag\w*|" # i18n-allow: input vocab+ r"dile|d[ií]gale|frag\w*|ask\w*|pregunt\w*)\b", # i18n-allow: input vocab+ re.IGNORECASE,+)++#: The modal directly behind a kind's name — the verbless way German (and+#: English) hands a group its work: "die Claudes SOLLEN die Tests fixen".+#: Commas are excluded from the gap so a name that merely opens a list cannot+#: borrow a modal from the next clause.+_GROUP_BRIEF_MODAL_RE = re.compile(+ r"[^.!?;,]{0,12}?\b(?:soll(?:en|te|ten)?|should|shall|must|" # i18n-allow: input vocab+ r"m[uü]ss(?:en|t)?|deben?|deber[ií]an?)\b", # i18n-allow: input vocab+ re.IGNORECASE,+)++#: What may stand between a briefing verb's addressee and its work: an optional+#: subordinator ("to" / "dass") and the pronoun re-stating the group. Part of+#: the ADDRESS, never of the task.+_GROUP_BRIEF_CONNECTIVE_RE = re.compile(+ r"\s*[,:]?\s*(?:(?:to|that|dass|damit|que)\b\s*)?" # i18n-allow: input vocab+ r"(?:(?:sie|er|es|they|it|them)\b\s*)?", # i18n-allow: input vocab+ re.IGNORECASE,+)++#: Trailing debris once the next group's clause is cut away: the conjunction+#: and the article that belonged to the NEXT addressee ("… fixen und der ").+_GROUP_TASK_TRIM_RE = re.compile(+ r"[\s,;.]*(?:\b(?:und|and|y|sowie|plus)\b)?" # i18n-allow: input vocab+ r"[\s,;.]*(?:\b(?:the|die|der|das|den|dem|el|la|los|las)\b)?" # i18n-allow: input vocab+ r"[\s,;.]*$",+ re.IGNORECASE,+)++#: Words allowed in front of the FIRST group brief without disqualifying the+#: per-group reading. Anything more substantial before it is a brief of its own+#: ("prompt each of them to do X and tell the codex …"), and the per-group map+#: would then silently withhold X from every pane the group clauses do not+#: name — so the whole map stands down instead.+_GROUP_BRIEF_LEAD_RE = re.compile(+ r"[\s.,:;!?—–-]*(?:\b(?:und|and|y|dann|then|also|bitte|" # i18n-allow: input vocab+ r"please|jetzt|now|"+ r"the|die|der|das|den|los|las|el|la)\b[\s,]*)*", # i18n-allow: input vocab+ re.IGNORECASE,+)++#: A group's task shorter than this is a fragment, not work ("do it" survives,+#: a stray article does not). Deliberately below ``_MIN_INSTRUCTION_CHARS``:+#: here there is no better fallback to prefer, and "write tests" is an order.+_MIN_GROUP_TASK_CHARS = 6+++def _group_brief_anchors(text: str) -> list[tuple[int, int, str]]:+ """Every per-kind brief in ``text`` as ``(cut_start, task_start, cli)``.++ ``cut_start`` is where the PREVIOUS group's task ends (the verb for+ verb-anchored briefs, the name for modal-anchored ones); ``task_start`` is+ where this group's own task begins.++ A verb may govern only the FIRST name after it: in "prompt the claudes to+ fix codex bugs" the word "codex" stands inside the claudes' task, and the+ guard that keeps it there is the previous mention's position — a verb in+ front of an earlier addressee is spent.+ """+ out: list[tuple[int, int, str]] = []+ previous_end = -1+ for match in _AGENT_RE.finditer(text):+ agent = _canonical_agent(match.group("agent"))+ if agent is None:+ continue+ verb: re.Match[str] | None = None+ for candidate in _GROUP_BRIEF_VERB_RE.finditer(text, 0, match.start()):+ if candidate.start() <= previous_end:+ continue+ between = text[candidate.end() : match.start()]+ if len(between) <= _COUNT_AGENT_MAX_GAP and not re.search(r"[.!?;:]", between):+ verb = candidate+ previous_end = match.end()+ if verb is not None:+ lead = _GROUP_BRIEF_CONNECTIVE_RE.match(text, match.end())+ out.append((verb.start(), lead.end() if lead else match.end(), agent))+ continue+ modal = _GROUP_BRIEF_MODAL_RE.match(text, match.end())+ if modal is not None:+ out.append((match.start(), modal.end(), agent))+ return out+++def spawn_group_tasks(user_text: str) -> dict[str, str]:+ """Each spawned kind's OWN task, or ``{}`` when the brief is shared.++ Reads the same remainder ``spawn_instruction`` reads — everything behind+ the last fleet clause — and splits it at the briefs that name a CLI. The+ caller maps each kind to the panes it just opened of that kind; a kind the+ brief does not name gets NO task, because "open two claudes and a codex,+ prompt the claudes to fix the tests" deliberately leaves the codex blank.++ ``{}`` — the shared-brief reading — whenever the remainder briefs nobody by+ kind, or carries work in front of the first kind-brief (that work belongs+ to everyone, and a partial map would silently withhold it).+ """+ text = _spoken_correction_suffix((user_text or "").strip())+ if len(text) < 6:+ return {}+ regions = _spawn_regions(text)+ if not regions:+ return {}+ last = regions[-1]+ remainder = text[last.start + len(last.parse_text) :]+ if not remainder.strip():+ return {}+ anchors = _group_brief_anchors(remainder)+ if not anchors:+ return {}+ lead = _GROUP_BRIEF_LEAD_RE.match(remainder)+ if lead is None or lead.end() < anchors[0][0]:+ return {}+ out: dict[str, str] = {}+ for index, (_cut, task_start, agent) in enumerate(anchors):+ stop = anchors[index + 1][0] if index + 1 < len(anchors) else len(remainder)+ task = remainder[task_start:stop].strip(" \t,:;-")+ task = " ".join(_GROUP_TASK_TRIM_RE.sub("", task).split())+ if len(task) < _MIN_GROUP_TASK_CHARS:+ continue+ out[agent] = f"{out[agent]}; {task}" if agent in out else task+ return out++_RECENT_FLEET_RE = re.compile(r"\b(?:jede[nr]?\s+(?:davon|dieser)|alle\s+davon|diese\w*|"r"each\s+(?:one|of\s+them)|all\s+of\s+them|those\s+(?:agents|terminals)|"@@ -2804,6 +2958,95 @@ def wants_split(user_text: str) -> bool:return bool(_DIVIDE_RECIPIENT_RE.search(text) or _DIVIDE_AREA_RE.search(text))+# --------------------------------------------------------------------------- #+# "one fixes the macOS bug, one fixes the Linux bug" #+# --------------------------------------------------------------------------- #+# The user enumerating the division THEMSELVES. ``wants_split`` catches the+# request to divide ("teilt es unter euch auf"); this catches a division+# already made. Both must end in the same place — the split planner — because+# the panes need DIFFERENT briefs either way: delivering the whole enumeration+# to every pane is how two fresh agents both fixed the macOS bug while the+# Linux bug sat unclaimed (maintainer report 2026-08-12).+#+# The trap: "one"/"einer" is among the most ordinary words there are, and the+# fleet description itself counts panes with it ("one Codex"). Two conditions+# keep it honest — and the callers only ever pass the TASK text (the remainder+# behind every fleet clause), never the raw utterance:+#+# 1. the enumerator must OPEN its clause: start of text, or directly behind+# a comma/semicolon/colon or a coordination ("and"/"und"/"y"). "bug one"+# and "Terminal eins" never stand there;+# 2. it must carry its own predicate inside its clause — an instruction verb,+# a modal, or the elided-verb complement ("und einer auf Linux", where the+# preposition does the pointing). "The other"/"der andere" is exempt from+# the predicate: that word pair has no counting reading at all, so it is+# distributive on its own ("one takes the backend, the other the+# frontend").+#+# Two qualifying enumerators are the evidence; one is an ordinary sentence.++_DISTRIBUTIVE_PREFIX = r"(?:^|[,;:]|\b(?:und|and|y)\b)\s*" # i18n-allow: input vocab++_DISTRIBUTIVE_ONE_RE = re.compile(+ _DISTRIBUTIVE_PREFIX+ + r"(?:ein(?:e[rs]?|s)?|one(?:\s+of\s+(?:them|you))?|un[oa]|" # i18n-allow: input vocab+ r"(?:(?:der|die|das|the|el|la)\s+)?" # i18n-allow: input vocab+ r"(?:erste[rs]?|zweite[rs]?|dritte[rs]?|vierte[rs]?|" # i18n-allow: input vocab+ r"first|second|third|fourth|"+ r"primer[oa]?|segund[oa]?|tercer[oa]?))\b",+ re.IGNORECASE,+)++_DISTRIBUTIVE_OTHER_RE = re.compile(+ _DISTRIBUTIVE_PREFIX+ + r"(?:(?:der|die|das)\s+andere[nrs]?|the\s+other(?:\s+one)?|" # i18n-allow: input vocab+ r"(?:el\s+|la\s+)?otr[oa])\b",+ re.IGNORECASE,+)++#: What counts as an enumerator's own predicate when it is not a full+#: instruction verb: a modal handing the slice over, or the preposition of an+#: elided-verb complement.+_DISTRIBUTIVE_PREDICATE_RE = re.compile(+ r"\b(?:soll\w*|m[uü]ss\w*|kann|k[oö]nn\w*|darf\w*|" # i18n-allow: input vocab+ r"should|shall|must|can|could|will|would|takes?|gets?|does|"+ r"deber?[ií]?an?|pueden?|podr[ií]an?|"+ r"auf|f[uü]r|on|for|en|an|mit|with|con)\b", # i18n-allow: input vocab+ re.IGNORECASE,+)++#: How far an enumerator's predicate may sit behind it, within its clause.+_DISTRIBUTIVE_PREDICATE_REACH = 60+++def _distributive_clause(text: str, start: int) -> str:+ window = text[start : start + _DISTRIBUTIVE_PREDICATE_REACH]+ return re.split(r"[.!?;]", window, maxsplit=1)[0]+++def distributes_tasks(task_text: str) -> bool:+ """True when the task hands each pane a DIFFERENT job by enumeration.++ Consulted on the extracted TASK text of a fleet brief (never the raw+ utterance — the fleet description counts panes with the same words). A+ True here routes the brief through the split planner, exactly like+ ``wants_split``, so every pane receives its own slice instead of the whole+ enumeration.+ """+ text = (task_text or "").strip()+ if len(text) < 12:+ return False+ heads = 0+ for match in _DISTRIBUTIVE_ONE_RE.finditer(text):+ clause = _distributive_clause(text, match.end())+ if _INSTRUCTION_VERB_RE.search(clause) or _DISTRIBUTIVE_PREDICATE_RE.search(clause):+ heads += 1+ if heads >= 2:+ return True+ heads += sum(1 for _ in _DISTRIBUTIVE_OTHER_RE.finditer(text))+ return heads >= 2++#: "both of you", "you two", "all three of them", "die zwei Terminals". What#: these have in common is a COUNT the utterance states out loud, which is the#: only evidence that survives a call-sign speech recognition mangled beyond@@ -2958,10 +3201,12 @@ __all__ = ["detect_visible","detect_close_fleet","detect_spawn",+ "distributes_tasks","expects_several","owns_turn","references_recent_fleet","reports_undelivered",+ "spawn_group_tasks","spawn_includes_task","spawn_instruction","spawn_vehicle_outranks_workspace",diff --git a/tests/unit/agentic_ide/test_spawn_intent.py b/tests/unit/agentic_ide/test_spawn_intent.pyindex 030be954ed..f928804025 100644--- a/tests/unit/agentic_ide/test_spawn_intent.py+++ b/tests/unit/agentic_ide/test_spawn_intent.py@@ -807,3 +807,140 @@ def test_counts_inside_a_briefed_task_never_become_more_panes() -> None:assert found is not Noneassert found.count == 2, "the tabs belong to the task, not the workspace"assert intent.spawn_includes_task(utterance) is True+++# --------------------------------------------------------------------------- #+# Per-kind briefs: "prompt the five Claudes to X, the two Codexes to Y" #+# --------------------------------------------------------------------------- #+# The maintainer's ask on 2026-08-12: a mixed fleet briefed by kind in the same+# sentence must route each kind ITS task. The old single-string extraction gave+# every pane the entire enumeration, and each agent then picked whatever slice+# it liked — three groups, one mashed brief, no routing.+++def test_each_kind_gets_its_own_task() -> None:+ utterance = (+ "Open five claudes, two codexes and one opencode. Prompt the five "+ "claudes to fix the login bug, prompt the two codexes to write tests "+ "and prompt the opencode to update the docs"+ )++ assert intent.spawn_group_tasks(utterance) == {+ "claude": "fix the login bug",+ "codex": "write tests",+ "opencode": "update the docs",+ }+++def test_german_modal_briefs_route_by_kind() -> None:+ """"Die Claudes sollen …" hands the group its work without a verb in front."""+ utterance = (+ "Öffne zwei Claude Terminals und einen Codex. Die Claudes sollen die "+ "Tests fixen und der Codex soll die Docs aktualisieren."+ ) # i18n-allow: spoken input under test++ assert intent.spawn_group_tasks(utterance) == {+ "claude": "die Tests fixen", # i18n-allow: quoted spoken input+ "codex": "die Docs aktualisieren", # i18n-allow: quoted spoken input+ }+++def test_a_kind_the_brief_does_not_name_stays_blank() -> None:+ """"prompt the claudes …" deliberately leaves the codex without a task."""+ utterance = (+ "Open two claudes and one codex. Prompt the claudes to fix the "+ "failing tests."+ )++ assert intent.spawn_group_tasks(utterance) == {+ "claude": "fix the failing tests"+ }+++def test_a_shared_brief_has_no_group_tasks() -> None:+ """"prompt each one to …" addresses everyone; the map must stand down."""+ utterance = (+ "Spawn two Codex terminals and prompt each one to perform a read-only "+ "platform compatibility review"+ )++ assert intent.spawn_group_tasks(utterance) == {}+++def test_work_in_front_of_the_first_kind_brief_disables_the_map() -> None:+ """A shared task followed by one kind's extra job must not orphan the rest.++ "Prompt each of them to do a deep dive and tell the codex to also update+ the docs" briefs EVERYONE first. A per-kind map would cover only the codex+ and silently withhold the deep dive from every other pane, so the whole+ map stands down and the shared path keeps the turn.+ """+ utterance = (+ "Open two terminals. Prompt each of them to do a deep dive and tell "+ "the codex to also update the docs"+ )++ assert intent.spawn_group_tasks(utterance) == {}+++def test_a_cli_named_inside_another_groups_task_is_not_an_addressee() -> None:+ """"prompt the claudes to fix codex bugs" briefs the claudes, not Codex."""+ utterance = (+ "Open two claude terminals. Prompt the claudes to fix the codex "+ "integration bugs."+ )++ assert intent.spawn_group_tasks(utterance) == {+ "claude": "fix the codex integration bugs"+ }+++# --------------------------------------------------------------------------- #+# Distributive briefs: "one fixes the macOS bug, one fixes the Linux bug" #+# --------------------------------------------------------------------------- #+# The user enumerating the division themselves. Without the detector, both+# fresh panes received the whole enumeration and raced on the first slice —+# two agents fixing macOS while Linux sat unclaimed (maintainer report+# 2026-08-12).+++ "task",+ [+ "one fixes a bug on macOS and one fixes a bug on Linux",+ "einer fixt den Bug auf macOS und einer auf Linux", # i18n-allow: spoken input under test+ "one should review the backend, the other the frontend",+ "the first fixes macOS, the second fixes Linux",+ ],+)+def test_an_enumerated_division_is_detected(task: str) -> None:+ assert intent.distributes_tasks(task) is True+++ "task",+ [+ # One shared job — the ordinary fleet brief.+ "perform a read-only platform compatibility review",+ "einen Deep Dive machen", # i18n-allow: spoken input under test+ # "one"/ordinals as ordinary objects of the work, not as panes.+ "fix bug one and bug two",+ "review the first file, the second file and the third one",+ "",+ ],+)+def test_ordinary_tasks_are_not_divisions(task: str) -> None:+ assert intent.distributes_tasks(task) is False+++def test_prompt_them_does_not_leak_the_pronoun_into_the_task() -> None:+ """"prompt them, one fixes …" starts the task at the work, not at "them"."""+ utterance = (+ "spawn two new terminals and prompt them, one fixes a bug on macOS "+ "and one fixes a bug on Linux"+ )++ instruction = intent.spawn_instruction(utterance)++ assert instruction == "one fixes a bug on macOS and one fixes a bug on Linux"+ assert intent.distributes_tasks(instruction) is Truediff --git a/tests/unit/brain/test_agentic_ide_spawn_fast_path.py b/tests/unit/brain/test_agentic_ide_spawn_fast_path.pyindex add2e3a1a1..8fec5e2cd6 100644--- a/tests/unit/brain/test_agentic_ide_spawn_fast_path.py+++ b/tests/unit/brain/test_agentic_ide_spawn_fast_path.py@@ -243,6 +243,140 @@ async def test_queued_fleet_receives_the_task_not_the_spawn_scaffolding(assert "Spawn two Codex terminals" not in str(captured["instruction"])+async def test_a_brief_by_kind_routes_each_kind_its_own_task(+ manager: tuple[BrainManager, FakeBus],+ registry: Registry,+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """"prompt the claudes to X and the codex to Y" must not mash X and Y.++ The maintainer's live failure (2026-08-12): every pane of a mixed fleet+ received the ENTIRE enumeration as its own task, and each agent picked+ whatever slice it liked.+ """+ from jarvis.agentic_ide import fanout, fleet_actions++ mgr, _bus = manager+ session = await registry.start(+ str(tmp_path), [{"agent": "claude"}, {"agent": "claude"}, {"agent": "codex"}]+ )+ names = [term.name for term in session.terminals]+ captured: dict[str, object] = {}++ async def _ready(_session: object, wanted: list[str]) -> tuple[str, ...]:+ return tuple(wanted)++ async def _deliver(**kwargs: object) -> object:+ captured.update(kwargs)+ return SimpleNamespace(delivered=(object(),) * 3)++ monkeypatch.setattr(fleet_actions, "wait_for_prompt_ready", _ready)+ monkeypatch.setattr(fanout, "deliver", _deliver)+ utterance = (+ "Open two claude terminals and one codex terminal. Prompt the claudes "+ "to fix the failing login tests and prompt the codex to update the "+ "developer docs."+ )++ await mgr._brief_spawned_agentic_ide_fleet(session, names, utterance)++ assert captured["terminals"] == tuple(names)+ assert captured["assignments"] == {+ names[0]: "fix the failing login tests",+ names[1]: "fix the failing login tests",+ names[2]: "update the developer docs",+ }+++async def test_a_kind_without_a_brief_is_not_briefed_at_all(+ manager: tuple[BrainManager, FakeBus],+ registry: Registry,+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """"prompt the claudes …" leaves the codex pane blank — as asked."""+ from jarvis.agentic_ide import fanout, fleet_actions++ mgr, _bus = manager+ session = await registry.start(+ str(tmp_path), [{"agent": "claude"}, {"agent": "codex"}]+ )+ names = [term.name for term in session.terminals]+ captured: dict[str, object] = {}++ async def _ready(_session: object, wanted: list[str]) -> tuple[str, ...]:+ return tuple(wanted)++ async def _deliver(**kwargs: object) -> object:+ captured.update(kwargs)+ return SimpleNamespace(delivered=(object(),))++ monkeypatch.setattr(fleet_actions, "wait_for_prompt_ready", _ready)+ monkeypatch.setattr(fanout, "deliver", _deliver)+ utterance = (+ "Open one claude terminal and one codex terminal. Prompt the claude "+ "to fix the failing login tests."+ )++ await mgr._brief_spawned_agentic_ide_fleet(session, names, utterance)++ assert captured["terminals"] == (names[0],)+ assert captured["assignments"] == {names[0]: "fix the failing login tests"}+++async def test_an_enumerated_division_reaches_the_split_planner(+ manager: tuple[BrainManager, FakeBus],+ registry: Registry,+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """"one fixes macOS, one fixes Linux" plans a split instead of one brief."""+ from jarvis.agentic_ide import fanout, fleet_actions, work_split++ mgr, _bus = manager+ session = await registry.start(+ str(tmp_path), [{"agent": "claude"}, {"agent": "claude"}]+ )+ names = [term.name for term in session.terminals]+ captured: dict[str, object] = {}+ planned: dict[str, object] = {}++ async def _ready(_session: object, wanted: list[str]) -> tuple[str, ...]:+ return tuple(wanted)++ async def _deliver(**kwargs: object) -> object:+ captured.update(kwargs)+ return SimpleNamespace(delivered=(object(),) * 2)++ async def _split(instruction: str, **kwargs: object) -> object:+ planned["instruction"] = instruction+ planned["count"] = kwargs.get("count")+ return work_split.WorkSplit(+ assignments=(+ work_split.Assignment(area="macOS", task="fix the macOS bug"),+ work_split.Assignment(area="Linux", task="fix the Linux bug"),+ ),+ split_by="llm",+ )++ monkeypatch.setattr(fleet_actions, "wait_for_prompt_ready", _ready)+ monkeypatch.setattr(fanout, "deliver", _deliver)+ monkeypatch.setattr(work_split, "split", _split)+ utterance = (+ "Spawn two new terminals and prompt them, one fixes a bug on macOS "+ "and one fixes a bug on Linux"+ )++ await mgr._brief_spawned_agentic_ide_fleet(session, names, utterance)++ assert planned["count"] == 2+ assert captured["assignments"] == {+ names[0]: "fix the macOS bug",+ names[1]: "fix the Linux bug",+ }++async def test_without_a_named_agent_the_new_panes_inherit(manager: tuple[BrainManager, FakeBus], registry: Registry, tmp_path: Path) -> None: