agentwire-dev 1.69.0__tar.gz → 1.71.0__tar.gz

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/.github/workflows/pytest.yml

@@ -10,7 +10,7 @@
 # is on PATH. Per the council guardrail we do NOT chase coverage % or block PRs
 # on flaky/tmux-dependent tests.
 #
-# Coverage is measured and surfaced (term-missing in the log + a table in the
+# On pushes to main, coverage is measured and surfaced (term-missing in the log + a table in the
 # run's job summary + an uploaded coverage.xml artifact) but is REPORT-ONLY:
 # there is deliberately no --cov-fail-under, so a low percentage never reds the
 # build. The point is visibility — letting the maintainer spot untested
@@ -37,13 +37,22 @@ jobs:
       - name: Sync dependencies
         run: uv sync --extra dev
 
-      - name: Run test suite (tmux-dependent tests deselected) + coverage
+      # Pull requests run the FAST set: no coverage tracing (it multiplies
+      # runtime on a hosted runner) and no `slow` tests (real git/tmux
+      # processes per test). A PR gate that takes 45 minutes gets bypassed.
+      - name: Run test suite (fast set)
+        if: github.event_name == 'pull_request'
+        run: uv run --no-sync pytest -q -m "not requires_tmux and not slow"
+
+      # Pushes to main run everything hermetic, with the report-only coverage.
+      - name: Run test suite (full) + coverage
+        if: github.event_name != 'pull_request'
         run: >
           uv run --no-sync pytest -q -m "not requires_tmux"
           --cov=agentwire --cov-report=term-missing --cov-report=xml
 
       - name: Publish coverage summary (report-only)
-        if: always()
+        if: github.event_name != 'pull_request' && always()
         run: |
           {
             echo '## Coverage (report-only — no threshold gate)'
@@ -54,7 +63,7 @@ jobs:
           } >> "$GITHUB_STEP_SUMMARY"
 
       - name: Upload coverage.xml artifact
-        if: always()
+        if: github.event_name != 'pull_request' && always()
         uses: actions/upload-artifact@v4
         with:
           name: coverage-xml

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: agentwire-dev
-Version: 1.69.0
+Version: 1.71.0
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.69.0"
+__version__ = "1.71.0"

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/__main__.py

@@ -183,7 +183,7 @@ Command Categories:
     #   - diff:   structured git diff for the mobile Review window
     #   - prompts: prompt routing (rides the limits watchdog)
     #   - msg:    polite agent-to-agent inbox (rides the watchdog)
-    from . import alerts_cli, diff_cli, limits_cli, msg_cli, pane_cli, prompts_cli, send_cli  # noqa: I001  # session_cli kept on its own line below to minimize Phase 1 #495 merge conflicts
+    from . import activity_cli, alerts_cli, diff_cli, limits_cli, msg_cli, pane_cli, prompts_cli, send_cli  # noqa: I001  # session_cli kept on its own line below to minimize Phase 1 #495 merge conflicts
     from . import session_cli
     from . import channels_cli, config_cli, portal_cli, tts_cli
     from . import scheduler_cli, ensure_cli, tasks_cli
@@ -199,6 +199,7 @@ Command Categories:
         prompts_cli.register_prompts_parser,
         msg_cli.register_msg_parser,
         alerts_cli.register_alerts_parser,
+        activity_cli.register_activity_parser,
         limits_cli.register_limits_parser,
         pane_cli.register_pane_parser,
         send_cli.register_send_parser,

agentwire_dev-1.71.0/agentwire/activity_cli.py

@@ -0,0 +1,86 @@
+"""``agentwire activity`` — what the fleet has been doing (#1016).
+
+The read side of :mod:`~agentwire.fleet_activity`. It exists as a CLI verb for
+two reasons, and the second is the load-bearing one:
+
+1. "CLI is the single source of truth" — a store readable only from inside the
+   process tree that writes it is exactly the shape that rule exists to prevent.
+2. The voice layer dispatches **only** through the CLI (see
+   ``voice_layer/tools.py``), so without this verb the buddy could not read the
+   ledger that was built for it.
+
+Read-only, by construction: nothing here writes. Producers record from inside
+the surfaces that generate the events (idle, say, toast, scheduled run), never
+from a verb an agent could be talked into calling.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import timedelta
+
+from . import fleet_activity
+
+#: Widest window the verb will look back over. The ledger is capped at
+#: ``MAX_ENTRIES`` anyway, so this bounds the ANSWER rather than the read: a
+#: request for a week of awareness is a request for history, and
+#: ``agentwire scheduler history`` / the event logs are where history lives.
+MAX_HOURS = 72
+
+
+def cmd_activity_list(args) -> int:
+    json_mode = getattr(args, "json", False)
+    hours = max(1, min(MAX_HOURS, int(getattr(args, "hours", 12) or 12)))
+    entries = fleet_activity.recent(
+        limit=max(1, int(getattr(args, "limit", 50) or 50)),
+        event=getattr(args, "event", "") or "",
+        session=getattr(args, "session", "") or "",
+        window=timedelta(hours=hours),
+    )
+    if json_mode:
+        print(json.dumps({
+            "success": True,
+            "count": len(entries),
+            "window_hours": hours,
+            "ledger": str(fleet_activity.ledger_path()),
+            "activity": entries,
+        }, indent=2))
+        return 0
+    if not entries:
+        print(f"No fleet activity recorded in the last {hours}h.")
+        return 0
+    for entry in entries:
+        # The announced flag is shown, not hidden: "recorded" and "said out
+        # loud" are different facts, and an operator debugging a chatty or a
+        # silent buddy needs to see which one an entry was.
+        mark = "*" if entry.get("announced") else " "
+        print(f"{mark} {entry.get('ts', '')}  {entry.get('event', ''):<16} "
+              f"{entry.get('text', '')}")
+    print()
+    print("* = also queued to fleet-alert subscribers (spoken by the voice buddy at a gap)")
+    return 0
+
+
+def register_activity_parser(subparsers) -> None:
+    parser = subparsers.add_parser(
+        "activity",
+        help="What the fleet has been doing (idle, tasks, toasts, speech)",
+        description=(
+            "The fleet's activity ledger: sessions going idle, scheduled tasks "
+            "finishing, toasts shown to the owner, and everything spoken aloud "
+            "through fleet TTS. This is AWARENESS — a record something can read "
+            "when asked. Only a short, ruled subset is also queued to "
+            "fleet-alert subscribers (see `agentwire alerts`); the rest waits "
+            "here to be looked up."
+        ),
+    )
+    sub = parser.add_subparsers(dest="activity_command", required=True)
+
+    p = sub.add_parser("list", help="Recent activity, newest first")
+    p.add_argument("--limit", type=int, default=50, help="Max entries (default: 50)")
+    p.add_argument("--hours", type=int, default=12,
+                   help=f"How far back to look (1-{MAX_HOURS}, default: 12)")
+    p.add_argument("--event", choices=fleet_activity.EVENTS, help="Only this event type")
+    p.add_argument("-s", "--session", help="Only this session (exact name)")
+    p.add_argument("--json", action="store_true", help="Output JSON")
+    p.set_defaults(func=cmd_activity_list)

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/beta.py

@@ -176,7 +176,18 @@ def gated_doc(fn):
     wrong, so the property is pinned over the WHOLE registry —
     ``test_no_published_description_carries_a_marker`` fails on any published
     description containing a marker, whatever put it there.
+
+    The resolution happens ONCE, at import, against whatever flag state the
+    process started with — so any later reader that wants to verify the
+    resolved text needs to know which flags it was resolved WITH, not which
+    flags are on now. ``__beta_enabled__`` records exactly that (and
+    ``__beta_raw_doc__`` the pre-resolution text), which is what lets the
+    byte-identity tests hold on a machine with a beta flag enabled instead of
+    silently asserting the developer's personal config (#1023).
     """
-    if fn.__doc__:
-        fn.__doc__ = render(fn.__doc__)
+    if fn.__doc__ and "beta:" in fn.__doc__:
+        enabled = enabled_flags()
+        fn.__beta_raw_doc__ = fn.__doc__
+        fn.__beta_enabled__ = frozenset(enabled)
+        fn.__doc__ = render(fn.__doc__, enabled=enabled)
     return fn

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/buddy_cli.py

@@ -29,6 +29,26 @@ from .voice_layer import delivery, identity, realtime, tools
 #: project keeps closing, and here the owner is often not even at a screen.
 BETA_KEY = "beta.voice_layer"
 
+#: The one ``--voice`` help string, shared by register/mint/serve (#1017).
+#:
+#: Enumerated here rather than declared as argparse ``choices=``, deliberately.
+#: ``choices`` does print the set and does reject early — but its rejection is
+#: argparse's own ("invalid choice"), which cannot say what the default is, is
+#: case-SENSITIVE (so a spoken-then-typed "Cedar" would be refused for no
+#: reason), and exits before any handler runs, which means the ``--json``
+#: caller gets a parser usage dump on stderr instead of a JSON error object.
+#: :func:`_check_voice` does all three properly, and this string is what makes
+#: the list discoverable without reaching the error at all.
+#:
+#: No percent signs anywhere in it: argparse runs help through printf-style
+#: interpolation, and a lone one raises at parse time.
+_VOICE_HELP = (
+    "Realtime voice, one of: " + realtime.voice_list()
+    + f" (default: {realtime.DEFAULT_VOICE}; cedar and marin are the newer, "
+    "more natural pair). Fixed for a session — switch it live from the picker "
+    "on the buddy page."
+)
+
 
 def _refuse_beta(json_mode: bool) -> int:
     """Refuse a buddy command because the beta flag is off.
@@ -127,20 +147,75 @@ def _fail(message: str, json_mode: bool) -> int:
     return 1
 
 
+def _check_voice(args) -> "int | None":
+    """Refuse an unknown ``--voice`` before anything is written or spent.
+
+    Early, and in every verb that takes one: the alternative is a bridge that
+    starts, connects, and then produces no audio at all — which in a screenless
+    channel is indistinguishable from a mic problem, an API outage, or the
+    buddy simply having nothing to say. The refusal carries the whole list,
+    because ten closed values are short enough to print and guessing is what
+    put the typo there.
+
+    Returns an exit code to propagate, or ``None`` when the voice is fine.
+    """
+    voice = getattr(args, "voice", "")
+    if not voice:
+        return None
+    try:
+        args.voice = realtime.validate_voice(voice)
+    except realtime.RealtimeError as exc:
+        return _fail(str(exc), getattr(args, "json", False))
+    return None
+
+
 def cmd_buddy_register(args) -> int:
     json_mode = getattr(args, "json", False)
+    refused = _check_voice(args)
+    if refused is not None:
+        return refused
+    # Read BEFORE the write: what changed is only knowable against the record
+    # that was there. Re-announcing a full registration over a one-word voice
+    # change reads like a second identity was created (#1017).
     try:
+        delta = identity.registration_delta(
+            args.name, model=args.model, voice=args.voice
+        )
         metadata = identity.register(args.name, model=args.model, voice=args.voice)
     except identity.BuddyError as exc:
         return _fail(str(exc), json_mode)
     status = identity.status(args.name)
+    changes = delta["changes"]
+    payload = {
+        "success": True,
+        "created": not delta["registered"],
+        "changes": changes,
+        "buddy": status,
+        "metadata": metadata,
+    }
+    if delta["registered"]:
+        lines = [
+            f"{field} → {change['to']}"
+            + (f" (was {change['from']})" if change["from"] else "")
+            for field, change in sorted(changes.items())
+        ]
+        return _emit(
+            payload,
+            json_mode,
+            [f"Voice buddy '{args.name}' is already registered."]
+            + [f"  updated {line}" for line in lines]
+            + ([] if lines else ["  nothing to change."]),
+        )
     return _emit(
-        {"success": True, "buddy": status, "metadata": metadata},
+        payload,
         json_mode,
         [
             f"Registered voice buddy '{args.name}'.",
             f"  inbox:  {status['inbox_dir']}",
             f"  spool:  {status['spool_path']}",
+            f"  voice:  {status['realtime_voice'] or realtime.DEFAULT_VOICE} (default)"
+            if not status["realtime_voice"]
+            else f"  voice:  {status['realtime_voice']}",
             "",
             f"Other sessions can now reach it: agentwire msg send --to {args.name} ...",
             "It has no tmux session — its mail is spooled, not pasted.",
@@ -164,6 +239,8 @@ def cmd_buddy_status(args) -> int:
             f"  role:        {status['role']} (not in the fleet topology)",
             f"  delivery:    {status['delivery']} (spooled, no tmux pane)",
             f"  registered:  {status['registered_at']}",
+            f"  voice:       {status['realtime_voice'] or realtime.DEFAULT_VOICE}"
+            + ("" if status["realtime_voice"] else " (default)"),
             f"  pending:     {status['pending']} message(s) awaiting the next drain",
             f"  unread:      {status['unread']} spooled message(s)",
         ],
@@ -253,6 +330,9 @@ def cmd_buddy_mint(args) -> int:
     json_mode = getattr(args, "json", False)
     from .voice_layer import instructions as buddy_instructions
 
+    refused = _check_voice(args)
+    if refused is not None:
+        return refused
     if not identity.is_registered(args.name):
         return _fail(_no_buddy(args.name), json_mode)
     try:
@@ -260,7 +340,8 @@ def cmd_buddy_mint(args) -> int:
             instructions=buddy_instructions.build_instructions(),
             tools=tools.realtime_tool_defs(),
             model=args.model or realtime.DEFAULT_MODEL,
-            voice=args.voice or realtime.DEFAULT_VOICE,
+            # Explicit flag → the buddy's recorded voice → the default.
+            voice=identity.resolve_voice(args.name, args.voice),
         )
     except realtime.RealtimeError as exc:
         return _fail(str(exc), json_mode)
@@ -280,6 +361,9 @@ def cmd_buddy_serve(args) -> int:
     """Serve the browser client on localhost until interrupted."""
     from .voice_layer import server
 
+    refused = _check_voice(args)
+    if refused is not None:
+        return refused
     if not identity.is_registered(args.name):
         return _fail(_no_buddy(args.name), getattr(args, "json", False))
     # Renew the fleet-alert lease (#982) — a buddy being started is a buddy that
@@ -294,6 +378,8 @@ def cmd_buddy_serve(args) -> int:
         args.name, port=args.port, model=args.model, voice=args.voice
     )
     print(f"buddy '{args.name}' listening on {url}")
+    print(f"voice: {identity.resolve_voice(args.name, args.voice)} "
+          f"(switch it on the page — no restart needed)")
     print("Open that URL in a browser and click Start talking. Ctrl-C to stop.")
     try:
         while True:
@@ -327,7 +413,7 @@ def register_buddy_parser(subparsers) -> None:
 
     reg = _common(sub.add_parser("register", help="Create the buddy's session identity"))
     reg.add_argument("--model", default="", help=f"Realtime model (default: {realtime.DEFAULT_MODEL})")
-    reg.add_argument("--voice", default="", help=f"Realtime voice (default: {realtime.DEFAULT_VOICE})")
+    reg.add_argument("--voice", default="", metavar="VOICE", help=_VOICE_HELP)
     reg.set_defaults(func=beta_gated(cmd_buddy_register))
 
     _common(sub.add_parser("status", help="Show the buddy's identity and mail counts")).set_defaults(
@@ -359,12 +445,12 @@ def register_buddy_parser(subparsers) -> None:
 
     mint = _common(sub.add_parser("mint", help="Mint an ephemeral Realtime session"))
     mint.add_argument("--model", default="")
-    mint.add_argument("--voice", default="")
+    mint.add_argument("--voice", default="", metavar="VOICE", help=_VOICE_HELP)
     mint.set_defaults(func=beta_gated(cmd_buddy_mint))
 
     srv = _common(sub.add_parser("serve", help="Serve the browser client on localhost"))
     srv.add_argument("--port", type=int, default=8788,
                      help="Port on 127.0.0.1 (default: 8788 — never a portal port)")
     srv.add_argument("--model", default="")
-    srv.add_argument("--voice", default="")
+    srv.add_argument("--voice", default="", metavar="VOICE", help=_VOICE_HELP)
     srv.set_defaults(func=beta_gated(cmd_buddy_serve))

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/channels_cli.py

@@ -304,10 +304,37 @@ def cmd_say(args) -> int:
     toast_ok = _post_desktop_notification(display, session=session, priority="normal",
                                           timeout=30) if display else None
 
+    def _record_spoken(heard: str, sink: str) -> None:
+        """Record what the owner ACTUALLY heard, for the voice layer (#1016).
+
+        Takes the heard text rather than reading `text` from the enclosing
+        scope, because on the local path those differ: `say` chunks, and a
+        failure on chunk 3 of 4 still played chunks 1 and 2 out loud. Recording
+        the whole string would claim the owner heard a sentence that never
+        played; recording nothing would let the buddy later offer, as news,
+        something they already heard. Both are the same defect — a record that
+        does not match the room.
+
+        This entry is NEVER announced to the buddy, whatever it said. The owner
+        already heard it; a voice channel that reads the audio back is the
+        two-surfaces problem made worse. What the record buys is the opposite —
+        the buddy can see what the fleet has already said and decline to offer
+        it as news.
+        """
+        if not heard.strip():
+            return
+        from agentwire import fleet_activity
+
+        try:
+            fleet_activity.note_spoke(heard, session=session or "", sink=sink)
+        except Exception:  # noqa: BLE001  # speaking is the job; the record is not
+            pass
+
     def _say_result(rc: int, sink: str, clients: int = 0) -> int:
         """Report which sink actually received the audio (#444): browser
         (played by N connected clients), local speakers / OS voice, or a
-        failed dispatch — instead of a blind "queued"."""
+        failed dispatch — instead of a blind "queued".
+        """
         if json_mode:
             _output_json({"success": rc == 0, "sink": sink if rc == 0 else None,
                           "clients": clients, "session": session, "toast": toast_ok,
@@ -322,6 +349,9 @@ def cmd_say(args) -> int:
 
         if has_connections:
             rc = _remote_say(text, actual_session, portal_url)
+            # One dispatch, one outcome: the browser path is not chunked here.
+            if rc == 0:
+                _record_spoken(text, "browser")
             return _say_result(rc, "browser", clients)
 
     # No portal connections — chunk locally for better TTS quality
@@ -329,14 +359,19 @@ def cmd_say(args) -> int:
     chunks = chunk_text(text)
 
     last_sink = "os-voice"
+    spoken: list[str] = []
     for chunk in chunks:
         result, last_sink = _local_say_dispatch(
             chunk, voice, exaggeration, cfg_weight, tts_config,
             backend=backend, instructions=instructions, language=language, stream=stream
         )
         if result != 0:
+            # Partial: the chunks before this one PLAYED. Record exactly those.
+            _record_spoken(" ".join(spoken), last_sink)
             return _say_result(result, last_sink)
+        spoken.append(chunk)
 
+    _record_spoken(" ".join(spoken), last_sink)
     return _say_result(0, last_sink)
 
 

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/cohort.py

@@ -70,10 +70,12 @@ STALE_GRACE = 3600
 # silently disarms the guard.
 PENDING = "pending"
 REPORTED = "reported"  # report collected, child killed
+IDLE = "resolved_idle"  # child went idle WITHOUT reporting (#952) — the idle
+                        # handler's synthetic placeholder arrived, no report did
 TIMEOUT = "timeout"    # deadline hit with no report; child killed anyway
 GONE = "gone"          # child's session vanished before it reported
 
-RESOLVED_STATES = (REPORTED, TIMEOUT, GONE)
+RESOLVED_STATES = (REPORTED, IDLE, TIMEOUT, GONE)
 
 # Topologies, which decide whether resolving a child also tears its session
 # down. A `main`-topology child (`agentwire new`) is the leak this issue is
@@ -100,6 +102,14 @@ WORKTREE = "worktree"
 # tests/unit/test_voice_kind.py::TestCohortInteraction.
 REPORT_KINDS = ("done", "request", "escalation", "note")
 
+# The idle handler's synthetic placeholder kind (#952). Harvested so the child
+# still RESOLVES promptly, but never counted as a report: a placeholder means
+# "the child went idle without reporting", and `wait` says exactly that
+# (state IDLE) instead of flattening it into `reported`. The discriminator is
+# the KIND, deliberately not the message text — a sentinel string is defeated
+# by any child that happens to write the same words as its genuine report.
+IDLE_KIND = "idle"
+
 _POLL_INTERVAL = 2.0
 
 
@@ -314,7 +324,7 @@ def _harvest(parent: str) -> dict[str, list]:
 
         out: dict[str, list] = {}
         for msg in inbox.list_messages(parent):
-            if msg.kind in REPORT_KINDS:
+            if msg.kind in REPORT_KINDS or msg.kind == IDLE_KIND:
                 out.setdefault(msg.sender, []).append(msg)
         return out
     except Exception:
@@ -361,9 +371,21 @@ def collect(parent: str) -> dict | None:
     for child in outstanding:
         msgs = reports.get(child)
         if msgs:
-            _mark(data, child, REPORTED, _consume(msgs))
+            # A slot holding ONLY the idle handler's synthetic placeholder is
+            # not a report (#952): the child went idle without saying anything.
+            # Any genuine report kind alongside it wins — the child both
+            # reported and idled, which is the normal happy path.
+            real = [m for m in msgs if m.kind in REPORT_KINDS]
+            placeholders = [m for m in msgs if m.kind == IDLE_KIND]
+            if real:
+                text = _consume(real)
+                _consume(placeholders)  # clear the files, drop the synthetic text
+                _mark(data, child, REPORTED, text)
+                log_event("collected", parent=parent, child=child)
+            else:
+                _mark(data, child, IDLE, _consume(placeholders))
+                log_event("child_idle_no_report", parent=parent, child=child)
             _teardown(data, child)
-            log_event("collected", parent=parent, child=child)
         elif not session_exists(child):
             _mark(data, child, GONE)
             log_event("child_gone", parent=parent, child=child)
@@ -405,12 +427,17 @@ def summarize(data: dict) -> dict:
         "pending": [c["session"] for c in children if c.get("state") == PENDING],
         "reports": [{"session": c["session"], "report": c.get("report")}
                     for c in children if c.get("state") == REPORTED],
+        # Resolved without a report (#952) — the child idled and the only
+        # thing in its slot was the idle handler's placeholder. Silence is a
+        # legitimate outcome; being counted as a report is not.
+        "idle": [{"session": c["session"], "report": c.get("report")}
+                 for c in children if c.get("state") == IDLE],
         "failed": [{"session": c["session"], "state": c.get("state")}
                    for c in children if c.get("state") in (TIMEOUT, GONE)],
         # Resolved but deliberately still running: worktree children, whose
         # branch/PR teardown follows merge verification (#756).
         "left_alive": [c["session"] for c in children
-                       if c.get("state") in (REPORTED, TIMEOUT)
+                       if c.get("state") in (REPORTED, IDLE, TIMEOUT)
                        and c.get("torn_down") is False],
         "children": children,
     }
@@ -432,8 +459,8 @@ def wait(parent: str, timeout: float = 600.0,
     data = load(parent)
     if not data:
         return {"parent": parent, "cohort": False, "resolved": True,
-                "pending": [], "reports": [], "failed": [], "left_alive": [],
-                "children": []}
+                "pending": [], "reports": [], "idle": [], "failed": [],
+                "left_alive": [], "children": []}
 
     deadline = time.time() + max(timeout, 0)
     while True:
@@ -442,7 +469,8 @@ def wait(parent: str, timeout: float = 600.0,
         if not result["pending"]:
             discard(parent)
             log_event("resolved", parent=parent,
-                      reported=len(result["reports"]), failed=len(result["failed"]))
+                      reported=len(result["reports"]), idle=len(result["idle"]),
+                      failed=len(result["failed"]))
             return {**result, "cohort": True, "resolved": True}
         if time.time() >= deadline:
             return {**result, "cohort": True, "resolved": False}

{agentwire_dev-1.69.0 → agentwire_dev-1.71.0}/agentwire/config.py

@@ -1010,11 +1010,14 @@ def load_config(config_path: Optional[Path] = None) -> Config:
     # Apply environment variable overrides
     data = _apply_env_overrides(data)
 
-    # Debug logging for STT config
+    # Debug logging for STT config. DEBUG, not INFO (#1018): config loading is
+    # not an event anyone asked to be told about, and at INFO it printed on
+    # ordinary CLI commands the moment anything in the process configured the
+    # root logger.
     import logging
     logger = logging.getLogger(__name__)
     if 'stt' in data:
-        logger.info(f"STT config after env overrides: {data['stt']}")
+        logger.debug(f"STT config after env overrides: {data['stt']}")
 
     return _dict_to_config(data)