agentwire-dev 1.2.0__tar.gz → 1.3.1__tar.gz

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-02-10
+
+### Added
+
+- Drag-to-tile window management for side-by-side session workflows
+- Auto-chunk long TTS messages into separate audio segments for sequential playback
+- Redesigned onboarding flow that asks 3 questions then spawns Claude for setup
+
+### Fixed
+
+- Chunk pasted terminal input to prevent PTY buffer flooding and session freezes
+- Poll summary file directly instead of relying on two-idle completion signal
+- Move TTS chunker to utils to avoid torch import in MCP server
+- Namespace task summary files by session to prevent cross-session collisions
+- Don't clear task context on ensure timeout (race condition)
+- Stale lock detection in `--wait-lock` + add `--skip-if-locked`
+- Use STT server when configured instead of always falling back to WhisperKit
+
 ## [1.2.0] - 2026-02-03
 
 ### Added
@@ -112,4 +130,6 @@ Initial public release of AgentWire.
 [1.0.0]: https://github.com/dotdevdotdev/agentwire-dev/releases/tag/v1.0.0
 
 [1.1.0]: https://github.com/dotdevdotdev/agentwire-dev/compare/v1.0.0...v1.1.0
-[Unreleased]: https://github.com/dotdevdotdev/agentwire-dev/compare/v1.1.0...HEAD
+[1.2.0]: https://github.com/dotdevdotdev/agentwire-dev/compare/v1.1.0...v1.2.0
+[1.3.0]: https://github.com/dotdevdotdev/agentwire-dev/compare/v1.2.0...v1.3.0
+[Unreleased]: https://github.com/dotdevdotdev/agentwire-dev/compare/v1.3.0...HEAD

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.2.0
+Version: 1.3.1
 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.2.0 → agentwire_dev-1.3.1}/agentwire/__init__.py

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

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/agentwire/__main__.py

@@ -331,6 +331,32 @@ def tmux_session_exists(name: str) -> bool:
     return result.returncode == 0
 
 
+def _get_session_project_path(session: str) -> Path | None:
+    """Get a session's project path from its tmux working directory.
+
+    Queries tmux for the session's actual working directory. Falls back to
+    deriving it from the session name if the session isn't running.
+
+    Returns:
+        Path to the project directory, or None if not determinable.
+    """
+    # Try to get the actual working directory from tmux
+    if tmux_session_exists(session):
+        result = subprocess.run(
+            ["tmux", "display-message", "-t", session, "-p", "#{pane_current_path}"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return Path(result.stdout.strip())
+
+    # Fallback: derive from session name
+    config = load_config()
+    projects_dir = Path(config.get("projects", {}).get("dir", "~/projects")).expanduser()
+    project, _, _ = parse_session_name(session)
+    return projects_dir / project
+
+
 def tmux_session_has_agent(name: str) -> bool:
     """Check if a tmux session has an agent running (not just a bare shell).
 
@@ -991,11 +1017,11 @@ def _start_tts_local(args, venv_override: str | None = None) -> int:
         print(f"Create it with: cd {source_dir} && uv venv {venv_name}", file=sys.stderr)
         return 1
 
-    # Build command with venv
+    # Build command using venv python directly (avoids broken activate scripts and conda interference)
+    venv_python = source_dir / venv_name / "bin" / "python"
     tts_cmd = (
         f"cd {source_dir} && "
-        f"source {venv_name}/bin/activate && "
-        f"python -m agentwire tts serve --host {host} --port {port} --backend {backend} --venv {venv}"
+        f"{venv_python} -m agentwire tts serve --host {host} --port {port} --backend {backend} --venv {venv}"
     )
 
     print(f"Starting TTS server on {host}:{port} (backend: {backend}, venv: {venv})...")
@@ -1991,19 +2017,27 @@ def cmd_say(args) -> int:
     _handle_voice_notifications(text, voice, args, session)
 
     # Try portal first if we have a session
+    # Portal handles chunking internally (sequential generation + broadcast)
     if session:
         portal_url = _get_portal_url()
         has_connections, actual_session = _check_portal_connections(session, portal_url)
 
         if has_connections:
-            # Send to portal - browser will play the audio
             return _remote_say(text, actual_session, portal_url)
 
-    # No portal connections (or no session) - generate locally
-    return _local_say_runpod(
-        text, voice, exaggeration, cfg_weight, tts_config,
-        backend=backend, instruct=instruct, language=language, stream=stream
-    )
+    # No portal connections — chunk locally for better TTS quality
+    from .utils.chunker import chunk_text
+    chunks = chunk_text(text)
+
+    for chunk in chunks:
+        result = _local_say_runpod(
+            chunk, voice, exaggeration, cfg_weight, tts_config,
+            backend=backend, instruct=instruct, language=language, stream=stream
+        )
+        if result != 0:
+            return result
+
+    return 0
 
 
 def cmd_alert(args) -> int:
@@ -5074,7 +5108,7 @@ def cmd_init(args) -> int:
         # Quick mode: run wizard but skip agentwire step
         # We do this by running onboarding and returning before agentwire prompt
         # The onboarding module handles this internally
-        return run_onboarding(skip_agentwire=True)
+        return run_onboarding(skip_session=True)
 
     # Default: run full wizard (ends with optional agentwire setup)
     return run_onboarding()
@@ -5408,7 +5442,7 @@ def cmd_doctor(args) -> int:
         print("     Run: agentwire hooks install")
 
     # Check Claude Code idle notification hook
-    idle_hook = CLAUDE_HOOKS_DIR / "suppress-bg-notifications.sh"
+    idle_hook = CLAUDE_HOOKS_DIR / "idle-handler.sh"
     if idle_hook.exists():
         print(f"  [ok] Idle notification hook: {idle_hook}")
     else:
@@ -6659,7 +6693,6 @@ def cmd_ensure(args) -> int:
         CompletionTimeout,
         generate_summary_filename,
         get_summary_prompt,
-        parse_summary_file,
         status_to_exit_code,
         wait_for_file,
         wait_for_idle,
@@ -6682,6 +6715,7 @@ def cmd_ensure(args) -> int:
     dry_run = getattr(args, 'dry_run', False)
     wait_lock = getattr(args, 'wait_lock', False)
     lock_timeout = getattr(args, 'lock_timeout', 60)
+    skip_if_locked = getattr(args, 'skip_if_locked', False)
     json_mode = getattr(args, 'json', False)
 
     # Parse session target
@@ -6690,14 +6724,11 @@ def cmd_ensure(args) -> int:
     if machine_id:
         return _output_result(False, json_mode, "Remote sessions not yet supported for ensure", exit_code=ENSURE_EXIT_SESSION_ERROR)
 
-    # Find project path from --project flag, or derive from session name
+    # Find project path from --project flag, or session's working directory
     if hasattr(args, 'project') and args.project:
         project_path = Path(args.project).expanduser().resolve()
     else:
-        config = load_config()
-        projects_dir = Path(config.get("projects", {}).get("dir", "~/projects")).expanduser()
-        project, branch, _ = parse_session_name(session_name)
-        project_path = projects_dir / project
+        project_path = _get_session_project_path(session)
 
     if not project_path.exists():
         return _output_result(False, json_mode, f"Project path not found: {project_path}", exit_code=ENSURE_EXIT_SESSION_ERROR)
@@ -6776,8 +6807,12 @@ def cmd_ensure(args) -> int:
                 args, session, task, ctx, shell, project_path, timeout, json_mode
             )
     except LockConflict as e:
+        if skip_if_locked:
+            return 0
         return _output_result(False, json_mode, str(e), exit_code=ENSURE_EXIT_LOCK_CONFLICT)
     except LockTimeout as e:
+        if skip_if_locked:
+            return 0
         return _output_result(False, json_mode, str(e), exit_code=ENSURE_EXIT_LOCK_CONFLICT)
 
 
@@ -6787,15 +6822,14 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
     Uses hook-based completion detection:
     1. Write task context file (tells hook a scheduled task is running)
     2. Send task prompt
-    3. Hook handles: first idle → send summary prompt, second idle → write completion signal
-    4. Wait for completion signal file
-    5. Read and parse summary
+    3. Hook handles: first idle → send summary prompt
+    4. Poll for summary file (agent writes it after receiving summary prompt)
+    5. Parse summary and return result
     """
     from .completion import (
         CompletionTimeout,
         clear_task_context,
         generate_summary_filename,
-        parse_summary_file,
         status_to_exit_code,
         wait_for_completion_signal,
         write_task_context,
@@ -6867,8 +6901,8 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
         except TemplateError as e:
             return _output_result(False, json_mode, str(e), exit_code=ENSURE_EXIT_PRE_FAILURE)
 
-        # Generate summary filename
-        summary_filename = generate_summary_filename(task.name)
+        # Generate summary filename (scoped to session to avoid collisions)
+        summary_filename = generate_summary_filename(session, task.name)
         summary_path = project_path / summary_filename
         ctx.summary_file = summary_filename
 
@@ -6880,7 +6914,7 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
         clear_task_context(session)
 
         # Write task context for hook coordination
-        # Hook will: first idle → send summary prompt, second idle → write completion signal
+        # Hook will: first idle → send summary prompt (ensure polls for summary file directly)
         write_task_context(
             session=session,
             task_name=task.name,
@@ -6889,6 +6923,18 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
             exit_on_complete=task.exit_on_complete,
         )
 
+        # Find previous summaries for this task to give the agent context
+        summary_glob = f".agentwire/task-summary-{session}-{task.name}-*.md"
+        prev_summaries = sorted(
+            project_path.glob(summary_glob),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:5]
+        if prev_summaries:
+            prompt += "\n\nPrevious task summaries (consider them when generating your output):"
+            for p in prev_summaries:
+                prompt += f"\n- {p}"
+
         if not json_mode:
             print("Sending task prompt...")
 
@@ -6897,13 +6943,20 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
 
         # Wait for completion signal from hook
         if not json_mode:
-            print("Waiting for task completion (hook-based)...")
+            print("Waiting for task completion...")
 
         try:
-            signal = wait_for_completion_signal(session, timeout=timeout)
+            signal = wait_for_completion_signal(
+                session, timeout=timeout, summary_path=summary_path
+            )
             last_status = signal.get("status", "incomplete")
+            last_summary = signal.get("summary", "")
+            ctx.status = last_status
+            ctx.summary = last_summary
         except CompletionTimeout:
-            clear_task_context(session)
+            # Don't clear task context here — the hook may still need it.
+            # Hook cleans up after itself (exit_on_complete kills session).
+            # Task context files are cleared at the START of next run.
             last_status = "incomplete"
             last_summary = "Timeout waiting for task completion"
             if attempt < max_attempts:
@@ -6916,17 +6969,6 @@ def _run_ensure_task(args, session, task, ctx, shell, project_path, timeout, jso
         # Clean up task context
         clear_task_context(session)
 
-        # Parse summary file
-        try:
-            result = parse_summary_file(summary_path)
-            last_status = result.status
-            last_summary = result.summary
-            ctx.status = result.status
-            ctx.summary = result.summary
-        except Exception as e:
-            last_status = "incomplete"
-            last_summary = f"Failed to parse summary: {e}"
-
         if not json_mode:
             print(f"Task status: {last_status}")
             if last_summary:
@@ -7070,18 +7112,13 @@ def cmd_task_list(args) -> int:
     session = getattr(args, 'session', None)
     json_mode = getattr(args, 'json', False)
 
-    # Find project path
-    config = load_config()
-    projects_dir = Path(config.get("projects", {}).get("dir", "~/projects")).expanduser()
-
+    # Find project path from session's working directory or cwd
     if session:
-        project, _, _ = parse_session_name(session)
-        project_path = projects_dir / project
+        project_path = _get_session_project_path(session)
     else:
-        # Use current directory
         project_path = Path.cwd()
 
-    if not project_path.exists():
+    if not project_path or not project_path.exists():
         return _output_result(False, json_mode, f"Project path not found: {project_path}")
 
     tasks = list_tasks(project_path)
@@ -7119,13 +7156,9 @@ def cmd_task_show(args) -> int:
         session = None
         task_name = task_arg
 
-    # Find project path
-    config = load_config()
-    projects_dir = Path(config.get("projects", {}).get("dir", "~/projects")).expanduser()
-
+    # Find project path from session's working directory or cwd
     if session:
-        project, _, _ = parse_session_name(session)
-        project_path = projects_dir / project
+        project_path = _get_session_project_path(session)
     else:
         project_path = Path.cwd()
 
@@ -7207,13 +7240,9 @@ def cmd_task_validate(args) -> int:
         session = None
         task_name = task_arg
 
-    # Find project path
-    config = load_config()
-    projects_dir = Path(config.get("projects", {}).get("dir", "~/projects")).expanduser()
-
+    # Find project path from session's working directory or cwd
     if session:
-        project, _, _ = parse_session_name(session)
-        project_path = projects_dir / project
+        project_path = _get_session_project_path(session)
     else:
         project_path = Path.cwd()
 
@@ -8003,6 +8032,7 @@ def main() -> int:
     ensure_parser.add_argument("--dry-run", action="store_true", help="Show what would execute without running")
     ensure_parser.add_argument("--wait-lock", action="store_true", help="Wait for lock instead of failing if locked")
     ensure_parser.add_argument("--lock-timeout", type=int, default=60, help="Max time to wait for lock (default: 60s)")
+    ensure_parser.add_argument("--skip-if-locked", action="store_true", help="Exit 0 silently if session is locked (for cron use cases)")
     ensure_parser.add_argument("--json", action="store_true", help="Output JSON")
     ensure_parser.set_defaults(func=cmd_ensure)
 

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/agentwire/completion.py

@@ -66,17 +66,21 @@ Status meanings:
 Write the file now."""
 
 
-def generate_summary_filename(task_name: str) -> str:
-    """Generate a timestamped summary filename.
+def generate_summary_filename(session: str, task_name: str) -> str:
+    """Generate a session-scoped timestamped summary filename.
+
+    Includes session name so multiple sessions sharing a project directory
+    don't collide on summary files or trigger false TASK-ORPHAN detection.
 
     Args:
-        task_name: Task name (for context, not used in filename currently)
+        session: tmux session name
+        task_name: Task name (for context)
 
     Returns:
-        Relative path like .agentwire/task-summary-2024-01-15T07-00-00.md
+        Relative path like .agentwire/task-summary-mysession-2024-01-15T07-00-00.md
     """
     timestamp = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-    return f".agentwire/task-summary-{timestamp}.md"
+    return f".agentwire/task-summary-{session}-{task_name}-{timestamp}.md"
 
 
 # =============================================================================
@@ -183,44 +187,28 @@ def clear_task_context(session: str) -> None:
             pass
 
 
-def write_completion_signal(session: str, status: str, summary_file: str) -> Path:
-    """Write completion signal file (called by hook).
-
-    Args:
-        session: tmux session name
-        status: Task status from summary
-        summary_file: Path to summary file
-
-    Returns:
-        Path to the completion signal file
-    """
-    TASKS_DIR.mkdir(parents=True, exist_ok=True)
-
-    signal = {
-        "completed_at": datetime.now().isoformat(),
-        "status": status,
-        "summary_file": summary_file,
-    }
-
-    complete_file = TASKS_DIR / f"{session}.complete"
-    complete_file.write_text(json.dumps(signal, indent=2))
-    return complete_file
-
-
 def wait_for_completion_signal(
     session: str,
     timeout: float = 300.0,
     poll_interval: float = 2.0,
+    summary_path: Path | None = None,
 ) -> dict:
-    """Wait for completion signal from hook.
+    """Wait for task completion by polling the summary file directly.
+
+    Primary detection: polls for the summary file the agent writes after
+    receiving the summary prompt. When found, parses it and returns the result.
+
+    Fallback: also checks for the legacy .complete signal file in case the
+    hook writes one (e.g. manual trigger).
 
     Args:
         session: tmux session name
         timeout: Maximum seconds to wait
         poll_interval: Seconds between checks
+        summary_path: Path to the summary .md file the agent will write
 
     Returns:
-        Completion signal dict with status and summary_file
+        Dict with 'status', 'summary', 'summary_file' keys
 
     Raises:
         CompletionTimeout: If timeout exceeded
@@ -229,6 +217,21 @@ def wait_for_completion_signal(
     start_time = time.time()
 
     while True:
+        # Primary: check if the agent has written the summary file
+        if summary_path and summary_path.exists() and summary_path.stat().st_size > 0:
+            # Give a moment for the file to be fully written
+            time.sleep(0.5)
+            try:
+                result = parse_summary_file(summary_path)
+                return {
+                    "status": result.status,
+                    "summary": result.summary,
+                    "summary_file": str(summary_path),
+                }
+            except CompletionError:
+                pass  # File may be partially written, retry
+
+        # Fallback: check for legacy .complete signal file
         if complete_file.exists():
             try:
                 signal = json.loads(complete_file.read_text())
@@ -397,18 +400,26 @@ def wait_for_file(
 
 
 def parse_summary_file(path: Path) -> SummaryResult:
-    """Parse a task summary file with YAML front matter.
+    """Parse a task summary file.
 
-    Expected format:
+    Supports two formats:
+
+    1. YAML front matter (from Python SYSTEM_SUMMARY_PROMPT):
         ---
         status: complete
         summary: Did the thing
         files_modified:
           - path/to/file
-        blockers: []
         ---
 
-        Additional notes here...
+    2. Markdown headings (from hook summary prompt):
+        # Task Summary
+        ## Status
+        complete
+        ## What Was Done
+        Description here
+        ## Notes
+        Extra context
 
     Args:
         path: Path to the summary file
@@ -430,9 +441,8 @@ def parse_summary_file(path: Path) -> SummaryResult:
     files_modified: list[str] = []
     blockers: list[str] = []
 
-    # Parse YAML front matter
     if content.startswith("---"):
-        # Find closing ---
+        # Parse YAML front matter format
         end_match = re.search(r"\n---\s*\n", content[3:])
         if end_match:
             yaml_content = content[3:3 + end_match.start()]
@@ -461,10 +471,31 @@ def parse_summary_file(path: Path) -> SummaryResult:
                         files_modified.append(item)
                     elif current_list == "blockers":
                         blockers.append(item)
-
-    # Validate status
+    else:
+        # Parse markdown heading format (## Status, ## What Was Done, etc.)
+        sections: dict[str, list[str]] = {}
+        current_section: str | None = None
+
+        for line in content.split("\n"):
+            stripped = line.strip()
+            heading = re.match(r"^#{1,3}\s+(.+)", stripped)
+            if heading:
+                current_section = heading.group(1).lower()
+                continue
+            if current_section and stripped:
+                sections.setdefault(current_section, []).append(stripped)
+
+        if "status" in sections:
+            status = sections["status"][0].strip().lower()
+        if "what was done" in sections:
+            summary = " ".join(sections["what was done"])
+        elif "summary" in sections:
+            summary = " ".join(sections["summary"])
+
+    # Validate status — also accept "error" as "failed"
+    if status == "error":
+        status = "failed"
     if status not in ("complete", "incomplete", "failed"):
-        # Default to incomplete if status is unrecognized
         status = "incomplete"
 
     return SummaryResult(

agentwire_dev-1.2.0/agentwire/hooks/suppress-bg-notifications.sh → agentwire_dev-1.3.1/agentwire/hooks/idle-handler.sh

@@ -190,18 +190,18 @@ complete | incomplete | error
           $AGENTWIRE send -s "$tmux_session" "$instruction" >/dev/null 2>&1 &
           echo "[$(date -Iseconds)] TASK: summary prompt sent" >> "$dlog"
         else
-          # Second+ idle: task complete, write completion signal and optionally exit
-          echo "[$(date -Iseconds)] TASK: second idle, writing completion signal" >> "$dlog"
-
-          # Write completion signal file
-          complete_file="$HOME/.agentwire/tasks/${tmux_session}.complete"
-          echo "{\"completed_at\":\"$(date -Iseconds)\",\"status\":\"complete\",\"summary_file\":\"${summary_file}\"}" > "$complete_file"
+          # Second+ idle: optionally exit session (ensure polls summary file directly)
+          echo "[$(date -Iseconds)] TASK: second idle" >> "$dlog"
 
           if [[ "$exit_on_complete" == "true" ]]; then
             echo "[$(date -Iseconds)] TASK: exit_on_complete=true, sending /exit" >> "$dlog"
             sleep 1
             $AGENTWIRE send -s "$tmux_session" "/exit" >/dev/null 2>&1
 
+            # Clean up task context file so it doesn't haunt future sessions
+            rm "$task_context_file" 2>/dev/null
+            echo "[$(date -Iseconds)] TASK: cleaned up task context" >> "$dlog"
+
             # Wait for Claude to exit, then kill the tmux session
             sleep 3
             echo "[$(date -Iseconds)] TASK: killing tmux session" >> "$dlog"
@@ -211,8 +211,9 @@ complete | incomplete | error
       ) &
     else
       # No task context file - check if this might be a scheduled task that lost its context
-      # Look for recent task summary files in the project directory
-      recent_summary=$(find "${cwd}/.agentwire" -name "task-summary-*.md" -mmin -5 2>/dev/null | head -1)
+      # Look for recent task summary files scoped to THIS session (avoids false matches
+      # when multiple sessions share the same project directory)
+      recent_summary=$(find "${cwd}/.agentwire" -name "task-summary-${tmux_session}-*.md" -mmin -5 2>/dev/null | head -1)
 
       if [[ -n "$recent_summary" ]]; then
         log "No task context but found recent summary file, cleaning up session"
@@ -222,6 +223,11 @@ complete | incomplete | error
           echo "[$(date -Iseconds)] TASK-ORPHAN: found summary at $recent_summary, exiting session" >> "$dlog"
           sleep 1
           $AGENTWIRE send -s "$tmux_session" "/exit" >/dev/null 2>&1
+
+          # Clean up orphan summary so it doesn't trigger again
+          rm "$recent_summary" 2>/dev/null
+          echo "[$(date -Iseconds)] TASK-ORPHAN: cleaned up orphan summary" >> "$dlog"
+
           sleep 3
           echo "[$(date -Iseconds)] TASK-ORPHAN: killing tmux session" >> "$dlog"
           tmux kill-session -t "$tmux_session" 2>/dev/null &

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/agentwire/locking.py

@@ -100,6 +100,15 @@ def session_lock(
                             f"Timeout waiting for lock on session '{session}' "
                             f"after {timeout:.1f}s"
                         )
+                    # Check if the lock holder is still alive
+                    holder_pid = get_lock_holder(session)
+                    if holder_pid is not None and not _is_process_running(holder_pid):
+                        # Stale lock from a dead process — clean it up
+                        remove_lock(session)
+                        # Close our current file handle (the old lock file is gone)
+                        lock_file.close()
+                        lock_file = open(lock_path, "w")
+                        continue  # Retry immediately
                     time.sleep(poll_interval)
         else:
             # Non-blocking - fail immediately if locked

{agentwire_dev-1.2.0 → agentwire_dev-1.3.1}/agentwire/mcp_server.py

@@ -588,6 +588,21 @@ def say(text: str, session: str | None = None, voice: str | None = None) -> str:
     Returns:
         Success message or error description.
     """
+    # Quick TTS health check — fail fast if server is unreachable
+    try:
+        from .config import load_config as load_typed_config
+        from .network import NetworkContext
+        import urllib.request
+
+        cfg = load_typed_config()
+        if cfg.tts.backend not in ("runpod", "none"):
+            ctx = NetworkContext.from_config()
+            tts_url = ctx.get_service_url("tts", use_tunnel=True)
+            urllib.request.urlopen(f"{tts_url}/health", timeout=3)
+    except Exception as e:
+        url = locals().get("tts_url", "unknown")
+        return f"TTS server unreachable at {url}: {e}"
+
     args = ["say"]
     if session:
         args.extend(["-s", session])
@@ -598,7 +613,11 @@ def say(text: str, session: str | None = None, voice: str | None = None) -> str:
     # Say command doesn't return JSON, run without --json
     data = run_agentwire_cmd(args, json_output=False)
     if data.get("success"):
-        return "Text queued for speech."
+        from .utils.chunker import chunk_text
+        chunks = chunk_text(text)
+        if len(chunks) > 1:
+            return f"Queued speech ({len(chunks)} chunks)."
+        return "Queued speech."
     return f"Failed to speak: {data.get('error', 'Unknown error')}"