agentwire-dev 1.58.0__tar.gz → 1.60.0__tar.gz

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/.gitignore

@@ -45,6 +45,8 @@ Thumbs.db
 /voices/
 
 .agentwire.yml
+.agentwire.tasks.yml
+.agentwire.tasks.proposed.yml
 
 
 # Test outputs

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.58.0
+Version: 1.60.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.58.0 → agentwire_dev-1.60.0}/agentwire/__init__.py

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

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/agentwire/doctor_cli.py

@@ -357,6 +357,124 @@ def _render_voice_loop_section(config, ctx) -> int:
     return failures
 
 
+def _find_unmigrated_task_projects() -> list[str]:
+    """Local projects with an inline ``.agentwire.yml`` ``tasks:`` block but no
+    promoted ``.agentwire.tasks.yml`` (#736).
+
+    This is the concrete #720/#721 regression: the task-split relocated where
+    tasks are READ from (``.agentwire.tasks.yml``) without migrating existing
+    task DATA, so these projects' scheduled/ensure tasks silently fail (exit 6)
+    while their config still *looks* task-bearing. Returns the affected project
+    names.
+    """
+    import yaml
+
+    from . import projects as projects_mod
+    from .tasks import TASKS_FILENAME
+
+    unmigrated: list[str] = []
+    for proj in projects_mod.get_projects("local"):
+        proj_dir = Path(proj["path"])
+        cfg_file = proj_dir / ".agentwire.yml"
+        try:
+            cfg = yaml.safe_load(cfg_file.read_text()) or {}
+        except Exception:
+            continue
+        if cfg.get("tasks") and not (proj_dir / TASKS_FILENAME).exists():
+            unmigrated.append(proj["name"])
+    return unmigrated
+
+
+def _render_task_migration_section() -> int:
+    """Doctor section: flag projects whose inline tasks never migrated (#736)."""
+    unmigrated = _find_unmigrated_task_projects()
+    if not unmigrated:
+        print("  [ok] No projects with un-migrated inline tasks")
+        return 0
+    for name in unmigrated:
+        print(
+            f"  [!!] Project {name}: tasks defined in .agentwire.yml but never "
+            "migrated to .agentwire.tasks.yml — they will NOT run under "
+            "ensure/scheduler."
+        )
+    print(
+        "     Run `agentwire tasks migrate` then `agentwire tasks promote` "
+        "in each affected project."
+    )
+    return len(unmigrated)
+
+
+def _find_dead_managed_shims() -> list[dict]:
+    """Managed voice shims whose tmux session is alive but ``/health`` is dead.
+
+    The #734 failure mode: a wedged Kokoro (:8102) or Moonshine STT (:8101) shim
+    inside a live ``agentwire-kokoro``/``agentwire-stt`` session — say/transcribe
+    then silently fall back to browser voice/recognition with no error, and the
+    old session-existence-only ``ensure`` never relaunches it. Only the default
+    tier runs a managed shim, so we check that tier only, and reuse the same
+    ``_shim_session_state`` liveness predicate as ``start`` (SSOT).
+    """
+    from .config import load_config as load_config_typed
+    from .core import (
+        get_kokoro_session_name,
+        get_stt_session_name,
+        tmux_session_exists,
+    )
+    from .tts_cli import _shim_session_state
+
+    cfg = load_config_typed()
+    checks: list[tuple[str, str, int, str, str]] = []
+
+    if getattr(getattr(cfg, "tts", None), "backend", "default") == "default":
+        checks.append((
+            "Kokoro TTS", get_kokoro_session_name(), 8102,
+            "agentwire kokoro start", "say falls back to browser voice",
+        ))
+
+    if getattr(getattr(cfg, "stt", None), "backend", "default") == "default":
+        # Only the Moonshine path runs a shim; without it the default tier
+        # transcribes in the browser and there is nothing to probe.
+        from .stt import moonshine_importable
+
+        if moonshine_importable():
+            checks.append((
+                "Moonshine STT", get_stt_session_name(), 8101,
+                "agentwire stt start",
+                "transcription falls back to browser recognition",
+            ))
+
+    dead: list[dict] = []
+    for label, session, port, fix, impact in checks:
+        if not tmux_session_exists(session):
+            continue
+        live, status = _shim_session_state(session, port)
+        if not live:
+            dead.append({
+                "label": label, "session": session, "port": port,
+                "status": status, "fix": fix, "impact": impact,
+            })
+    return dead
+
+
+def _render_shim_liveness_section() -> int:
+    """Doctor section: managed shim session alive but ``/health`` dead (#734)."""
+    dead = _find_dead_managed_shims()
+    if not dead:
+        print("  [ok] No dead-but-present voice shims")
+        return 0
+    for d in dead:
+        print(
+            f"  [!!] {d['label']} shim session '{d['session']}' is alive but "
+            f":{d['port']}/health is not serving (state: "
+            f"{d['status'] or 'no response'}) — {d['impact']}."
+        )
+    print(
+        f"     Self-heal: re-run `{dead[0]['fix']}` — it is now health-aware and "
+        "reaps a dead session before relaunching."
+    )
+    return len(dead)
+
+
 def cmd_doctor(args) -> int:
     """Auto-diagnose and fix common issues."""
     from .hooks_cli import _managed_file_state, _managed_hook_files, get_hooks_source
@@ -868,6 +986,28 @@ def cmd_doctor(args) -> int:
     except Exception as e:
         print(f"  [..] Could not check for dangling worktree sessions: {e}")
 
+    # 12. Projects whose inline .agentwire.yml tasks were never migrated to the
+    # promoted .agentwire.tasks.yml (#736). The #720/#721 task-split moved where
+    # tasks are read from without migrating the data, so these tasks silently
+    # fail (exit 6) under ensure/scheduler — the exact regression that went
+    # undetected because nothing surfaced it. Loud here so it can't hide again.
+    print("\nChecking project task migration (#736)...")
+    try:
+        issues_found += _render_task_migration_section()
+    except Exception as e:
+        print(f"  [..] Could not check project task migration: {e}")
+
+    # 13. Managed voice shims (Kokoro :8102, Moonshine STT :8101) whose tmux
+    # session is alive but whose /health is dead (#734). The old
+    # session-existence-only idempotency masked a wedged engine forever, so
+    # say/transcribe silently fell back to browser voice. Surfaced distinctly
+    # here with the now-health-aware self-heal command.
+    print("\nChecking managed voice shim liveness (#734)...")
+    try:
+        issues_found += _render_shim_liveness_section()
+    except Exception as e:
+        print(f"  [..] Could not check managed voice shim liveness: {e}")
+
     # Summary
     print()
     print("-" * 60)

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/agentwire/server.py

@@ -387,10 +387,11 @@ class AgentWireServer(
         """Ensure the default-tier Moonshine shim subprocess is running.
 
         Delegates to the CLI (single source of truth): ``agentwire stt start``
-        is idempotent — ``cmd_stt_start`` early-returns if the ``agentwire-stt``
-        tmux session already exists, so a user-started shim is reused with no
-        port clash. The ~19s ONNX warm-up happens in that child process, never
-        on the portal's event loop. Mirrors ``autostart_custom_services``."""
+        is idempotent and health-aware — ``cmd_stt_start`` reuses the
+        ``agentwire-stt`` session only when it is actually serving, and reaps +
+        relaunches a dead-but-present one (#734), so a wedged shim self-heals on
+        the next ensure. The ~19s ONNX warm-up happens in that child process,
+        never on the portal's event loop. Mirrors ``autostart_custom_services``."""
         await asyncio.sleep(5)  # let the portal finish binding first
         try:
             success, result = await self.run_agentwire_cmd(["stt", "start"], json_output=False)
@@ -438,10 +439,11 @@ class AgentWireServer(
         """Ensure the default-tier Kokoro TTS shim subprocess is running.
 
         Delegates to the CLI (single source of truth): ``agentwire kokoro start``
-        is idempotent — ``cmd_kokoro_start`` early-returns if the
-        ``agentwire-kokoro`` tmux session already exists, so a user-started shim
-        is reused with no port clash. The ~200 MB download + ONNX warm-up
-        happens in that child process, never on the portal's event loop. Mirrors
+        is idempotent and health-aware — ``cmd_kokoro_start`` reuses the
+        ``agentwire-kokoro`` session only when it is actually serving, and reaps
+        + relaunches a dead-but-present one (#734), so a wedged shim self-heals
+        on the next ensure. The ~200 MB download + ONNX warm-up happens in that
+        child process, never on the portal's event loop. Mirrors
         ``ensure_managed_stt``."""
         await asyncio.sleep(5)  # let the portal finish binding first
         try:

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/agentwire/tasks_cli.py

@@ -200,6 +200,80 @@ def cmd_tasks_review(args) -> int:
     return 0
 
 
+def cmd_tasks_migrate(args) -> int:
+    """CLI command: agentwire tasks migrate [session]
+
+    One-shot data migration for the #720/#721 task-split (#736): reads the
+    inline ``tasks:`` block still living in a project's declarative
+    ``.agentwire.yml`` — now dead weight, since the executor only reads
+    ``.agentwire.tasks.yml`` — and STAGES it to the unprotected
+    ``.agentwire.tasks.proposed.yml``. It deliberately never writes the
+    protected live ``.agentwire.tasks.yml``; that is ``promote``'s host-only
+    job. The human then runs ``agentwire tasks review`` and
+    ``agentwire tasks promote``.
+    """
+    json_mode = getattr(args, "json", False)
+    project_path = _resolve_project_path(getattr(args, "session", None))
+
+    config_path = project_path / ".agentwire.yml"
+    proposed_path = project_path / PROPOSED_TASKS_FILENAME
+    active_path = project_path / TASKS_FILENAME
+
+    if not config_path.exists():
+        return _output_result(
+            False, json_mode, f"No .agentwire.yml found in {project_path}"
+        )
+
+    data, err = _load_yaml(config_path)
+    if err:
+        return _output_result(False, json_mode, err)
+
+    tasks = data.get("tasks")
+    if not tasks:
+        return _output_result(
+            False, json_mode,
+            f"No inline 'tasks:' block in {config_path.name} — nothing to migrate.",
+        )
+
+    if active_path.exists():
+        return _output_result(
+            False, json_mode,
+            f"{active_path.name} already exists — tasks look already migrated. "
+            "Refusing to clobber the live task file; reconcile it by hand if you "
+            "really mean to re-migrate.",
+        )
+
+    overwrote = proposed_path.exists()
+    proposed_path.write_text(
+        yaml.safe_dump(
+            {"tasks": tasks}, sort_keys=False, allow_unicode=True, width=100
+        )
+    )
+    ensure_gitignored(project_path, TASKS_FILENAME, ".agentwire.tasks*.yml")
+
+    lines = [
+        f"Staged {len(tasks)} task(s) from {config_path.name} -> {proposed_path.name}"
+    ]
+    if overwrote:
+        lines.append(f"(overwrote an existing {proposed_path.name})")
+    lines += [
+        "",
+        "Next:",
+        "  1. Review:  agentwire tasks review",
+        "  2. Promote: agentwire tasks promote   (host-only)",
+        "",
+        f"After promoting, delete the dead 'tasks:' block from {config_path.name} "
+        "— the executor ignores it.",
+    ]
+    return _output_result(
+        True, json_mode, "\n".join(lines),
+        project=str(project_path),
+        proposed=str(proposed_path),
+        tasks=list(tasks),
+        overwrote=overwrote,
+    )
+
+
 def cmd_tasks_promote(args) -> int:
     """CLI command: agentwire tasks promote [session] [--yes]
 
@@ -283,6 +357,20 @@ def register_tasks_parser(subparsers) -> None:
     )
     tasks_subparsers = tasks_parser.add_subparsers(dest="tasks_command")
 
+    migrate = tasks_subparsers.add_parser(
+        "migrate",
+        help="Stage a project's inline .agentwire.yml tasks: block as a draft (#736)",
+        description=(
+            "Read the inline 'tasks:' block from the project's .agentwire.yml "
+            "(dead weight since #720/#721 — the executor only reads "
+            ".agentwire.tasks.yml) and stage it to .agentwire.tasks.proposed.yml. "
+            "Then run `agentwire tasks review` and `agentwire tasks promote`."
+        ),
+    )
+    migrate.add_argument("session", nargs="?", help="Session name (default: current directory)")
+    migrate.add_argument("--json", action="store_true", help="Output JSON")
+    migrate.set_defaults(func=cmd_tasks_migrate)
+
     review = tasks_subparsers.add_parser(
         "review", help="Show the diff + every shell command in the staged draft"
     )

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/agentwire/tts_cli.py

@@ -459,19 +459,102 @@ def _resolve_shim_python() -> tuple[str | None, str | None, str | None]:
     return sys.executable, None, None
 
 
+# === Managed shim liveness (health-aware idempotency, #734) ===
+#
+# A managed voice shim (Kokoro TTS :8102, Moonshine STT :8101) runs uvicorn in
+# a tmux session and warms its model in the background. The old start path was
+# idempotent on *session existence* alone, so a dead/wedged process inside a
+# live session was treated as healthy forever — say/transcribe then silently
+# fell back to browser voice. These helpers make start/ensure health-aware:
+# reuse a session only when it is actually serving (or too young to have bound
+# its port yet); otherwise reap it and relaunch.
+
+
+def _probe_shim_health(port: int, timeout: float = 2.0) -> tuple[bool, str | None]:
+    """Probe a managed shim's ``/health`` on localhost.
+
+    Returns ``(responded, status)``: ``responded`` is True when the HTTP server
+    answered at all (even mid-warmup); ``status`` is the reported state string
+    (``ok``/``loading``/``downloading``/``absent``/``failed``/…) or None when
+    nothing answered (process dead, wedged, or the port not yet bound)."""
+    try:
+        req = urllib.request.Request(f"http://localhost:{port}/health")
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode())
+            return True, data.get("status")
+    except Exception:
+        return False, None
+
+
+def _tmux_session_age(session_name: str) -> float | None:
+    """Seconds since the tmux session was created, or None if unknowable."""
+    import time
+
+    result = subprocess.run(
+        ["tmux", "display-message", "-p", "-t", session_name, "#{session_created}"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    try:
+        return time.time() - int(result.stdout.strip())
+    except (ValueError, TypeError):
+        return None
+
+
+def _shim_session_state(
+    session_name: str, port: int, *, warmup_grace: float = 25.0
+) -> tuple[bool, str | None]:
+    """``(live, status)`` for an EXISTING managed-shim tmux session.
+
+    The single liveness predicate shared by ``start`` (reuse-vs-reap) and
+    ``doctor`` (flag-a-dead-shim). A session is *live* when its ``/health``
+    answers a non-``failed`` status, OR it is younger than ``warmup_grace`` (the
+    port may not be bound yet). A process that never answers past the grace, or
+    reports a terminal ``failed``, is NOT live. ``status`` is the ``/health``
+    state, ``"starting"`` for a still-booting young session, or None for a dead
+    one — carried through for human-readable diagnostics."""
+    responded, status = _probe_shim_health(port)
+    if responded:
+        return (status != "failed", status)
+    age = _tmux_session_age(session_name)
+    if age is not None and age < warmup_grace:
+        return (True, "starting")
+    return (False, status)
+
+
+def _reap_shim_session(session_name: str) -> None:
+    """Kill a dead shim tmux session so a fresh one can bind the port."""
+    import time
+
+    subprocess.run(["tmux", "kill-session", "-t", session_name], capture_output=True)
+    time.sleep(0.5)
+
+
 # === STT Commands ===
 
 def cmd_stt_start(args) -> int:
     """Start the STT server in tmux."""
     session_name = get_stt_session_name()
+    port = args.port or 8101
+    host = args.host or "0.0.0.0"
 
     if tmux_session_exists(session_name):
-        print(f"STT server already running in tmux session '{session_name}'")
-        print(f"  Attach: tmux attach -t {session_name}")
-        return 0
+        live, status = _shim_session_state(session_name, port)
+        if live:
+            print(f"STT server already running in tmux session '{session_name}'")
+            print(f"  Attach: tmux attach -t {session_name}")
+            return 0
+        # Session exists but :{port}/health isn't serving (dead/wedged) —
+        # self-heal by reaping and relaunching instead of masking a dead
+        # engine behind mere session existence (#734).
+        print(
+            f"STT server session '{session_name}' is present but not serving "
+            f"(state: {status or 'no response'}) — relaunching."
+        )
+        _reap_shim_session(session_name)
 
-    port = args.port or 8101
-    host = args.host or "0.0.0.0"
     config = load_config()
     stt_config = config.get("stt", {})
     model = args.model or stt_config.get("model", "base")
@@ -576,21 +659,31 @@ def cmd_stt_status(args) -> int:
 # === Kokoro (default-tier TTS shim) Commands ===
 
 def cmd_kokoro_start(args) -> int:
-    """Start the default-tier Kokoro TTS shim in tmux (idempotent).
+    """Start the default-tier Kokoro TTS shim in tmux (idempotent, health-aware).
 
     Mirrors ``agentwire stt start``: the portal's ``ensure_managed_tts`` calls
-    this on startup, and the early-return on an existing session means a
-    user-started shim is reused with no port clash."""
+    this on startup. An existing session is reused only when it is actually
+    serving (``/health`` ok/warming); a dead-but-present session is reaped and
+    relaunched so a wedged shim self-heals instead of masking forever (#734)."""
     session_name = get_kokoro_session_name()
-
-    if tmux_session_exists(session_name):
-        print(f"Kokoro TTS shim already running in tmux session '{session_name}'")
-        print(f"  Attach: tmux attach -t {session_name}")
-        return 0
-
     port = args.port or 8102
     host = args.host or "0.0.0.0"
 
+    if tmux_session_exists(session_name):
+        live, status = _shim_session_state(session_name, port)
+        if live:
+            print(f"Kokoro TTS shim already running in tmux session '{session_name}'")
+            print(f"  Attach: tmux attach -t {session_name}")
+            return 0
+        # Session exists but :{port}/health isn't serving (dead/wedged) —
+        # self-heal by reaping and relaunching instead of masking a dead
+        # engine behind mere session existence (#734).
+        print(
+            f"Kokoro TTS shim session '{session_name}' is present but not serving "
+            f"(state: {status or 'no response'}) — relaunching."
+        )
+        _reap_shim_session(session_name)
+
     # Resolve an interpreter that can run the shim: dev-checkout venv when one
     # exists, otherwise the installed package's interpreter.
     python_path, cwd, error = _resolve_shim_python()

{agentwire_dev-1.58.0 → agentwire_dev-1.60.0}/docs/wiki/scheduling/scheduled-workloads.md

@@ -23,6 +23,8 @@ Define tasks in `.agentwire.tasks.yml` (a sibling of `.agentwire.yml`, split out
 
 `.agentwire.tasks.yml` is **protected control-plane** — a policed agent can't write it directly. Authoring it is propose-and-promote: draft to `.agentwire.tasks.proposed.yml`, then a human runs `agentwire tasks review` and `agentwire tasks promote`. See [Damage control](../internals/damage-control.md#task-execution-config-split-agentwiretasksyml-720).
 
+**Legacy inline tasks are dead weight (#736).** Tasks that predate the #720/#721 split still living under a `tasks:` key in `.agentwire.yml` do **not** run — the executor reads only `.agentwire.tasks.yml`, with no runtime fallback. Migrate once: `agentwire tasks migrate` stages the inline block to `.agentwire.tasks.proposed.yml`, then `agentwire tasks review` + `agentwire tasks promote` lands it; finally delete the dead `tasks:` block from `.agentwire.yml`. `agentwire doctor` flags any project still in the un-migrated state.
+
 ```yaml
 # .agentwire.yml — declarative session config
 posture: auto    # Recommended for unattended work — see auto below

agentwire_dev-1.60.0/tests/unit/test_doctor_task_migration.py

@@ -0,0 +1,79 @@
+"""Tests for the doctor task-migration check (#736).
+
+The #720/#721 task-split relocated where tasks are READ from
+(.agentwire.tasks.yml) without migrating existing inline .agentwire.yml
+`tasks:` data, so those projects' scheduled/ensure tasks silently failed
+(exit 6). Doctor must surface exactly that state.
+"""
+
+import agentwire.projects as projects_mod
+from agentwire.doctor_cli import (
+    _find_unmigrated_task_projects,
+    _render_task_migration_section,
+)
+
+
+def _make_project(tmp_path, name, *, inline_tasks: bool, migrated: bool):
+    """Create a fake local project dir and return its get_projects() dict."""
+    proj_dir = tmp_path / name
+    proj_dir.mkdir()
+    cfg = "posture: bypass\n"
+    if inline_tasks:
+        cfg += "tasks:\n  daily:\n    prompt: do the thing\n"
+    (proj_dir / ".agentwire.yml").write_text(cfg)
+    if migrated:
+        (proj_dir / ".agentwire.tasks.yml").write_text(
+            "tasks:\n  daily:\n    prompt: do the thing\n"
+        )
+    return {"name": name, "path": str(proj_dir), "machine": "local"}
+
+
+def _patch_projects(monkeypatch, project_dicts):
+    monkeypatch.setattr(projects_mod, "get_projects", lambda machine=None: project_dicts)
+
+
+def test_flags_unmigrated_project(tmp_path, monkeypatch):
+    p = _make_project(tmp_path, "daily-book-report", inline_tasks=True, migrated=False)
+    _patch_projects(monkeypatch, [p])
+    assert _find_unmigrated_task_projects() == ["daily-book-report"]
+
+
+def test_clean_once_migrated(tmp_path, monkeypatch):
+    p = _make_project(tmp_path, "daily-book-report", inline_tasks=True, migrated=True)
+    _patch_projects(monkeypatch, [p])
+    assert _find_unmigrated_task_projects() == []
+
+
+def test_project_without_inline_tasks_not_flagged(tmp_path, monkeypatch):
+    p = _make_project(tmp_path, "no-tasks", inline_tasks=False, migrated=False)
+    _patch_projects(monkeypatch, [p])
+    assert _find_unmigrated_task_projects() == []
+
+
+def test_mixed_fleet_reports_only_unmigrated(tmp_path, monkeypatch):
+    projects = [
+        _make_project(tmp_path, "broken", inline_tasks=True, migrated=False),
+        _make_project(tmp_path, "fixed", inline_tasks=True, migrated=True),
+        _make_project(tmp_path, "plain", inline_tasks=False, migrated=False),
+    ]
+    _patch_projects(monkeypatch, projects)
+    assert _find_unmigrated_task_projects() == ["broken"]
+
+
+def test_render_section_flags_and_counts(tmp_path, monkeypatch, capsys):
+    p = _make_project(tmp_path, "daily-book-report", inline_tasks=True, migrated=False)
+    _patch_projects(monkeypatch, [p])
+    count = _render_task_migration_section()
+    out = capsys.readouterr().out
+    assert count == 1
+    assert "daily-book-report" in out
+    assert "will NOT run under ensure/scheduler" in out
+    assert "agentwire tasks migrate" in out
+
+
+def test_render_section_ok_when_clean(tmp_path, monkeypatch, capsys):
+    p = _make_project(tmp_path, "fixed", inline_tasks=True, migrated=True)
+    _patch_projects(monkeypatch, [p])
+    count = _render_task_migration_section()
+    assert count == 0
+    assert "No projects with un-migrated inline tasks" in capsys.readouterr().out