Skip to content

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.

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.md
index 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 aft
write), the router's decision table has a DELEGATE way ahead of `spawn_worker`, the realtime
session 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). **M3
world** is the maintainer's parallel track. Open in M4: rooms live under the scheduler, the
curator.
diff --git a/docs/agent-society/agent-definition.md b/docs/agent-society/agent-definition.md
index 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`) i
name the roster does not know, "email agent") the lead picks the agent whose focus fits the
task (`SocietyRuntime.pick_agent`, `derive_focus` over the task text) or says that nobody
fits. 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" to
the 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 on
the 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.py
index 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.py
index 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, NamedTuple
from loguru import logger
-from . import voice_readback
from .activity import (
RESIZE_SHADOW_S,
STILL_S,
@@ -445,13 +444,6 @@ class ActivityWatcher:
self.center = center
self._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 taken
def take_resume_dirty(self) -> bool:
"""Return and clear whether activity changed the resume checkpoint."""
@@ -649,14 +641,6 @@ class ActivityWatcher:
watch.announced = True
watch.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 None
return 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 sweep
diff --git a/jarvis/agentic_ide/session.py b/jarvis/agentic_ide/session.py
index 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_at
term.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 += 1
term.submitted = submitted
term.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_for
history_entry = prompt_history.PromptHistoryEntry(
diff --git a/jarvis/agentic_ide/voice_readback.py b/jarvis/agentic_ide/voice_readback.py
deleted file mode 100644
index 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.py
index 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 handed
both and asked to work out what the user actually needs to hear, instead of
reading 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.py
index 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:
break
async 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 result
log.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 acknowledges
at once ("Scout is on it"); the work then ends on the board, where the
person 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.py
index 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.py
index 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 exc
diff --git a/jarvis/voice/report_readback.py b/jarvis/voice/report_readback.py
deleted file mode 100644
index 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 = composer
diff --git a/tests/conftest.py b/tests/conftest.py
index 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: ANN001
yield
[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 the
diff --git a/tests/contract/test_society_communication.py b/tests/contract/test_society_communication.py
index 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 = world
request = 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"] == status
assert 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.py
index 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_SOURCES
diff --git a/tests/unit/agentic_ide/test_voice_readback.py b/tests/unit/agentic_ide/test_voice_readback.py
deleted file mode 100644
index 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.py
index 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 asyncio
chat: FakeChat = rt.chat # type: ignore[attr-defined]
@@ -275,12 +272,16 @@ async def test_an_agent_answer_to_the_lead_reaches_the_person(rt: SocietyRuntime
assert 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 None
async 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.py
index 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.",