agentwire-dev 1.62.0__tar.gz → 1.64.0__tar.gz

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.62.0
+Version: 1.64.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.62.0 → agentwire_dev-1.64.0}/agentwire/__init__.py

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

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/config.py

@@ -13,6 +13,14 @@ from typing import Optional
 
 import yaml
 
+# Gitignored files a fresh git worktree needs seeded — a worktree can't load
+# its session/task config without them. Single source of truth: referenced
+# by WorktreesConfig's default below, the config-loading fallback further
+# down, AND worktree.py's mandatory (never-omittable) seed set (#803) — a
+# stale `copy_files:` in a user's config.yaml that predates one of these
+# being added here must not silently drop it from every fresh worktree.
+DEFAULT_WORKTREE_COPY_FILES = [".env", ".agentwire.yml", ".agentwire.tasks.yml"]
+
 
 def _get_default_agent_command() -> str:
     """Get the default agent command.
@@ -105,7 +113,7 @@ class WorktreesConfig:
     # tasks can't load their session/task config without them when the project
     # gitignores them (the latter is the protected, host-authored task-exec file —
     # #720).
-    copy_files: list = field(default_factory=lambda: [".env", ".agentwire.yml", ".agentwire.tasks.yml"])
+    copy_files: list = field(default_factory=lambda: list(DEFAULT_WORKTREE_COPY_FILES))
 
 
 @dataclass
@@ -623,7 +631,7 @@ def _dict_to_config(data: dict) -> Config:
         enabled=worktrees_data.get("enabled", True),
         suffix=worktrees_data.get("suffix", "-worktrees"),
         auto_create_branch=worktrees_data.get("auto_create_branch", True),
-        copy_files=worktrees_data.get("copy_files", [".env", ".agentwire.yml", ".agentwire.tasks.yml"]),
+        copy_files=worktrees_data.get("copy_files", list(DEFAULT_WORKTREE_COPY_FILES)),
     )
     projects = ProjectsConfig(
         dir=projects_data.get("dir", "~/projects"),

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/doctor_cli.py

@@ -19,6 +19,7 @@ import shutil
 import socket
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 from .core import (
@@ -475,6 +476,75 @@ def _render_shim_liveness_section() -> int:
     return len(dead)
 
 
+def _scheduler_daemon_started_at() -> float | None:
+    """Epoch seconds the scheduler daemon process started, or ``None`` if not running.
+
+    Reads the daemon's own self-reported ``started_at`` from the live-state
+    file it already writes every loop tick (``scheduler/loop.py`` ->
+    ``_write_live_state`` -> ``read_live_state()``) rather than reimplementing
+    process-start-time discovery via ``ps``/``pgrep`` PID matching, which is
+    both platform-fragile (``ps`` elapsed-time output format varies) and
+    ambiguous if a stray/duplicate daemon process happens to be running.
+    ``tmux_session_exists`` confirms the daemon is actually alive, so a
+    leftover live-state file from a since-stopped daemon doesn't produce a
+    false "stale" reading.
+    """
+    from .scheduler import SCHEDULER_SESSION, read_live_state
+
+    if not tmux_session_exists(SCHEDULER_SESSION):
+        return None
+    state = read_live_state()
+    if not state:
+        return None
+    started_at = state.get("started_at")
+    if not started_at:
+        return None
+    try:
+        from datetime import datetime
+        return datetime.fromisoformat(started_at).timestamp()
+    except (ValueError, TypeError):
+        return None
+
+
+def _newest_installed_source_mtime(pkg_dir: Path | None = None) -> float:
+    """Newest mtime among the installed ``agentwire`` package's ``.py`` files."""
+    if pkg_dir is None:
+        pkg_dir = Path(__file__).resolve().parent
+    try:
+        return max((f.stat().st_mtime for f in pkg_dir.rglob("*.py")), default=0.0)
+    except Exception:
+        return 0.0
+
+
+def _render_scheduler_staleness_section() -> int:
+    """Doctor section: flag a scheduler daemon older than the installed code (#803).
+
+    ``agentwire scheduler serve`` is a long-running Python process — like the
+    MCP server, it imports its modules once at start and never re-reads them.
+    ``agentwire rebuild`` updates the on-disk package but can't touch an
+    already-running interpreter's loaded bytecode, so a daemon that has been
+    up since before the last rebuild is silently executing stale dispatch
+    logic: any bug fixed since then stays live in production until the
+    daemon is restarted.
+    """
+    started_at = _scheduler_daemon_started_at()
+    if started_at is None:
+        print("  [..] Scheduler daemon not running — skipping staleness check")
+        return 0
+
+    newest_src = _newest_installed_source_mtime()
+    if not newest_src or newest_src <= started_at:
+        print("  [ok] Scheduler daemon is current with the installed package")
+        return 0
+
+    age_days = (time.time() - started_at) / 86400
+    print(f"  [!!] Scheduler daemon has been running {age_days:.1f}d — "
+          "predates the most recent `agentwire rebuild`")
+    print("       Any dispatch bug fixed since then is still live in the running daemon.")
+    print("       Fix: agentwire scheduler stop && agentwire scheduler start")
+    return 1
+
+
 def cmd_doctor(args) -> int:
     """Auto-diagnose and fix common issues."""
     from .hooks_cli import _managed_file_state, _managed_hook_files, get_hooks_source
@@ -653,6 +723,14 @@ def cmd_doctor(args) -> int:
         else:
             print("  [ok] Local main up to date with origin/main")
 
+    # 4d. Scheduler daemon staleness — the daemon is a long-running process
+    # that never re-imports its code, so it can silently run a dispatch bug
+    # that's since been fixed on disk (#803). Distinct from the git-drift
+    # check above: that flags an out-of-date CHECKOUT, this flags a
+    # currently-running PROCESS that predates the last install.
+    print("\nChecking scheduler daemon freshness...")
+    issues_found += _render_scheduler_staleness_section()
+
     # Check custom services (registry-driven: built-in notifications bridge
     # + user-defined services from services.custom)
     print("\nChecking custom services...")

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/bash-tool-damage-control.py

@@ -613,8 +613,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -629,6 +629,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/edit-tool-damage-control.py

@@ -609,8 +609,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -625,6 +625,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/mcp-tool-damage-control.py

@@ -621,8 +621,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -637,6 +637,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/read-tool-damage-control.py

@@ -615,8 +615,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -631,6 +631,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/hooks/damage-control/write-tool-damage-control.py

@@ -608,8 +608,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -624,6 +624,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/safety/_core.py

@@ -577,8 +577,8 @@ def load_config(
 # dispatch by the scheduler), the hook resolves ``ask`` by FAILING CLOSED:
 # block + notify the owner, UNLESS the matched rule's stable ID is on the
 # allowlist. The allowlist is the union of:
-#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (tight — work + open a PR, nothing
-#      irreversible or outward-facing),
+#   1. ``DEFAULT_UNATTENDED_ALLOW`` below (work + open a PR + notify the owner
+#      by email — nothing else irreversible or outward-facing),
 #   2. ``safety.unattended_allow`` from global / project config,
 #   3. ``AGENTWIRE_UNATTENDED_ALLOW`` (comma-separated) — the per-task
 #      extension the scheduler stamps from a task's ``unattended_allow``.
@@ -593,6 +593,7 @@ DEFAULT_UNATTENDED_ALLOW = {
     "git.commit",    # commit
     "git.push",      # push (force/delete are SEPARATE hard-block/ask rules)
     "gh.pr-create",  # open a PR — the human-reviewed gate
+    "outbound.agentwire-email",  # blanket allow, any recipient (#804)
 }
 
 

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/scheduler/gates.py

@@ -46,7 +46,25 @@ def _check_gate(board, task_name: str) -> bool:
     project = task.project
 
     def _gate_skip(gate_type: str, reason: str, **extra):
-        """Record a gate skip, only logging on first occurrence."""
+        """Record a gate skip. Logs only on first occurrence (spam control),
+        but persists ``last_gate_skip`` on every REASON CHANGE.
+
+        Distinct from ``_gate_error`` below: this is the CLEAN "not ready
+        yet" path (e.g. a ``command`` gate legitimately returning nonzero),
+        not an exception. Recorded so the board can show "waiting on gate"
+        instead of reading as silently-falling-behind overdue (#803).
+        Persisting on reason-change (not just first-occurrence, which
+        ``_gated_tasks`` alone gates) matters for multi-condition gates: if
+        task's blocker shifts from ``git_commit`` to ``command`` without the
+        gate ever fully passing in between, ``task_name`` never leaves
+        ``_gated_tasks``, so a first-occurrence-only write would leave the
+        board showing the ORIGINAL, now-stale reason.
+        """
+        skip_text = f"{gate_type}: {reason}"
+        if state.last_gate_skip != skip_text:
+            state.last_gate_skip = skip_text
+            board.state[task_name] = state
+            _sched.save_board(board)
         if task_name not in _gated_tasks:
             _sched._log_event("task_gated", task=task_name, gate_type=gate_type,
                               reason=reason, **extra)
@@ -69,6 +87,7 @@ def _check_gate(board, task_name: str) -> bool:
             print(f"[{_ts()}] Gate error on {task_name}: {gate_type} "
                   f"({reason}) — failing open")
             state.last_gate_error = f"{gate_type}: {reason}"
+            state.last_gate_skip = ""  # failing open — no longer "waiting on gate"
             board.state[task_name] = state
             _sched.save_board(board)
         _gated_tasks.discard(task_name)
@@ -131,16 +150,20 @@ def _check_gate(board, task_name: str) -> bool:
 
 
 def _clear_gate_error(board, task_name: str) -> None:
-    """Clear a previously-recorded gate error once the gate evaluates cleanly.
+    """Clear a previously-recorded gate error/skip once the gate evaluates cleanly.
 
-    No-op (and no board write) unless this task actually had an error, so
-    the common clean path stays cheap.
+    No-op (and no board write) unless this task actually had something
+    recorded, so the common clean path stays cheap. Clears BOTH
+    ``last_gate_error`` (exception path) and ``last_gate_skip`` (clean
+    "not ready yet" path, #803) — both are stale the moment the gate passes.
     """
     from agentwire import scheduler as _sched
 
     state = board.state.get(task_name)
     had_tracked = _gate_errored.pop(task_name, None) is not None
-    if had_tracked or (state is not None and state.last_gate_error):
-        if state is not None and state.last_gate_error:
+    had_state = state is not None and (state.last_gate_error or state.last_gate_skip)
+    if had_tracked or had_state:
+        if state is not None and (state.last_gate_error or state.last_gate_skip):
             state.last_gate_error = ""
+            state.last_gate_skip = ""
             _sched.save_board(board)

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/scheduler/models.py

@@ -89,6 +89,7 @@ class TaskState:
     run_count: int = 0
     last_summary: str = ""
     last_gate_error: str = ""     # last gate-eval exception reason (failed open)
+    last_gate_skip: str = ""      # currently-blocking gate reason (clean skip, not an error)
     last_gate_commit: str = ""    # HEAD at last dispatch (for gate checks)
     last_dispatch: datetime | None = None  # set BEFORE running (restart safety)
     # Active worktree-PR tracking (set on finalize, cleared by the reaper on

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/scheduler/report.py

@@ -199,6 +199,8 @@ def get_board_display(board: Board) -> list[dict]:
             row["last_summary"] = state.last_summary
         if state.last_gate_error:
             row["last_gate_error"] = state.last_gate_error
+        if state.last_gate_skip:
+            row["last_gate_skip"] = state.last_gate_skip
         rows.append(row)
 
     # Sort: enabled first, then by overdue (most overdue first)

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/scheduler/state.py

@@ -112,6 +112,7 @@ def load_board() -> Board:
                 run_count=int(s.get("run_count", 0)),
                 last_summary=str(s.get("last_summary", "")),
                 last_gate_error=str(s.get("last_gate_error", "")),
+                last_gate_skip=str(s.get("last_gate_skip", "")),
                 last_gate_commit=str(s.get("last_gate_commit", "")),
                 last_dispatch=_parse_datetime_field(s.get("last_dispatch")),
                 worktree_branch=str(s.get("worktree_branch", "")),
@@ -163,6 +164,8 @@ def _state_to_dict(board: Board) -> dict:
             entry["last_summary"] = s.last_summary
         if s.last_gate_error:
             entry["last_gate_error"] = s.last_gate_error
+        if s.last_gate_skip:
+            entry["last_gate_skip"] = s.last_gate_skip
         if s.last_gate_commit:
             entry["last_gate_commit"] = s.last_gate_commit
         if s.last_dispatch:

{agentwire_dev-1.62.0 → agentwire_dev-1.64.0}/agentwire/scheduler_cli.py

@@ -148,7 +148,7 @@ def _recent_activity(events: list[dict], limit: int = 5) -> list[dict]:
     glance at `scheduler status` shows recent results — including the
     fail-open gate errors that used to vanish entirely.
     """
-    keep = {"task_completed", "task_failed", "gate_error"}
+    keep = {"task_completed", "task_failed", "gate_error", "task_gated"}
     out: list[dict] = []
     for evt in reversed(events):
         etype = evt.get("event")
@@ -165,6 +165,8 @@ def _recent_activity(events: list[dict], limit: int = 5) -> list[dict]:
             detail = f"{status}" + (f" — {summary}" if summary else "")
         elif etype == "task_failed":
             detail = "failed — " + (evt.get("summary") or evt.get("reason") or "?")
+        elif etype == "task_gated":
+            detail = f"[gated] {evt.get('gate_type', '?')}: {evt.get('reason', '?')}"
         else:  # gate_error
             detail = f"[gate-error] {evt.get('gate_type', '?')}: {evt.get('reason', '?')}"
         if len(detail) > 80:
@@ -254,10 +256,14 @@ def cmd_scheduler_board(args) -> int:
             )
 
             # Surface WHY: a gate-eval error (fail-open, would otherwise be
-            # invisible) takes precedence; else the summary behind a bad status.
+            # invisible) takes precedence; then a currently-blocking gate
+            # (so "+4h11m" reads as "waiting on gate", not silently falling
+            # behind, #803); else the summary behind a bad status.
             detail = ""
             if r.get("last_gate_error"):
                 detail = f"[gate-error] {r['last_gate_error']}"
+            elif r.get("last_gate_skip"):
+                detail = f"[gated] {r['last_gate_skip']}"
             elif status_str in _BAD_STATUSES and r.get("last_summary"):
                 detail = r["last_summary"]
             if detail: