agentwire-dev 1.54.0__tar.gz → 1.55.0__tar.gz

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.54.0
+Version: 1.55.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.54.0 → agentwire_dev-1.55.0}/agentwire/__init__.py

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

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/inbox.py

@@ -62,6 +62,13 @@ BROADCAST_TOKEN = "@all"
 # being permanently busy/typed-in).
 MAX_ATTEMPTS = 40
 
+# A recipient that positively does not exist gets a much shorter window (#694):
+# a gone session can't clear its box by itself — it only comes back if someone
+# recreates it — so the grace is ~5 watchdog ticks (≈5 min), enough for a
+# restart/recreate to land, not the 40-minute busy cap. Counted separately
+# (``Message.gone_attempts``) so prior busy penalties don't erode the grace.
+GONE_MAX_ATTEMPTS = 5
+
 # Defer reasons that DON'T penalize: the target is legitimately busy — running a
 # long command (unparseable box → "target_busy") or generating with human-queued
 # input (the "queued messages" placeholder → "queued_placeholder"), or the box
@@ -106,6 +113,7 @@ class Message:
     text: str
     ts: int  # epoch ms
     attempts: int = 0
+    gone_attempts: int = 0  # ticks the drain observed the target session gone
     reason: str = ""  # last defer reason (why delivery kept failing)
     dead_ts: int = 0  # epoch ms when dead-lettered (0 = still live)
     ref: str = ""  # optional machine-readable pointer (e.g. a report path) — for ingest
@@ -120,6 +128,7 @@ class Message:
             "text": self.text,
             "ts": self.ts,
             "attempts": self.attempts,
+            "gone_attempts": self.gone_attempts,
             "reason": self.reason,
             "dead_ts": self.dead_ts,
             "ref": self.ref,
@@ -251,6 +260,7 @@ def _read_message(path: Path) -> "Message | None":
             text=str(data.get("text", "")),
             ts=int(data.get("ts", 0)),
             attempts=int(data.get("attempts", 0)),
+            gone_attempts=int(data.get("gone_attempts", 0)),
             reason=str(data.get("reason", "")),
             dead_ts=int(data.get("dead_ts", 0)),
             ref=str(data.get("ref", "")),
@@ -484,19 +494,34 @@ def gc_sender(sender: str) -> dict:
 # =============================================================================
 
 
-def _live_agent_sessions() -> list[str]:
-    """Every tmux session whose pane 0 runs an agent (Claude/pi)."""
-    from . import prompt_router
+def live_sessions() -> "set[str] | None":
+    """Every live tmux session name, or None when tmux is unreachable.
+
+    ``None`` (no server / no tmux) is deliberately distinct from ``set()``:
+    the gone fast-path (#694) and the send-time warning only fire on POSITIVE
+    knowledge that tmux is reachable but the target isn't there. With the
+    server down everything is equally unreachable — that's an outage, not a
+    gone recipient, so callers fall back to the ordinary defer path.
+    """
     from .usage_limit import _tmux
 
     try:
         result = _tmux(["list-sessions", "-F", "#{session_name}"])
     except Exception:
-        return []
+        return None
     if result.returncode != 0:
+        return None
+    return {s for s in result.stdout.split("\n") if s.strip()}
+
+
+def _live_agent_sessions() -> list[str]:
+    """Every tmux session whose pane 0 runs an agent (Claude/pi)."""
+    from . import prompt_router
+
+    sessions = live_sessions()
+    if not sessions:
         return []
-    sessions = [s for s in result.stdout.split("\n") if s.strip()]
-    return [s for s in sessions if prompt_router.is_agent_pane(s, 0)]
+    return [s for s in sorted(sessions) if prompt_router.is_agent_pane(s, 0)]
 
 
 def resolve_targets(to: str, sender: "str | None") -> list[str]:
@@ -639,6 +664,15 @@ def _bump_attempts(messages: list[Message], reason: str = "") -> int:
     ``reason`` is the defer reason that caused this pass; it's stamped onto the
     message so a dead-lettered one carries *why* it never got delivered.
     Returns the number dead-lettered this pass.
+
+    ``target_gone`` additionally bumps the per-message ``gone_attempts``
+    counter and dead-letters at the fast ``GONE_MAX_ATTEMPTS`` cap (#694) — a
+    gone session can't un-go by itself, so it gets minutes of grace (enough
+    for a recreate to land), not the 40-minute busy window. The counter is
+    separate from ``attempts`` so busy penalties accrued while the target
+    lived don't erode the grace, and cumulative across gone observations —
+    a target that flaps in and out without ever accepting delivery still
+    burns out on schedule.
     """
     dead = 0
     for msg in messages:
@@ -657,7 +691,9 @@ def _bump_attempts(messages: list[Message], reason: str = "") -> int:
 
         msg.attempts += 1
         msg.reason = reason
-        if msg.attempts >= MAX_ATTEMPTS:
+        if reason == "target_gone":
+            msg.gone_attempts += 1
+        if msg.attempts >= MAX_ATTEMPTS or msg.gone_attempts >= GONE_MAX_ATTEMPTS:
             msg.dead_ts = _now_ms()
             target = dead_dir(msg.to or "unknown") / msg.path.name
             try:
@@ -737,6 +773,22 @@ def flush_session(session: str, force: bool = False) -> dict:
         if not messages:
             return {"session": session, "delivered": 0, "deferred": False, "reason": "empty"}
 
+        # Gone gate FIRST (#694): a recipient that positively doesn't exist can
+        # never clear a box, and the ordinary gates misread it — capturing a
+        # gone session parses as "no box" → target_busy, a NO-penalty defer, so
+        # a done to a stale parent once sat queued ~24h instead of burning out.
+        # Gone is its own penalized reason with the fast GONE_MAX_ATTEMPTS cap.
+        # Only positive knowledge counts: with tmux unreachable live_sessions()
+        # is None and the ordinary defer path applies.
+        live = live_sessions()
+        if live is not None and session not in live:
+            dead = _bump_attempts(messages, "target_gone")
+            _log_event("deferred", to=session, count=len(messages), reason="target_gone")
+            return {
+                "session": session, "delivered": 0, "deferred": True,
+                "reason": "target_gone", "dead": dead,
+            }
+
         pre_consumed = 0
         if not force:
             # Collision guard FIRST (cheap, and refuses dialogs/busy too via None).

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/mcp_msg.py

@@ -17,6 +17,12 @@ def msg_send(to: str, text: str, kind: str = "note", ref: str = "") -> str:
     is empty and the pane is safe, so it can never clobber a human who is
     mid-typing. Delivery is at the next safe boundary (≤60s), not instant.
 
+    Sending to a named session that doesn't currently exist still queues (the
+    session may be about to be created), but the confirmation carries a
+    warning: unless the session appears, the message dead-letters within a few
+    minutes (and load-bearing kinds email the owner). Heed the warning — a
+    gone recipient usually means a stale session name; check sessions_list.
+
     Prefer `session_send` ONLY when you must forcibly drive a session right
     now (it pastes + Enter immediately, overwriting any uncommitted draft).
 
@@ -34,7 +40,8 @@ def msg_send(to: str, text: str, kind: str = "note", ref: str = "") -> str:
             so the recipient can open the file without parsing free text.
 
     Returns:
-        Confirmation of which sessions were queued, or an error.
+        Confirmation of which sessions were queued — plus a warning when a
+        named recipient doesn't currently exist — or an error.
     """
     caller = get_caller_session()
     args = ["msg", "send", "--to", to, "--kind", kind]
@@ -48,7 +55,10 @@ def msg_send(to: str, text: str, kind: str = "note", ref: str = "") -> str:
         recipients = data.get("recipients") or []
         if not recipients:
             return f"No live recipients for '{to}'."
-        return f"Queued {kind} → {', '.join(recipients)} (delivers when their box is clear)."
+        out = f"Queued {kind} → {', '.join(recipients)} (delivers when their box is clear)."
+        for warning in data.get("warnings") or []:
+            out += f"\nWarning: {warning}"
+        return out
     return f"Failed to queue message: {data.get('error', 'Unknown error')}"
 
 
@@ -149,12 +159,16 @@ def msg_dead(session: str | None = None) -> str:
     """List dead-lettered polite messages — ones dropped after retrying out.
 
     A `msg` whose recipient never cleared its input box (or stayed parked /
-    non-agent) is retried for ~40 minutes, then dead-lettered rather than lost
-    silently. Use this to see what never reached someone, and why.
+    non-agent) is retried for ~40 minutes; one whose recipient doesn't exist
+    dead-letters after only a few minutes (`target_gone`). Either way the drop
+    is recorded here rather than lost silently. Use this to see what never
+    reached someone, and why.
 
     Args:
-        session: Session name (default: the calling session; omit to list
-            every session that has dead-lettered messages).
+        session: Scope to one session's graveyard. Omitted means GLOBAL —
+            every session that has dead-lettered messages (#693: it never
+            defaults to the calling session, so a monitoring loop inside a
+            session still sees the whole graveyard).
 
     Returns:
         The dead-lettered messages with their drop reason + timestamp, or a

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/mcp_worktree.py

@@ -52,15 +52,41 @@ def worktree_create(
     caller = get_caller_session()
     if caller:
         args += ["--created-by", caller]
-    # Seeding waits for agent boot (~up to 60s); give the CLI room to finish.
-    data = run_agentwire_cmd(args, timeout=90)
+    # Seeding waits for agent boot (up to 60s) and, on a failed seed, runs the
+    # clear-box + inbox-fallback recovery (#695) — give the CLI room to finish
+    # the loud-failure path instead of masking it with a subprocess timeout.
+    data = run_agentwire_cmd(args, timeout=180)
     if not data.get("success"):
         return f"Failed to create worktree: {data.get('error', 'Unknown error')}"
     session = data.get("session", name)
     path = data.get("path", "")
-    seeded = " (seeded)" if prompt and data.get("first_message_delivered") else ""
     if data.get("reattached"):
-        return f"Reattached to existing worktree session '{session}' at {path}."
+        note = (
+            " NOTE: the session was already live, so the seed prompt was NOT "
+            "pasted — send it with msg_send if still needed."
+            if prompt
+            else ""
+        )
+        return f"Reattached to existing worktree session '{session}' at {path}.{note}"
+    # Seed failure must be LOUD (#695): a silently-missing "(seeded)" suffix is
+    # invisible to an orchestrator skimming results, and the session then sits
+    # idle with the task never delivered.
+    if prompt and not data.get("first_message_delivered"):
+        if data.get("first_message_fallback") == "inbox":
+            return (
+                f"Created worktree session '{session}' at {path}. "
+                "WARNING: seed prompt NOT delivered — the input box was not ready. "
+                "The prompt was queued to the session's msg inbox and the watchdog "
+                "will deliver it once the box is ready; verify with msg_inbox / "
+                "session_output before assuming the task started."
+            )
+        return (
+            f"Created worktree session '{session}' at {path}. "
+            "WARNING: seed prompt NOT delivered and could NOT be queued — the "
+            f"session is idle with no task. Deliver it manually (session_send to "
+            f"'{session}')."
+        )
+    seeded = " (seeded)" if prompt else ""
     return f"Created worktree session '{session}'{seeded} at {path}."
 
 

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/msg_cli.py

@@ -66,15 +66,36 @@ def cmd_msg_send(args) -> int:
             print(f"Nothing queued — {reason}.")
         return 0
 
+    # Send-time existence signal (#694): queueing to a named session that
+    # doesn't currently exist is legal (it may be created shortly), but the
+    # sender must learn the target is gone instead of reading a bare "Queued"
+    # as delivery-in-progress. @all targets are live by construction, and with
+    # tmux unreachable (live is None) we can't positively say gone — no warning.
+    live = inbox.live_sessions()
+    missing = (
+        []
+        if args.to == inbox.BROADCAST_TOKEN or live is None
+        else sorted({m.to for m in written} - live)
+    )
+    warnings = [
+        f"session '{t}' does not currently exist — message will dead-letter "
+        f"in ~{inbox.GONE_MAX_ATTEMPTS} min unless it appears"
+        for t in missing
+    ]
+
     if getattr(args, "json", False):
         print(json.dumps({
             "success": True,
             "queued": [m.to_dict() for m in written],
             "recipients": [m.to for m in written],
+            "missing": missing,
+            "warnings": warnings,
         }))
     else:
         recips = ", ".join(m.to for m in written)
         print(f"Queued {args.kind} from {sender} → {recips}")
+        for warning in warnings:
+            print(f"Warning: {warning}")
     return 0
 
 
@@ -171,8 +192,8 @@ def _parse_duration(text: str) -> "int | None":
 
 def _purge_dead(args) -> int:
     """Clear dead-lettered corpses. ``-s`` scopes to one session; without it the
-    whole graveyard is cleared (purge never falls back to the *current* session
-    — that's a listing convenience, too sharp an edge for a delete)."""
+    whole graveyard is cleared — same no-``-s``-means-global rule as the lister
+    (#693), and purge never guesses a session for a delete."""
     import sys
     import time
 
@@ -203,13 +224,19 @@ def cmd_msg_dead(args) -> int:
     """List (or, with ``--purge``, clear) dead-lettered messages.
 
     These are messages a recipient never accepted — its input box stayed busy,
-    or it was parked/non-agent the whole time. They are *not* retried; this is
-    where silent data loss became visible. ``--purge`` is the human/ops cleanup
-    for the graveyard `doctor` surfaces.
+    it was parked/non-agent the whole time, or it didn't exist. They are *not*
+    retried; this is where silent data loss became visible. ``--purge`` is the
+    human/ops cleanup for the graveyard `doctor` surfaces.
+
+    Omitted ``-s`` means GLOBAL — every session's graveyard (#693). It never
+    falls back to the caller's session: every agent runs inside tmux, so a
+    caller-scoped default made the global view unreachable exactly where
+    monitoring loops run, silently reporting "no dead letters" while other
+    sessions' graveyards grew.
     """
     if getattr(args, "purge", False):
         return _purge_dead(args)
-    session = getattr(args, "session", None) or _current_session()
+    session = getattr(args, "session", None)
     sessions = [session] if session else inbox.dead_sessions()
 
     grouped = [(s, inbox.list_dead(s)) for s in sessions]
@@ -350,8 +377,8 @@ def register_msg_parser(subparsers) -> None:
     )
     dead_parser.add_argument(
         "-s", "--session", default=None,
-        help="Session (list default: current, or all when outside one; "
-             "purge default: all — never the current session)",
+        help="Scope to one session (default: every session's graveyard, "
+             "for both list and --purge)",
     )
     dead_parser.add_argument(
         "--purge", action="store_true",

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/pane_manager.py

@@ -280,7 +280,14 @@ def send_to_target(target: str, text: str, enter: bool = True) -> None:
             result = run_command(["tmux", "load-buffer", temp_path], timeout=5)
             if not result.success:
                 raise RuntimeError(f"Failed to load buffer: {result.stderr.strip()}")
-            result = run_command(["tmux", "paste-buffer", "-t", target], timeout=5)
+            # -p wraps the paste in bracketed-paste delimiters when the app has
+            # requested them (Claude Code always does; tmux falls back to a
+            # plain paste otherwise). Without the explicit end-of-paste marker,
+            # Claude Code detects the paste heuristically as an input burst,
+            # and an Enter arriving inside that window is coalesced INTO the
+            # paste as a newline instead of submitting — the swallowed-Enter
+            # root cause behind the #698 stress-test failures.
+            result = run_command(["tmux", "paste-buffer", "-p", "-t", target], timeout=5)
             if not result.success:
                 raise RuntimeError(f"Target '{target}' not found: {result.stderr.strip()}")
         finally:

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/prompt_router.py

@@ -775,20 +775,26 @@ def _flush_stuck_box(session: str, pane_index: int, visible: str) -> bool:
 
       - the box parses and holds non-empty, non-placeholder content,
       - the content starts with a machine-injected header (never a human draft),
-      - the pane is not mid-generation (no ``esc to interrupt`` footer),
+      - no live select-menu is on screen (Enter would answer the dialog),
       - the identical content has sat there for ``STUCK_BOX_SWEEPS``
         consecutive sweeps (state persisted per-pane next to prompt markers).
 
+    A mid-generation pane is deliberately NOT skipped (#698): Enter on a
+    generating Claude Code pane QUEUES the draft (Esc interrupts, Enter never
+    does), while the old ``esc to interrupt`` gate both refused the flush AND
+    reset the counter every sweep — so a stuck box on a busy orchestrator was
+    never rescued for as long as it kept working (the 2026-07-04 12:40
+    incident, where the owner watched the message sit and pressed Enter
+    manually). Frames we can't judge (unparseable box, live menu) HOLD the
+    counter instead of resetting it, for the same reason.
+
     Never pastes — Enter only, so the #621 idempotency dedup keeps holding.
     """
     path = _stuck_box_path(session, pane_index)
     box = input_box_content(visible)
-    if (
-        not box
-        or not _MACHINE_HEADER_RE.match(box)
-        or is_queued_placeholder(box)
-        or "esc to interrupt" in visible.lower()
-    ):
+    if box is None or screen_shows_live_menu(visible):
+        return False  # can't judge this frame / Enter unsafe — hold the counter
+    if not box or not _MACHINE_HEADER_RE.match(box) or is_queued_placeholder(box):
         try:
             path.unlink(missing_ok=True)
         except OSError:

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/scheduler/schedule.py

@@ -14,6 +14,11 @@ from .models import (
     _parse_time,
 )
 
+# Minimum sleep when the board has a DUE task that isn't runnable (gate
+# failed). Without it, pick_next_task returns (None, 0.0) and the main loop
+# spins at time.sleep(0) — see #691.
+GATE_RETRY_FLOOR = 30.0
+
 
 def _dt_to_ts(dt: datetime | None) -> float:
     """Convert a datetime to a Unix timestamp (0 if None)."""
@@ -258,9 +263,14 @@ def pick_next_task(board: Board) -> tuple[str | None, float]:
         if _sched._check_gate(board, name):
             return name, 0.0
 
-    # Nothing to run now — calculate sleep until earliest task is due
+    # Nothing to run now — calculate sleep until earliest task is due. A task
+    # can be DUE yet not runnable (gate failed, above), which makes
+    # seconds_until_next_due return 0.0 — without a floor the main loop does
+    # time.sleep(0) and spins hard: gate command re-run + portal notify
+    # ~12×/sec until the gate ever passes (#691). Floor to GATE_RETRY_FLOOR so
+    # a due-but-gated board re-checks at loop cadence instead.
     wait = seconds_until_next_due(board)
-    return None, wait
+    return None, max(wait, GATE_RETRY_FLOOR)
 
 
 def seconds_until_next_due(board: Board) -> float:

{agentwire_dev-1.54.0 → agentwire_dev-1.55.0}/agentwire/session_cli.py

@@ -477,11 +477,25 @@ def cmd_new(args) -> int:
             )
         save_project_config(project_config, session_path)
 
+    # Record the creating session as parent for prompt routing. --created-by
+    # overrides; empty string opts out; default = the calling tmux session.
+    # Resolved before seeding so a failed seed can name its sender.
+    created_by = getattr(args, 'created_by', None)
+    if created_by is None:
+        created_by = pane_manager.get_current_session()
+
     # Deliver the first message once the agent is ready (verified paste).
-    # Delivery failure doesn't fail the command — the session exists.
+    # Delivery failure doesn't fail the command — the session exists — but it
+    # must be LOUD (#695): clear the partial paste out of the box and fall
+    # back to the msg inbox so the prompt still arrives once the box is ready.
     first_message_delivered = None
+    first_message_fallback = None
     if first_message and agent_cmd:
-        from agentwire.session_ready import send_verified, wait_for_session_ready
+        from agentwire.session_ready import (
+            recover_failed_seed,
+            send_verified,
+            wait_for_session_ready,
+        )
 
         if not json_mode:
             print("Waiting for agent to deliver first message...")
@@ -489,14 +503,24 @@ def cmd_new(args) -> int:
             wait_for_session_ready(session_name, timeout=60)
             and send_verified(session_name, first_message)
         )
-        if not first_message_delivered and not json_mode:
-            print(f"Warning: first message not delivered to '{session_name}' — paste it manually", file=sys.stderr)
+        if not first_message_delivered:
+            first_message_fallback = recover_failed_seed(
+                session_name, first_message, sender=created_by or "agentwire"
+            )
+            if not json_mode:
+                if first_message_fallback == "inbox":
+                    print(
+                        f"WARNING: first message NOT delivered to '{session_name}' — "
+                        "queued to its msg inbox for delivery once the input box is ready",
+                        file=sys.stderr,
+                    )
+                else:
+                    print(
+                        f"WARNING: first message NOT delivered to '{session_name}' "
+                        "and could not be queued — paste it manually",
+                        file=sys.stderr,
+                    )
 
-    # Record the creating session as parent for prompt routing. --created-by
-    # overrides; empty string opts out; default = the calling tmux session.
-    created_by = getattr(args, 'created_by', None)
-    if created_by is None:
-        created_by = pane_manager.get_current_session()
     _record_session_creator(session_name, created_by, via="new")
 
     if json_mode:
@@ -509,6 +533,10 @@ def cmd_new(args) -> int:
         }
         if first_message:
             result["first_message_delivered"] = bool(first_message_delivered)
+            if not first_message_delivered:
+                # "inbox" (queued for watchdog delivery) or None (fallback
+                # failed too — the prompt is gone; caller must redeliver).
+                result["first_message_fallback"] = first_message_fallback
         _output_json(result)
     else:
         print(f"Created session '{session_name}' in {session_path}")