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(voice): results of coding panes and Jarvis agents are shown, never spoken
rubenluetke10-beep2461972bae23
diff --git a/docs/agent-society/MASTERPLAN.md b/docs/agent-society/MASTERPLAN.mdindex 3226901cbe..121868a514 100644--- a/docs/agent-society/MASTERPLAN.md+++ b/docs/agent-society/MASTERPLAN.md@@ -32,7 +32,7 @@ carries the team card (roster + hands, byte-stable, current on the next turn aftwrite), the router's decision table has a DELEGATE way ahead of `spawn_worker`, the realtimesession gets a names directive and the turn planner a `SOCIETY` reason, `delegate_to_agent`picks the fitting agent when no name is given, and a lead-assigned result comes back as a-spoken completion plus a notice in the front-page chat (`agent-definition.md` §3.5). **M3+notice in the front-page chat, not spoken (2026-09-30; `agent-definition.md` §3.5). **M3world** is the maintainer's parallel track. Open in M4: rooms live under the scheduler, thecurator.diff --git a/docs/agent-society/agent-definition.md b/docs/agent-society/agent-definition.mdindex cda3d3e50a..6ff21e12c3 100644--- a/docs/agent-society/agent-definition.md+++ b/docs/agent-society/agent-definition.md@@ -313,8 +313,8 @@ Gmail agent stood on the island. The team card (`jarvis/society/lead_card.py`) iname the roster does not know, "email agent") the lead picks the agent whose focus fits thetask (`SocietyRuntime.pick_agent`, `derive_focus` over the task text) or says that nobodyfits. When a lead-assigned run ends, `SocietyRuntime.report_to_lead` posts a `notice` event- into the newest front-page chat session (rendered as a muted result line) and publishes an- `AnnouncementRequested(kind="completion")` the TTS pipeline and the realtime session speak.+ into the newest front-page chat session (rendered as a muted result line). It is not+ spoken: since 2026-09-30 no background result is read aloud, and no model call phrases one.- **Words.** The section is "Agents" (`nav.agents`); the Agentic IDE holds "coding terminals"in every prompt and directive; `navigate` maps "society", "team", "island", "my agents" tothe section and "terminals", "terminal grid" to the IDE.@@ -327,7 +327,8 @@ Gmail agent stood on the island. The team card (`jarvis/society/lead_card.py`) i- **User ↔ agent:** the canonical chat (card's right column), `society:<agent_id>` session onthe agent_chat store; the composer's `/` lists the agent's enabled skills, `@` the roster.- **Jarvis ↔ agent (voice):** the `delegate-to-agent` router tool (M4): ACK < 5 s, work goes- through the scheduler as `ASSIGN`, completion re-enters voice through `scrub_for_voice`.+ through the scheduler as `ASSIGN`, completion comes back as a notice in the front-page+ chat (not spoken, 2026-09-30).- **Agent ↔ agent:** exactly one tool, `message_agent(target, text, kind)` → one `SAY` /`QUERY` / `PROPOSE` envelope to ONE teammate; the scheduler wakes the target's chat.`@name` in a canonical chat by the USER also produces a `SAY` from the user's identity.diff --git a/jarvis/agentic_ide/fanout.py b/jarvis/agentic_ide/fanout.pyindex a258153c3b..89badc1720 100644--- a/jarvis/agentic_ide/fanout.py+++ b/jarvis/agentic_ide/fanout.py@@ -443,9 +443,7 @@ async def _default_send(name: str, text: str, **receipt: Any) -> Any:"""from .session import get_registry- # A job Jarvis handed over on the user's behalf: its end is reported by- # voice (see `voice_readback`).- return await get_registry().send_prompt(name, text, readback=True, **receipt)+ return await get_registry().send_prompt(name, text, **receipt)async def deliver(diff --git a/jarvis/agentic_ide/notifications.py b/jarvis/agentic_ide/notifications.pyindex 5629cb3ec2..33fd035dea 100644--- a/jarvis/agentic_ide/notifications.py+++ b/jarvis/agentic_ide/notifications.py@@ -95,7 +95,6 @@ from typing import TYPE_CHECKING, Any, Literal, NamedTuplefrom loguru import logger-from . import voice_readbackfrom .activity import (RESIZE_SHADOW_S,STILL_S,@@ -445,13 +444,6 @@ class ActivityWatcher:self.center = centerself._panes: dict[tuple[str, str], _PaneWatch] = {}self._resume_dirty = False- #: Jarvis-given jobs that just stopped: (kind, terminal), in order.- self._readbacks: list[tuple[Kind, Any]] = []-- def take_readbacks(self) -> list[tuple[Kind, Any]]:- """Return and clear the stops that owe the user a spoken readback."""- taken, self._readbacks = self._readbacks, []- return takendef take_resume_dirty(self) -> bool:"""Return and clear whether activity changed the resume checkpoint."""@@ -649,14 +641,6 @@ class ActivityWatcher:watch.announced = Truewatch.worked = False- if kind in ("completed", "needs_input") and getattr(term, "voice_readback", False):- # Jarvis handed this job over for the user, so the user hears how- # it ended — independent of the bell switch below. A question keeps- # the job open: the answer resumes the same job, and its end is- # still owed.- if kind == "completed":- term.voice_readback = False- self._readbacks.append((kind, term))if not emit:return Nonereturn self.center.add(@@ -991,7 +975,6 @@ def reset() -> None:_CENTER.clear()_WATCHER._panes.clear() # noqa: SLF001 - same module, one owner_WATCHER._resume_dirty = False # noqa: SLF001 - same module, one owner- _WATCHER._readbacks.clear() # noqa: SLF001 - same module, one owner_FEED.clear()set_publisher(None)reset_switch_cache()@@ -1025,10 +1008,6 @@ async def _run(registry: Registry) -> None:# with notifications disabled, restored panes must not be# offered a blind Continue merely because history exists._WATCHER.poll(registry, emit=await _enabled_off_loop())- for kind, term in _WATCHER.take_readbacks():- # Its own task: composing the sentence waits on a model,- # and the sweep must keep its two-second rhythm.- voice_readback.schedule(kind, term, _publisher)if _WATCHER.take_resume_dirty():await registry.persist_resume_activity()# After the stamps, so the event carries the word this sweepdiff --git a/jarvis/agentic_ide/session.py b/jarvis/agentic_ide/session.pyindex efac1055b3..13020a5794 100644--- a/jarvis/agentic_ide/session.py+++ b/jarvis/agentic_ide/session.py@@ -1140,14 +1140,6 @@ class Terminal:# bursts — for work nobody had asked for. A pane nobody has given an# instruction cannot have finished one, and this is how that is known.last_submit_at: float | None = None- # Is the job this pane is working on one the user gave THROUGH Jarvis (a- # spoken order, the IDE prompt bar)? Then Jarvis owes the user a spoken- # "here is what it did" when the pane stops (see `.voice_readback`). Set by- # the prompt paths that ask for it, cleared by a job typed in by hand and by- # the readback itself. Ephemeral: a restored pane owes nobody anything.- voice_readback: bool = False- # The user's own words for that job — what the readback is about.- voice_readback_request: str = ""# Did the last prompt actually leave the input line? None = none sent yet.submitted: bool | None = None# A hand-pressed Enter on an injected prompt is being checked against the@@ -4675,11 +4667,6 @@ class Registry:else:term.last_submit_at = term.last_input_atterm.submit_generation = term.process_generation- if term.reading().activity != "asking":- # A new job typed by hand is the user's own, and nobody- # asked Jarvis to report on it. Answering the pane's- # question keeps the Jarvis job (and its readback) alive.- term.voice_readback = False# And the pane's conversation may have just begun, which for most# coding CLIs is the first moment its id exists on disk at all. A# pane driven only by hand never goes through `send_prompt`, so@@ -6386,13 +6373,11 @@ class Registry:require_idle: bool = False,expected_input: str = "",allow_question: bool = False,- readback: bool = False,) -> Terminal:"""Serialize deliveries and pin the pane before the first await.- ``readback`` marks the job as one the user gave through Jarvis, so its- end is reported by voice (see :mod:`.voice_readback`). Callers that- supervise the pane themselves (a society agent) leave it off.+ How the job ends is shown on the pane (status badge, bell entry), never+ spoken: no pane result is read aloud (maintainer decision 2026-09-30)."""found = self.find_terminal(wanted, workspace_id)if found is None:@@ -6426,7 +6411,6 @@ class Registry:attachments=attachments,expected_input=expected_input,allow_question=allow_question,- readback=readback,)@staticmethod@@ -6445,7 +6429,6 @@ class Registry:attachments: Sequence[Any] = (),expected_input: str = "",allow_question: bool = False,- readback: bool = False,) -> Terminal:"""Type ``text`` into a terminal, press Enter, and CONFIRM it was sent.@@ -6592,10 +6575,6 @@ class Registry:term.manual_submit_token += 1term.submitted = submittedterm.sent_multiline = multiline and submitted is True- # Whoever sent THIS job decides whether its end is reported by voice; a- # supervising agent's follow-up replaces a Jarvis job and its readback.- term.voice_readback = readback- term.voice_readback_request = (typed or payload).strip() if readback else ""from .prompt_receipts import receipts_forhistory_entry = prompt_history.PromptHistoryEntry(diff --git a/jarvis/agentic_ide/voice_readback.py b/jarvis/agentic_ide/voice_readback.pydeleted file mode 100644index b05374bad8..0000000000--- a/jarvis/agentic_ide/voice_readback.py+++ /dev/null@@ -1,233 +0,0 @@-"""Tell the user, out loud, how a job they gave a pane through Jarvis ended.--"Prompt terminal T1 to fix the login bug" used to end at "Sent — T1 has the-brief and is working on it." The pane then worked for minutes, stopped, and-nothing more was said: the only sign was the bell in the IDE header. A job-the user gave Jarvis is a question Jarvis owes an answer to, so when such a-pane stops, Jarvis now says what it did — or, when it stopped on a question,-what it is asking.--What counts as "given through Jarvis" is decided at the send site-(``Registry.send_prompt(readback=True)``: the voice fan-out and the IDE prompt-bar) and carried on the pane (``Terminal.voice_readback``). A job typed into-the pane by hand, and one a supervising Jarvis agent handed over (it reports-itself), are not announced.--When it is spoken: the announcement uses a source the speech pipeline holds-for an open call (``_HELD_FOR_CALL_SOURCES``) — inside a call it is spoken at-the next free moment, outside one it waits for the next call. Jarvis never-speaks into a room where nobody called it.--What it says comes from the pane's own record: the coding CLI's final message-when its transcript is readable, else the last lines of its screen. That text-is phrased into one short sentence by the readback composer-(:mod:`jarvis.voice.report_readback`); the canned fallback names the pane and-quotes the report's first sentence.-"""--from __future__ import annotations--import asyncio-import inspect-import re-from collections.abc import Awaitable, Callable-from typing import Any, Literal--from loguru import logger--#: Where these announcements come from. Listed in the speech pipeline's-#: held-for-call sources, which is what keeps them out of an idle room.-SOURCE_LAYER = "agentic_ide.readback"--#: How many screen lines are read when no transcript is available.-SCREEN_LINES = 24--ReadbackKind = Literal["completed", "needs_input"]-Publisher = Callable[[Any], Awaitable[None]]--#: Deterministic fallbacks, spoken when the composer cannot phrase the report.-_CANNED: dict[str, dict[str, str]] = {- "completed": {- "de": "{name} ist fertig: {report}", # i18n-allow: spoken readback- "en": "{name} is done: {report}",- "es": "{name} ha terminado: {report}",- },- "completed_bare": {- "de": "{name} ist mit deinem Auftrag fertig.", # i18n-allow: spoken readback- "en": "{name} has finished your task.",- "es": "{name} ha terminado tu encargo.",- },- "needs_input": {- "de": "{name} hat eine Frage: {report}", # i18n-allow: spoken readback- "en": "{name} has a question: {report}",- "es": "{name} tiene una pregunta: {report}",- },- "needs_input_bare": {- "de": "{name} wartet auf deine Antwort.", # i18n-allow: spoken readback- "en": "{name} is waiting for your answer.",- "es": "{name} espera tu respuesta.",- },-}--_INSTRUCTIONS: dict[str, str] = {- "completed": (- "A coding agent in the terminal named {name} has finished the task the "- "user gave it through you. Tell the user what it did or found, based "- "only on its report. Name the terminal. If the report says something "- "failed or is still open, say so."- ),- "needs_input": (- "A coding agent in the terminal named {name} stopped while working on "- "the user's task and is waiting for the user. Tell the user briefly what "- "it is asking or needs, based only on its screen. Name the terminal."- ),-}--#: Box drawing, block elements and the spinner/prompt glyphs a TUI paints.-_TUI_NOISE_RE = re.compile(r"[─-▟⠀-⣿■-◿❯⏵⏸]+")--_tasks: set[asyncio.Task[None]] = set()---def schedule(kind: ReadbackKind, term: Any, publish: Publisher | None) -> None:- """Compose and publish the readback for ``term`` in a task of its own."""- if publish is None:- logger.debug("Agentic IDE readback for {}: no bus to speak on", getattr(term, "name", "?"))- return- try:- loop = asyncio.get_running_loop()- except RuntimeError: # no event loop (a sync test / CLI): nobody to speak to- logger.debug("Agentic IDE readback for {}: no event loop", getattr(term, "name", "?"))- return- task = loop.create_task(readback(kind, term, publish), name="agentic-ide-readback")- _tasks.add(task)- task.add_done_callback(_tasks.discard)---async def readback(kind: ReadbackKind, term: Any, publish: Publisher) -> None:- """Tell the user how the pane's Jarvis job ended. Never raises."""- name = str(getattr(term, "name", "") or "the terminal")- try:- request = str(getattr(term, "voice_readback_request", "") or "")- report = ""- if kind == "completed":- report = await asyncio.to_thread(final_report, term)- screen = "" if report else screen_text(term)- language = await asyncio.to_thread(_language, request)- text = await _compose(kind, name, language, request, report, screen)- if not text.strip():- return- from jarvis.core.events import AnnouncementRequested-- result = publish(- AnnouncementRequested(- source_layer=SOURCE_LAYER,- text=text,- language=language,- priority="normal",- # A readback kind: the answer to something the user asked for.- kind="completion",- detail=f"agentic_ide pane={name} outcome={kind}",- # A live voice model reasons over this itself; ``text`` is- # what classic TTS speaks.- report=_report_material(name, request, report, screen),- )- )- if inspect.isawaitable(result):- await result- logger.info("Agentic IDE readback for {} ({}): {!r}", name, kind, text[:120])- except Exception: # noqa: BLE001 - a lost readback must never touch the sweep- logger.opt(exception=True).warning("Agentic IDE readback for {} failed", name)---async def _compose(- kind: ReadbackKind, name: str, language: str, request: str, report: str, screen: str-) -> str:- from jarvis.voice.report_readback import compose_report, plain_excerpt-- excerpt = plain_excerpt(report, max_words=35)-- def canned() -> str:- key = kind if excerpt else f"{kind}_bare"- table = _CANNED[key]- return table.get(language, table["en"]).format(name=name, report=excerpt)-- facts: dict[str, object] = {"terminal": name}- if request:- facts["task the user gave"] = request[:400]- if screen:- facts["what the terminal shows"] = screen- return await compose_report(- instruction=_INSTRUCTIONS[kind].format(name=name),- language=language,- canned=canned,- report=report,- facts=facts,- )---def _report_material(name: str, request: str, report: str, screen: str) -> str:- """Everything the live model gets to think about, labelled."""- parts = [f"Terminal: {name}"]- if request:- parts.append(f"What the user asked for:\n{request}")- if report:- parts.append(f"The coding agent's final message:\n{report}")- elif screen:- parts.append(f"No transcript is readable; the terminal's screen shows:\n{screen}")- return "\n\n".join(parts)---def final_report(term: Any) -> str:- """The coding agent's last message, from its own transcript, or ``""``.-- Only the answer to the newest user message counts: a transcript whose last- turn is the user's own has not answered yet.-- A pane on a connected computer writes its transcript THERE; the local copy- stopped at the offload and ends with an older job's answer (#250). Such a- pane reports ``""`` and the readback falls back to its live screen.- """- from . import agent_transcript- from .session import account_home-- if getattr(term, "computer_id", ""):- return ""- handle = getattr(term, "resume", None)- agent = str(getattr(term, "agent", "") or "")- if handle is None or not agent_transcript.can_read(agent):- return ""- turns = agent_transcript.read(- agent, handle.id, home=account_home(agent, getattr(term, "account", None))- )- if not turns or turns[-1].role != "assistant":- return ""- return str(turns[-1].text or "").strip()---def screen_text(term: Any) -> str:- """The last lines on the pane's screen, without the TUI's drawing."""- try:- lines = list(term.transcript.tail(SCREEN_LINES))- except Exception: # noqa: BLE001 - no screen is an empty fact, not an error- logger.opt(exception=True).debug("Agentic IDE readback: screen unreadable")- return ""- cleaned = (" ".join(_TUI_NOISE_RE.sub(" ", line).split()) for line in lines)- return "\n".join(line for line in cleaned if line)[-1500:]---def _language(request: str) -> str:- """The language to speak in: the user's pin, else the words they used."""- from jarvis.core.turn_language import DEFAULT_LOCALE, resolve_output_language-- pin = ""- try:- from jarvis.core.config import load_config-- pin = str(getattr(load_config().brain, "reply_language", "") or "")- except Exception: # noqa: BLE001 - an unreadable config means "no pin"- logger.opt(exception=True).debug("Agentic IDE readback: reply-language pin unreadable")- return resolve_output_language(pin, "", request, default=DEFAULT_LOCALE)---__all__ = ["SOURCE_LAYER", "final_report", "readback", "schedule", "screen_text"]diff --git a/jarvis/realtime/report_prompt.py b/jarvis/realtime/report_prompt.pyindex 8055d85865..aab27f123c 100644--- a/jarvis/realtime/report_prompt.py+++ b/jarvis/realtime/report_prompt.py@@ -1,8 +1,10 @@"""The prompt that lets a live voice model reason over an agent's report.-Background results — a coding pane that finished the job Jarvis handed it, a-Jarvis agent reporting back — carry two things: a short deterministic line-(what classic TTS speaks) and the agent's full report. A live model is handed+An announcement that carries an agent's report (``AnnouncementRequested.report``)+has two things: a short deterministic line (what classic TTS speaks) and the+agent's full report. Coding panes and Jarvis agents no longer send one — their+results are shown, not spoken (2026-09-30) — so only a caller that still+attaches a report reaches this path. A live model is handedboth and asked to work out what the user actually needs to hear, instead ofreading either one out. Every live engine (the realtime wrapper, GPT-Live,native Gemini) builds its request here, so they all ask the same thing.diff --git a/jarvis/society/runtime.py b/jarvis/society/runtime.pyindex 9f9491da95..9a90818078 100644--- a/jarvis/society/runtime.py+++ b/jarvis/society/runtime.py@@ -68,89 +68,14 @@ class SocietyRuntimeClosed(RuntimeError):"""This runtime owner has entered terminal shutdown."""-#: What the person hears when a task Jarvis handed out comes back.-_LEAD_DONE: dict[str, str] = {- "de": "{name} ist fertig: {text}", # i18n-allow: spoken completion- "en": "{name} is done: {text}",- "es": "{name} ha terminado: {text}",-}-_LEAD_BLOCKED: dict[str, str] = {- "de": "{name} kam nicht weiter: {text}", # i18n-allow: spoken completion- "en": "{name} got stuck: {text}",- "es": "{name} se quedó atascado: {text}",-}--#: What the person hears when an agent answers Jarvis directly (SAY / QUERY /-#: ANSWER / PROPOSE to the lead). Previously these envelopes were only queued-#: into the Jarvis chat inbox and projected onto the island — voice stayed-#: silent after the "X ist dran, ich sage Bescheid" ack (live 2026-09-09).-_LEAD_MESSAGE: dict[str, str] = {- "de": "{name} meldet: {text}", # i18n-allow: spoken completion- "en": "{name} reports: {text}",- "es": "{name} informa: {text}",-}--#: The situation the readback composer is told about, per case. The agent's own-#: text is the only content it may use; the spoken line is Jarvis passing it on-#: in one short sentence, not the raw text clipped at a character count.-_LEAD_DONE_SITUATION = (- "The user's Jarvis agent named {name} finished a task the user gave it through "- "you. Tell the user what it did or found, based only on its report. Name the agent."-)-_LEAD_BLOCKED_SITUATION = (- "The user's Jarvis agent named {name} could not finish a task the user gave it "- "through you. Tell the user what stopped it, based only on its report. Name the agent."-)-_LEAD_MESSAGE_SITUATION: dict[MsgType, str] = {- MsgType.SAY: (- "The user's Jarvis agent named {name} sent a message. Pass it on to the "- "user in your own words. Name the agent."- ),- MsgType.QUERY: (- "The user's Jarvis agent named {name} is asking the user a question. Pass "- "the question on in your own words, keeping what exactly it asks. Name the agent."- ),- MsgType.ANSWER: (- "The user's Jarvis agent named {name} answered. Tell the user its answer in "- "your own words. Name the agent."- ),- MsgType.PROPOSE: (- "The user's Jarvis agent named {name} proposes something. Tell the user what "- "it proposes in your own words. Name the agent."- ),-}---def _lead_report_material(name: str, env: Any, status: str, summary: str) -> str:- """What a live voice model gets to think about for a lead-assigned result."""- task = str(getattr(env, "text", "") or env.payload.get("text") or "").strip()- outcome = "finished" if status == "done" else "could not finish"- parts = [f"Agent: {name} ({outcome} the task)"]- if task:- parts.append(f"What the user asked for:\n{task}")- parts.append(f"The agent's report:\n{summary}")- return "\n\n".join(parts)---async def _spoken_report(- *, instruction: str, language: str, line: str, name: str, report: str-) -> str:- """The agent's report as one short spoken sentence; ``line`` is the fallback."""- from jarvis.voice.report_readback import compose_report, plain_excerpt-- excerpt = plain_excerpt(report, max_words=40)- return await compose_report(- instruction=instruction,- language=language,- canned=lambda: line.format(name=name, text=excerpt),- report=report,- facts={"agent": name},- )-+# An agent reporting back to the lead is SHOWN, never spoken: a notice in the+# newest front-page chat carries the full text. The spoken readback (a flash+# model phrasing the report, billed on an API key) was removed by maintainer+# decision 2026-09-30 — nobody asked to hear background results read out.#: Board types that are somebody TALKING to the lead. RESULT stays out: chat-#: runs announce it via report_to_lead and mission runs via MissionAnnouncer —-#: announcing it here as well would speak every completion twice.+#: runs post it via report_to_lead and mission runs via the mission stack —+#: posting it here as well would show every completion twice._LEAD_INCOMING_TYPES: Final[frozenset[MsgType]] = frozenset({MsgType.SAY, MsgType.QUERY, MsgType.ANSWER, MsgType.PROPOSE})@@ -244,9 +169,6 @@ class SocietyRuntime:# ``event_publish`` is the app bus the WebSocket forwards (server.py hands# it in); without it the engine falls back to the process default bus.self.checkpoints = CheckpointEngine(self, publish=event_publish)- #: The same app bus, for what the lead has to SAY: a delegated task's- #: result is announced to the person (voice + front-page chat).- self._publish_event = event_publish#: The society's one memory service; every touch moves the figure to the Memory House.self.memory = SocietyMemory(self, on_activity=self.checkpoints.note_memory_activity)self.conversations = ConversationArchive(self._data_dir / "society-conversations.db")@@ -374,11 +296,11 @@ class SocietyRuntime:breakasync def _on_lead_incoming(self, env: SocietyEnvelope) -> None:- """Announce replies to a specific request from Jarvis.+ """Post replies to a specific request from Jarvis into the lead chat.- Direct agent chats and unsolicited board messages stay silent. A past- assignment to the same agent is not permission to speak a new chat.- Assignment completions retain their report_to_lead announcement.+ Direct agent chats and unsolicited board messages stay on the board. A+ past assignment to the same agent is not permission to surface a new+ chat. Assignment completions keep their report_to_lead notice."""try:if env.to_agent != LEAD_AGENT_ID or env.msg_type not in _LEAD_INCOMING_TYPES:@@ -413,109 +335,40 @@ class SocietyRuntime:except Exception: # noqa: BLE001 - a silent message is a lost courtesy, not a lost resultlog.warning("society: lead incoming announcement failed", exc_info=True)- async def _lead_message_lang(self, env: SocietyEnvelope) -> str:- """The spoken language for an agent's message to the lead.-- The envelope itself carries no lang (only ASSIGN does), so follow the- trace back to the lead's order and reuse its lang; fall back to "en"- and let the pipeline's authoritative resolver decide.- """- lang = str(env.payload.get("lang") or "").strip().lower()- if lang in _LEAD_MESSAGE:- return lang- try:- for event in await self.store.events_for_trace(env.trace_id):- candidate = str(event.payload.get("lang") or "").strip().lower()- if candidate in _LEAD_MESSAGE:- return candidate- # An ANSWER rarely shares its trace with the lead's order (the- # assignment turn runs without incoming context), so fall back to- # the newest assignment Jarvis sent this agent — its lang is the- # turn language the ack already spoke.- latest = await self.store.latest_assignment_for_agent(- env.from_agent, from_agent=LEAD_AGENT_ID- )- if latest is not None:- candidate = str(latest.payload.get("lang") or "").strip().lower()- if candidate in _LEAD_MESSAGE:- return candidate- except Exception: # noqa: BLE001 - the lang hint is best-effort only- log.debug("society: lead message lang lookup failed", exc_info=True)- return "en"-async def announce_lead_message(self, sender: AgentRecord, env: SocietyEnvelope) -> None:- """Close the loop on an agent talking back to Jarvis: tell the person.+ """Close the loop on an agent talking back to Jarvis: show the person.Twin of report_to_lead for conversational envelopes (SAY / QUERY /- ANSWER / PROPOSE): the text goes where the order came from — spoken- as a completion announcement on the app bus (the TTS pipeline and- the realtime session both read AnnouncementRequested) and posted as- a notice into the newest front-page chat. Neither leg may fail the run.+ ANSWER / PROPOSE): the text is posted as a notice into the newest+ front-page chat, where the order came from. It is not spoken — no+ background result is read aloud (maintainer decision 2026-09-30).+ A failed notice never fails the run."""summary = " ".join(str(env.text or "").split())if not summary:return- lang = await self._lead_message_lang(env)- line = _LEAD_MESSAGE.get(lang, _LEAD_MESSAGE["en"])svc = self._get_chat()post = getattr(svc, "post_notice", None)- if svc is not None and post is not None:- try:- sessions = svc.store.list_sessions(limit=1, surface="jarvis")- if sessions:- await post(- sessions[0].session_id,- {- "kind": "society_message",- "agent_id": sender.agent_id,- "agent_name": sender.name,- "msg_type": str(env.msg_type).lower(),- "status": "done",- "text": summary[:1000],- "session_id": sender.session_id,- "trace_id": env.trace_id,- },- )- except Exception: # noqa: BLE001 - chat notice is a courtesy; voice still runs- log.warning(- "society: incoming message notice for the lead chat failed", exc_info=True- )- if self._publish_event is None:+ if svc is None or post is None:return- # Phrased after the chat notice: the notice carries the full text- # and must not wait on the composer.- text = await _spoken_report(- instruction=_LEAD_MESSAGE_SITUATION.get(- env.msg_type, _LEAD_MESSAGE_SITUATION[MsgType.SAY]- ).format(name=sender.name),- language=lang,- line=line,- name=sender.name,- report=summary,- )try:- from jarvis.core.events import AnnouncementRequested-- maybe = self._publish_event(- AnnouncementRequested(- source_layer="society.lead",- text=text,- priority="normal",- language=lang,- kind="completion",- detail=(- f"agent={sender.agent_id} "- f"trace={env.trace_id} "- f"msg={str(env.msg_type).lower()}"- ),- # The live voice model thinks about the full message.- report=f"Message from {sender.name} ({str(env.msg_type).lower()}):\n{summary}",+ sessions = svc.store.list_sessions(limit=1, surface="jarvis")+ if sessions:+ await post(+ sessions[0].session_id,+ {+ "kind": "society_message",+ "agent_id": sender.agent_id,+ "agent_name": sender.name,+ "msg_type": str(env.msg_type).lower(),+ "status": "done",+ "text": summary[:1000],+ "session_id": sender.session_id,+ "trace_id": env.trace_id,+ },)- )- if asyncio.iscoroutine(maybe):- await maybe- except Exception: # noqa: BLE001 - a silent message is a lost courtesy, not a lost result- log.warning("society: incoming message announcement for the lead failed", exc_info=True)+ except Exception: # noqa: BLE001 - a lost notice is a lost courtesy, not a lost result+ log.warning("society: incoming message notice for the lead chat failed", exc_info=True)async def _deliver_pending(self) -> None:"""Recover committed messages and retry busy chats without opening sockets."""@@ -999,74 +852,39 @@ class SocietyRuntime:async def report_to_lead(self, target: AgentRecord, env: SocietyEnvelope, *, status: str, summary: str) -> None:- """Close the loop on a task Jarvis handed out: tell the person.+ """Close the loop on a task Jarvis handed out: show the person.Jarvis delegates by voice or from the front-page chat and acknowledgesat once ("Scout is on it"); the work then ends on the board, where theperson only sees it by opening the Agents section. So the RESULT of a- lead-assigned task also goes where the order came from — spoken as a- completion announcement on the app bus (the TTS pipeline and the- realtime session both read ``AnnouncementRequested``) and posted as a- notice into the newest front-page chat. Neither leg may fail the run.+ lead-assigned task is also posted where the order came from: a notice+ in the newest front-page chat. It is not spoken — no background result+ is read aloud (maintainer decision 2026-09-30). A failed notice never+ fails the run."""if not should_report(env, status):return- lang = str(env.payload.get("lang") or "en").lower()- line = (_LEAD_DONE if status == "done" else _LEAD_BLOCKED).get(- lang, (_LEAD_DONE if status == "done" else _LEAD_BLOCKED)["en"]- )svc = self._get_chat()post = getattr(svc, "post_notice", None)- if svc is not None and post is not None:- try:- sessions = svc.store.list_sessions(limit=1, surface="jarvis")- if sessions:- await post(- sessions[0].session_id,- {- "kind": "society_result",- "agent_id": target.agent_id,- "agent_name": target.name,- "status": status,- "text": summary[:1000],- "session_id": target.session_id,- "trace_id": env.trace_id,- },- )- except Exception: # noqa: BLE001 - the chat notice is a courtesy; the voice leg still runs- log.warning("society: result notice for the lead chat failed", exc_info=True)- if self._publish_event is None:+ if svc is None or post is None:return- # Phrased after the chat notice: the notice carries the full text- # and must not wait on the composer.- text = await _spoken_report(- instruction=(- _LEAD_DONE_SITUATION if status == "done" else _LEAD_BLOCKED_SITUATION- ).format(name=target.name),- language=lang if lang in _LEAD_DONE else "en",- line=line,- name=target.name,- report=summary,- )try:- from jarvis.core.events import AnnouncementRequested-- maybe = self._publish_event(- AnnouncementRequested(- source_layer="society.lead",- text=text,- priority="normal",- language=lang if lang in _LEAD_DONE else "en",- kind="completion",- detail=f"agent={target.agent_id} trace={env.trace_id}",- # The live voice model thinks about the full report.- report=_lead_report_material(target.name, env, status, summary),+ sessions = svc.store.list_sessions(limit=1, surface="jarvis")+ if sessions:+ await post(+ sessions[0].session_id,+ {+ "kind": "society_result",+ "agent_id": target.agent_id,+ "agent_name": target.name,+ "status": status,+ "text": summary[:1000],+ "session_id": target.session_id,+ "trace_id": env.trace_id,+ },)- )- if asyncio.iscoroutine(maybe):- await maybe- except Exception: # noqa: BLE001 - a silent completion is a lost courtesy, not a lost result- log.warning("society: result announcement for the lead failed", exc_info=True)+ except Exception: # noqa: BLE001 - a lost notice is a lost courtesy, not a lost result+ log.warning("society: result notice for the lead chat failed", exc_info=True)def pick_agent(self, task: str) -> AgentRecord | None:"""The active agent whose hands fit ``task`` best, or ``None``.diff --git a/jarvis/speech/pipeline.py b/jarvis/speech/pipeline.pyindex ffa0de5f3b..1da0aa56a6 100644--- a/jarvis/speech/pipeline.py+++ b/jarvis/speech/pipeline.py@@ -392,13 +392,11 @@ _READBACK_KINDS: frozenset[str] = frozenset(#: Readback sources that never speak outside a call (see ``_is_agent_reply``).#: A mission the user just asked for is not here: its answer may still punch-#: through the hangup gate (AD-OE5/OE6).+#: through the hangup gate (AD-OE5/OE6). A coding pane or a Jarvis agent that+#: finishes is not here either: since 2026-09-30 neither is spoken at all, only+#: shown (pane badge and bell, the agent chat notice)._HELD_FOR_CALL_SOURCES: frozenset[str] = frozenset({- "society.lead",- # A pane finishing a job Jarvis handed it (jarvis/agentic_ide/- # voice_readback.py): spoken inside the call, else at the next one.- "agentic_ide.readback","tasks.runner","workflows.runner","workflows.scheduler",diff --git a/jarvis/ui/web/agentic_ide_routes.py b/jarvis/ui/web/agentic_ide_routes.pyindex 83575f49c8..ab81db3d3c 100644--- a/jarvis/ui/web/agentic_ide_routes.py+++ b/jarvis/ui/web/agentic_ide_routes.py@@ -4277,8 +4277,6 @@ async def terminal_prompt(workspace_id=found[0].id,typed=req.prompt,attachments=attachments,- # Asked of Jarvis, so Jarvis reports how it ended.- readback=True,)except SessionError as exc:raise HTTPException(status_code=409, detail=str(exc)) from excdiff --git a/jarvis/voice/report_readback.py b/jarvis/voice/report_readback.pydeleted file mode 100644index cd1da2c0f4..0000000000--- a/jarvis/voice/report_readback.py+++ /dev/null@@ -1,146 +0,0 @@-"""Turn another agent's report into a short spoken sentence for the user.--Two things report back to the user through Jarvis: a coding agent in an-Agentic-IDE pane that finished the job Jarvis handed it, and a Jarvis agent-answering the lead. Both used to be read out raw — a markdown report clipped-at a character count, often mid-word, in whatever language the agent wrote.-What the user wants to hear is what Jarvis would say about it: one short,-natural sentence, in the conversation's language.--So the report goes through the same bounded flash composer every other-readback uses (:mod:`jarvis.voice.contextual_readback`), with the report as-the only facts it may use. When that composer is unavailable or its answer is-rejected, the canned line is spoken instead — built from the report's leading-sentences, cut at a sentence or word boundary and never inside a word.-"""--from __future__ import annotations--import asyncio-import re-from collections.abc import Callable-from typing import Any--from loguru import logger--__all__ = ["compose_report", "plain_excerpt", "set_composer"]--#: Off the turn-critical path: a background result may take a little longer to-#: phrase than an acknowledgement, but it must not hang on a dead provider.-LATENCY_BUDGET_MS = 4000--#: How much of a report the composer is shown. The end of a long report is-#: where an agent states its result, so a longer one keeps both ends.-MAX_REPORT_CHARS = 1800--_CODE_FENCE_RE = re.compile(r"```.*?```", re.DOTALL)-_INLINE_CODE_RE = re.compile(r"`([^`\n]*)`")-_LINK_RE = re.compile(r"\[([^\]]+)\]\([^)]*\)")-_MARKUP_RE = re.compile(r"(^|\s)(?:#{1,6}|[-*+>]|\d+[.)])\s+", re.MULTILINE)-_EMPHASIS_RE = re.compile(r"[*_~]{1,3}")-_SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")--_composer: Any = None-_composer_lock = asyncio.Lock()---def _plain(text: str) -> str:- """``text`` without markdown, code blocks and line structure."""- value = _CODE_FENCE_RE.sub(" ", str(text or ""))- value = _LINK_RE.sub(r"\1", value)- value = _INLINE_CODE_RE.sub(r"\1", value)- value = _MARKUP_RE.sub(r"\1", value)- value = _EMPHASIS_RE.sub("", value)- return " ".join(value.split())---def plain_excerpt(text: str, *, max_words: int = 40) -> str:- """The leading sentences of ``text`` as plain speech, within ``max_words``.-- Cut at a sentence boundary when one fits, else at a word boundary — never- inside a word, which is how the old 400-character cut ended readbacks.- """- plain = _plain(text)- if not plain:- return ""- kept: list[str] = []- total = 0- for sentence in _SENTENCE_SPLIT_RE.split(plain):- words = sentence.split()- if not words:- continue- if total + len(words) > max_words:- if not kept:- kept.append(" ".join(words[:max_words]).rstrip(",;:") + " …")- break- kept.append(sentence.strip())- total += len(words)- return " ".join(kept)---def _report_facts(report: str) -> str:- plain = _plain(report)- if len(plain) <= MAX_REPORT_CHARS:- return plain- half = MAX_REPORT_CHARS // 2- return f"{plain[:half]} … {plain[-half:]}"---async def _get_composer() -> Any:- """The readback composer, built once and off the event loop.-- Building it reads ``jarvis.toml`` and constructs a provider client, so it- runs in a thread; it never raises and falls back to canned-only mode.- """- global _composer- if _composer is not None:- return _composer- async with _composer_lock:- if _composer is None:- from jarvis.brain.factory import build_readback_composer-- _composer = await asyncio.to_thread(build_readback_composer)- return _composer---async def compose_report(- *,- instruction: str,- language: str,- canned: Callable[[], str],- report: str,- facts: dict[str, object] | None = None,-) -> str:- """One short spoken sentence about ``report``, or the canned line.-- ``instruction`` describes the situation in English; ``report`` is the- agent's own words, the only content the sentence may draw on. Never raises.- """- from jarvis.voice.contextual_readback import render_readback-- all_facts: dict[str, object] = dict(facts or {})- if report.strip():- all_facts["report"] = _report_facts(report)- try:- composer = await _get_composer()- except Exception: # noqa: BLE001 - a missing composer only costs the phrasing- logger.opt(exception=True).warning("Report readback: composer unavailable")- composer = None- return await render_readback(- composer,- instruction=instruction,- language=language,- canned=canned,- facts=all_facts,- # The report is usually in another language than the speech (briefs are- # English), so the content-overlap guard would reject every good- # rephrasing; the digit and vocabulary guards still apply.- honesty_bound=False,- latency_budget_ms=LATENCY_BUDGET_MS,- )---def set_composer(composer: Any) -> None:- """Use ``composer`` from now on; ``None`` builds it again on next use."""- global _composer- _composer = composerdiff --git a/tests/conftest.py b/tests/conftest.pyindex 3bcf5331c4..3860c87c8e 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -183,23 +183,6 @@ def _pricing_feed_in_tmp(tmp_path_factory, monkeypatch): # noqa: ANN001yield[email protected](autouse=True)-def _report_readback_canned_only():- """Keep spoken report readbacks off the real flash provider.-- ``jarvis.voice.report_readback`` builds its composer from the host's own- ``jarvis.toml`` on first use, which in a test would be a real model call.- A bare composer speaks the deterministic canned line; suites that test the- phrasing hand in their own composer on top of this.- """- from jarvis.voice import report_readback- from jarvis.voice.contextual_readback import ReadbackComposer-- report_readback.set_composer(ReadbackComposer())- yield- report_readback.set_composer(None)--@pytest.fixture(autouse=True)def _app_action_state_in_tmp(tmp_path_factory, monkeypatch): # noqa: ANN001"""Every registry-command or app-action call records its outcome for thediff --git a/tests/contract/test_society_communication.py b/tests/contract/test_society_communication.pyindex 4db94dd743..c6b7807985 100644--- a/tests/contract/test_society_communication.py+++ b/tests/contract/test_society_communication.py@@ -149,7 +149,8 @@ async def test_question_returns_once_and_answer_ends_exchange(world):assert answers[0].text == "Navigation and reading succeeded."assert reply_policy(answers[0]) == "none"assert "No reply is requested" in frame_incoming(answers[0], "Scout")- assert len(chat.notices) == len(published) == 1+ assert len(chat.notices) == 1+ assert published == [], "a reply to the lead is shown, never spoken"refused = await MessageAgentTool(rt, "jarvis").execute({"target": "scout",@@ -209,7 +210,8 @@ async def test_message_reporting_matrix(world, policy, status, expected):rt, chat, published = worldrequest = await send(rt, reply_policy=policy)await finish_message(rt, chat, request, status=status)- assert len(chat.notices) == len(published) == expected+ assert len(chat.notices) == expected+ assert published == [], "a reply to the lead is shown, never spoken"if expected and status == "error":replies = await rt.store.events_for_trace(request.trace_id)assert replies[-1].payload["reply_status"] == "blocked"@@ -275,7 +277,7 @@ async def test_assignment_reporting_preserves_result_and_releases_slot(ctx(),)assert reported.success- assert not published # The watcher owns the single completion announcement.+ assert not published # Nothing to the lead is spoken.assert not any(chat.store.incoming_message(session.session_id, reported.output["message_id"])for session in chat.store.list_sessions(surface="jarvis")@@ -290,7 +292,8 @@ async def test_assignment_reporting_preserves_result_and_releases_slot(]assert len(results) == 1 and results[0].payload["status"] == statusassert rt.scheduler.active_runs("scout") == 0- assert len(chat.notices) == len(published) == expected+ assert len(chat.notices) == expected+ assert published == [], "a reply to the lead is shown, never spoken"@pytest.mark.parametrize(diff --git a/tests/unit/agentic_ide/test_pane_notifications.py b/tests/unit/agentic_ide/test_pane_notifications.pyindex de60a4aad0..75d9531092 100644--- a/tests/unit/agentic_ide/test_pane_notifications.py+++ b/tests/unit/agentic_ide/test_pane_notifications.py@@ -1087,3 +1087,18 @@ def _entry(entry_id: str) -> notifications.Notification:detail="",created_at=1.0,)+++def test_a_finished_pane_job_is_shown_never_spoken() -> None:+ """Maintainer decision 2026-09-30: how a pane's job ended is shown (badge,+ bell entry) and never read aloud. The spoken readback also cost a model+ call on an API key per job; nothing may bring it back unnoticed."""+ import importlib.util+ import inspect++ from jarvis.speech.pipeline import _HELD_FOR_CALL_SOURCES++ assert importlib.util.find_spec("jarvis.agentic_ide.voice_readback") is None+ assert "readback" not in inspect.signature(Registry.send_prompt).parameters+ assert not hasattr(notifications.watcher(), "take_readbacks")+ assert "agentic_ide.readback" not in _HELD_FOR_CALL_SOURCESdiff --git a/tests/unit/agentic_ide/test_voice_readback.py b/tests/unit/agentic_ide/test_voice_readback.pydeleted file mode 100644index ee4ad99452..0000000000--- a/tests/unit/agentic_ide/test_voice_readback.py+++ /dev/null@@ -1,230 +0,0 @@-"""A job the user gave a pane through Jarvis ends with Jarvis saying how it went.--The bell (``test_pane_notifications``) says THAT a pane stopped. This is the-spoken half: only for jobs handed over through Jarvis, once per job, phrased-from the pane's own report, and routed through the speech pipeline's-held-for-call gate so it never speaks into an idle room.-"""--from __future__ import annotations--from pathlib import Path-from typing import Any--import pytest--from jarvis.agentic_ide import notifications, voice_readback-from jarvis.agentic_ide import session as session_mod-from jarvis.agentic_ide.activity import STILL_S-from jarvis.agentic_ide.session import Registry-from jarvis.core.events import AnnouncementRequested-from jarvis.speech.pipeline import SpeechPipeline-from jarvis.voice.report_readback import plain_excerpt-from tests.fakes.fake_pty_manager import FakePtyManager--QUESTION_SCREEN = "\r\nDo you want to make this edit to config.py?\r\n❯ 1. Yes\r\n"--[email protected](autouse=True)-def _clean_store() -> Any:- notifications.reset()- yield- notifications.reset()---def registry(monkeypatch: pytest.MonkeyPatch) -> Registry:- monkeypatch.setattr(session_mod, "agent_argv", lambda name: (f"/usr/bin/{name}",))- return Registry(pty_manager=FakePtyManager())---def no_pin(monkeypatch: pytest.MonkeyPatch) -> None:- """Keep the host's real reply-language pin out of the language decision."""- from jarvis.core import config-- def _unreadable() -> Any:- raise OSError("no config in this test")-- monkeypatch.setattr(config, "load_config", _unreadable)---async def _noop(_data: Any) -> None:- return None---async def _pane(registry: Registry, folder: Path) -> tuple[Any, Any]:- session = await registry.start(str(folder), [{"agent": "claude", "name": "Alex"}])- term = await registry.attach("Alex", 100, 30, _noop, _noop)- return session, term---def _work_then_rest(- watcher: Any, registry: Registry, term: Any, screen: str, *, emit: bool-) -> None:- """Busy for three sweeps, then still until the stop is reported."""- term.last_submit_at = 99.9- term.submit_generation = term.process_generation- at = 100.0- for step in range(3):- at = 100.0 + step * notifications.SWEEP_INTERVAL_S- term.transcript.clear()- term.transcript.feed(f"\r\n· working, frame {step}\r\n")- watcher.poll(registry, now=at, emit=emit)- rest = at + 1- term.transcript.clear()- term.transcript.feed(screen)- term.last_output_at = rest- term.last_input_at = None- watcher.poll(registry, now=rest, emit=emit)- watcher.poll(registry, now=rest + STILL_S + 2, emit=emit)- watcher.poll(registry, now=rest + STILL_S + notifications.SETTLE_S + 4, emit=emit)---async def test_a_jarvis_job_that_finishes_owes_one_readback(- registry: Registry, tmp_path: Path-) -> None:- watcher = notifications.watcher()- _session, term = await _pane(registry, tmp_path)- term.voice_readback = True-- # The bell switch is off: the spoken readback does not depend on it.- _work_then_rest(watcher, registry, term, "\r\n❯ \r\n", emit=False)-- assert watcher.take_readbacks() == [("completed", term)]- assert term.voice_readback is False, "one readback per job"- assert watcher.take_readbacks() == []---async def test_a_job_nobody_gave_through_jarvis_is_not_announced(- registry: Registry, tmp_path: Path-) -> None:- watcher = notifications.watcher()- _session, term = await _pane(registry, tmp_path)-- _work_then_rest(watcher, registry, term, "\r\n❯ \r\n", emit=True)-- assert watcher.take_readbacks() == []---async def test_a_question_is_announced_and_keeps_the_job_open(- registry: Registry, tmp_path: Path-) -> None:- watcher = notifications.watcher()- _session, term = await _pane(registry, tmp_path)- term.voice_readback = True-- _work_then_rest(watcher, registry, term, QUESTION_SCREEN, emit=True)-- assert watcher.take_readbacks() == [("needs_input", term)]- assert term.voice_readback is True, "its end is still owed"---async def test_a_job_typed_by_hand_cancels_the_readback(- registry: Registry, tmp_path: Path-) -> None:- session, term = await _pane(registry, tmp_path)- term.voice_readback = True-- registry.write(term.key, "do something else\r", workspace_id=session.id)-- assert term.voice_readback is False---async def test_the_readback_is_phrased_from_the_agents_report(- monkeypatch: pytest.MonkeyPatch, no_pin: None-) -> None:- published: list[Any] = []-- async def publish(event: Any) -> None:- published.append(event)-- term = _FakeTerm(request="Behebe bitte den Login-Fehler") # i18n-allow: user's words- monkeypatch.setattr(- voice_readback,- "final_report",- lambda _term: "## Summary\n\nFixed the **login** bug in `auth.py`. All 12 tests pass.",- )-- await voice_readback.readback("completed", term, publish)-- assert len(published) == 1- event = published[0]- assert isinstance(event, AnnouncementRequested)- assert event.source_layer == voice_readback.SOURCE_LAYER- assert event.kind == "completion"- assert event.language == "de"- # The live model gets the whole report and the user's own words to think about.- assert "Fixed the **login** bug in `auth.py`." in (event.report or "")- assert "Behebe bitte den Login-Fehler" in (event.report or "") # i18n-allow: user's words- # The test composer is canned-only (root conftest): pane name + the- # report's first sentences, markdown gone.- spoken = (- "Alex ist fertig: " # i18n-allow: spoken readback- "Summary Fixed the login bug in auth.py. All 12 tests pass."- )- assert event.text == spoken---async def test_without_a_report_the_readback_still_names_the_pane(- monkeypatch: pytest.MonkeyPatch, no_pin: None-) -> None:- published: list[Any] = []-- async def publish(event: Any) -> None:- published.append(event)-- monkeypatch.setattr(voice_readback, "final_report", lambda _term: "")-- await voice_readback.readback("completed", _FakeTerm(request="Run the tests"), publish)-- assert [e.text for e in published] == ["Alex has finished your task."]---def test_a_remote_pane_never_reads_its_stale_local_transcript(- monkeypatch: pytest.MonkeyPatch,-) -> None:- """#250: the transcript of a pane on a connected computer lives there; the- local copy ends with the previous job's answer."""- from jarvis.agentic_ide import agent_transcript-- def _stale(*_a: Any, **_k: Any) -> Any:- raise AssertionError("a remote pane's local transcript is stale")-- monkeypatch.setattr(agent_transcript, "read", _stale)- monkeypatch.setattr(agent_transcript, "can_read", lambda _agent: True)- term = _FakeTerm(request="Fix the login bug")- term.computer_id = "vps-1"- term.agent = "claude"- term.resume = type("Handle", (), {"id": "abc"})()-- assert voice_readback.final_report(term) == ""---def test_the_pipeline_holds_pane_readbacks_for_an_open_call() -> None:- event = AnnouncementRequested(- source_layer=voice_readback.SOURCE_LAYER, kind="completion", text="Alex is done."- )- assert SpeechPipeline._is_agent_reply(event)---def test_an_excerpt_is_never_cut_inside_a_word() -> None:- long = " ".join(f"word{i}" for i in range(80))- excerpt = plain_excerpt(long, max_words=10)- assert excerpt.split()[:10] == [f"word{i}" for i in range(10)]- assert excerpt.endswith("…")- assert plain_excerpt("First one. Second one. Third.", max_words=4) == "First one. Second one."---class _FakeTerm:- name = "Alex"-- def __init__(self, *, request: str) -> None:- self.voice_readback_request = request- self.transcript = _Screen()---class _Screen:- @staticmethod- def tail(_n: int) -> list[str]:- return []diff --git a/tests/unit/society/test_lead_card.py b/tests/unit/society/test_lead_card.pyindex 38329cc6b3..4e126b3007 100644--- a/tests/unit/society/test_lead_card.py+++ b/tests/unit/society/test_lead_card.py@@ -12,8 +12,8 @@ society. The card is the fix, and these tests pin its contract:5. the rule block says what "agent" means and where the old system went;6. the realtime helper hands the planner the live names;7. the lead picks the fitting agent for a nameless delegation;-8. a lead-assigned RESULT reaches the person: a chat notice and a spoken- completion.+8. a lead-assigned RESULT reaches the person as a chat notice, never spoken+ (no background result is read aloud since 2026-09-30)."""from __future__ import annotations@@ -227,18 +227,15 @@ async def test_a_lead_assigned_result_reaches_the_person(rt: SocietyRuntime):assert payload["agent_name"] == "Gmail agent"assert payload["status"] == "done"assert payload["text"] == "Invoice answered."+ # Shown, never spoken (2026-09-30): no announcement, no phrasing model call.published = rt.published # type: ignore[attr-defined]- announcements = [e for e in published if type(e).__name__ == "AnnouncementRequested"]- assert len(announcements) == 1- assert announcements[0].kind == "completion"- assert announcements[0].language == "de"- spoken = "Gmail agent ist fertig: Invoice answered." # i18n-allow: spoken completion- assert announcements[0].text == spoken+ assert [e for e in published if type(e).__name__ == "AnnouncementRequested"] == []async def test_an_agent_answer_to_the_lead_reaches_the_person(rt: SocietyRuntime):- """Live 2026-09-09: the ack promised a report, the ANSWER arrived, voice- stayed silent. The lead's incoming message is owed an answer too."""+ """Live 2026-09-09: the ack promised a report, the ANSWER arrived, and+ nothing reached the person. The lead's incoming message is owed a notice+ too — in the chat, not by voice."""import asynciochat: FakeChat = rt.chat # type: ignore[attr-defined]@@ -275,12 +272,16 @@ async def test_an_agent_answer_to_the_lead_reaches_the_person(rt: SocietyRuntimeassert payload["agent_name"] == "Gmail agent"assert payload["msg_type"] == "answer"assert payload["text"] == "Invoice answered."- announcements = [e for e in published if type(e).__name__ == "AnnouncementRequested"]- assert len(announcements) == 1- assert announcements[0].kind == "completion"- assert announcements[0].language == "de"- spoken = "Gmail agent meldet: Invoice answered." # i18n-allow: spoken completion- assert announcements[0].text == spoken+ # Shown, never spoken (2026-09-30).+ assert [e for e in published if type(e).__name__ == "AnnouncementRequested"] == []+++def test_no_model_phrases_a_background_report_anymore() -> None:+ """The flash composer that turned an agent's report into a spoken sentence+ (billed on an API key) is gone with the spoken readback (2026-09-30)."""+ import importlib.util++ assert importlib.util.find_spec("jarvis.voice.report_readback") is Noneasync def test_agent_to_agent_chatter_stays_silent(rt: SocietyRuntime):diff --git a/tests/unit/speech/test_agent_reply_readbacks.py b/tests/unit/speech/test_agent_reply_readbacks.pyindex a9b44ec12a..6d5ce8346a 100644--- a/tests/unit/speech/test_agent_reply_readbacks.py+++ b/tests/unit/speech/test_agent_reply_readbacks.py@@ -12,7 +12,9 @@ from tests.unit.speech.test_realtime_mode import _FakeRealtimeSession, _FakeTTS,def reply(name="Nala"):return AnnouncementRequested(- source_layer="society.lead",+ # A routine an agent ran: the held-for-call path society.lead used to+ # share before agent messages stopped being spoken (2026-09-30).+ source_layer="tasks.runner",kind="completion",language="en",text=f"{name} reports: The draft is ready.",