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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.54.0
+Version: 1.56.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.56.0}/agentwire/__init__.py

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

{agentwire_dev-1.54.0 → agentwire_dev-1.56.0}/agentwire/__main__.py

@@ -268,6 +268,17 @@ Command Categories:
         "stop", help="Kill the sitting's sessions (prompt history kept)"
     )
     c_stop.add_argument("--name", help=_name_help)
+    c_stop.add_argument(
+        "--minutes", dest="minutes", action="store_true", default=None,
+        help="Render the minutes artifact (default: render when any prompt exists)",
+    )
+    c_stop.add_argument(
+        "--no-minutes", dest="minutes", action="store_false",
+        help="Skip the minutes artifact",
+    )
+    c_stop.add_argument(
+        "--synthesis", help="Synthesis for the minutes: text, or a path to a file"
+    )
     c_stop.add_argument("--json", action="store_true", help="Output JSON")
     c_stop.set_defaults(func=council_cli.cmd_council_stop)
 
@@ -332,6 +343,30 @@ Command Categories:
     c_reply.add_argument("--json", action="store_true", help="Output JSON")
     c_reply.set_defaults(func=council_cli.cmd_council_reply)
 
+    # council minutes
+    c_minutes = council_subparsers.add_parser(
+        "minutes",
+        help="Render a sitting's minutes artifact (question + takes + synthesis)",
+        description=(
+            "Deterministically renders the sitting's persisted prompt history "
+            "(question + attributed verbatim take/ack/pass replies) plus an "
+            "optional orchestrator-supplied synthesis into a self-contained "
+            "HTML artifact at ~/.agentwire/artifacts/council-<name>-minutes/, "
+            "and opens it as a portal artifact window when the portal is up. "
+            "Works for live and dismissed sittings (prompt history is kept "
+            "on stop)."
+        ),
+    )
+    c_minutes.add_argument("--name", help=_name_help)
+    c_minutes.add_argument(
+        "--prompt", help="Prompt id to render, or 'all' (default: all)"
+    )
+    c_minutes.add_argument(
+        "--synthesis", help="Synthesis: text, or a path to a file containing it"
+    )
+    c_minutes.add_argument("--json", action="store_true", help="Output JSON")
+    c_minutes.set_defaults(func=council_cli.cmd_council_minutes)
+
     return parser
 
 

{agentwire_dev-1.54.0 → agentwire_dev-1.56.0}/agentwire/channels_cli.py

@@ -57,9 +57,11 @@ def _infer_session_from_path() -> str | None:
 
     ~/projects/myapp -> myapp
     ~/projects/myapp-worktrees/feature -> myapp/feature
+    ~/worktrees/myapp/fix-bug -> myapp-fix-bug (worktree session)
     """
     cwd = Path.cwd()
     projects_dir = Path.home() / "projects"
+    worktrees_dir = Path.home() / "worktrees"
 
     try:
         rel = cwd.relative_to(projects_dir)
@@ -76,6 +78,15 @@ def _infer_session_from_path() -> str | None:
     except ValueError:
         pass
 
+    try:
+        # Worktree sessions live at ~/worktrees/<project>/<name>/ with a flat
+        # tmux session name {project}-{name}.
+        parts = cwd.relative_to(worktrees_dir).parts
+        if len(parts) >= 2:
+            return f"{parts[0]}-{parts[1]}"
+    except ValueError:
+        pass
+
     return None
 
 

{agentwire_dev-1.54.0 → agentwire_dev-1.56.0}/agentwire/config.py

@@ -84,7 +84,16 @@ class ServerConfig:
 
 @dataclass
 class WorktreesConfig:
-    """Git worktrees configuration for parallel sessions."""
+    """Git worktrees configuration for `project/branch` sessions.
+
+    Governs the legacy ``project/branch`` session layout under
+    ``~/projects/<project>-worktrees/``. Still ALIVE (#703): the scheduler's
+    worktree+PR dispatch creates its sessions via
+    ``agentwire new -s <project>/<branch>``, and ``copy_files`` seeds every
+    fresh worktree (including scheduler dispatches). Standalone
+    ``agentwire worktree`` sessions use :class:`WorktreeConfig` instead
+    (``~/worktrees/<project>/<name>/``).
+    """
 
     enabled: bool = True
     suffix: str = "-worktrees"
@@ -128,7 +137,9 @@ class WorktreeConfig:
         default_project: Repo path used when ``--project`` is omitted and
             cwd is not inside a git repo. ``None`` → infer from cwd's git
             root, else cwd.
-        worktree_dir: Where worktrees live (one dir per session).
+        worktree_dir: Root under which worktrees are created, nested per
+            project — ``<worktree_dir>/<project>/<name>/`` — mirroring
+            ``~/projects/<project>/``.
         naming: Optional branch-name template applied in default (new-branch)
             mode, e.g. ``"{user}/{slug}"`` or ``"feature-{slug}"``.
             Placeholders: ``{name}`` (raw), ``{slug}`` (slugified),

{agentwire_dev-1.54.0 → agentwire_dev-1.56.0}/agentwire/council/cli.py

@@ -16,12 +16,15 @@ recency) otherwise, and **every command echoes which sitting it acted on**.
 Subcommands:
 
 - ``start``   — spin up the orchestrator + lens soul sessions (a *sitting*)
-- ``stop``    — kill the sitting's sessions, clear state (history kept)
+- ``stop``    — kill the sitting's sessions, clear state (history kept);
+  renders the minutes artifact by default when any prompt exists (#708)
 - ``status``  — sitting + per-session liveness + open prompts
 - ``ask``     — fan a prompt out to every soul (creates the inbox first)
 - ``collect`` — block until every soul has filed take/ack/pass, or timeout
 - ``reply``   — file a soul's reply (souls run this via Bash)
 - ``list``    — every live/known sitting, oldest-first
+- ``minutes`` — render a sitting's persisted record to a standalone HTML
+  artifact (question + attributed verbatim takes + optional synthesis)
 """
 
 from __future__ import annotations
@@ -30,9 +33,10 @@ import json
 import subprocess
 import sys
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Any
 
-from agentwire.council import inbox, state
+from agentwire.council import inbox, state, view
 
 # --- output helpers -----------------------------------------------------------
 
@@ -160,6 +164,35 @@ def current_session() -> str | None:
     return pane_manager.get_current_session()
 
 
+def open_artifact_window(url: str, title: str) -> bool:
+    """Best-effort: open a rendered artifact as a portal window.
+
+    Returns True only when the portal accepted the open; a down or erroring
+    portal returns False — the artifact file exists on disk either way.
+    """
+    import os
+
+    from agentwire import core
+
+    portal = os.environ.get("AGENTWIRE_PORTAL_URL")
+    if not portal:
+        try:
+            portal = (core.load_config().get("portal", {}) or {}).get("url")
+        except Exception:
+            portal = None
+    portal = portal or core._default_portal_url()
+    try:
+        resp = core.portal_request(
+            "POST",
+            f"{portal}/api/desktop/window/open",
+            json={"type": "artifact", "url": url, "title": title},
+            timeout=5,
+        )
+        return resp.status_code == 200 and bool(resp.json().get("success"))
+    except Exception:
+        return False
+
+
 # --- targeting / resolution -----------------------------------------------------
 
 
@@ -322,6 +355,39 @@ def cmd_council_start(args) -> int:
     return _emit(args, payload, human, exit_code=0 if payload["success"] else 1, council=name)
 
 
+def _synthesis_text(value: str | None) -> str:
+    """Resolve ``--synthesis <file-or-text>``: an existing file's content,
+    else the value verbatim."""
+    if not value:
+        return ""
+    try:
+        path = Path(value).expanduser()
+        if path.is_file():
+            return path.read_text()
+    except (OSError, ValueError):
+        pass  # not a readable path — the value is the synthesis itself
+    return value
+
+
+def _render_minutes(
+    name: str, prompt_ids: list[int] | None = None, synthesis: str = ""
+) -> tuple[str | None, bool | None]:
+    """Write the minutes artifact and best-effort open it in the portal.
+
+    Returns ``(path, opened)`` — both None when the sitting has no matching
+    prompt history (nothing rendered, nothing opened).
+    """
+    from agentwire.council import minutes
+
+    path = minutes.write_minutes(name, prompt_ids, synthesis=synthesis)
+    if path is None:
+        return None, None
+    opened = open_artifact_window(
+        minutes.artifact_url(name), f"Council minutes — {name}"
+    )
+    return str(path), opened
+
+
 def cmd_council_stop(args) -> int:
     name, err = resolve_name(args)
     if err:
@@ -330,6 +396,15 @@ def cmd_council_stop(args) -> int:
     if sitting is None:
         return _emit_error(args, f"no council sitting '{name}'")
 
+    # Minutes before teardown (#708): tri-state --minutes/--no-minutes,
+    # default (None) renders exactly when any prompt history exists.
+    minutes_path: str | None = None
+    minutes_opened: bool | None = None
+    if getattr(args, "minutes", None) is not False:
+        minutes_path, minutes_opened = _render_minutes(
+            name, synthesis=_synthesis_text(getattr(args, "synthesis", None))
+        )
+
     live = list_live_sessions()
     killed: list[str] = []
     not_running: list[str] = []
@@ -340,14 +415,57 @@ def cmd_council_stop(args) -> int:
             not_running.append(session)
     state.clear_sitting(name)
 
-    payload = {"success": True, "killed": killed, "not_running": not_running}
-    return _emit(
-        args,
-        payload,
-        f"Council '{name}' stopped ({len(killed)} sessions killed). Prompt history kept.",
-        council=name,
+    payload = {
+        "success": True,
+        "killed": killed,
+        "not_running": not_running,
+        "minutes": minutes_path,
+        "minutes_opened": minutes_opened,
+    }
+    human = (
+        f"Council '{name}' stopped ({len(killed)} sessions killed). "
+        "Prompt history kept."
+    )
+    if minutes_path:
+        human += f"\nMinutes: {minutes_path}"
+    return _emit(args, payload, human, council=name)
+
+
+def cmd_council_minutes(args) -> int:
+    name, err = resolve_name(args)
+    if err:
+        return _emit_error(args, err)
+
+    available = view.available_prompt_ids(name)
+    if not available:
+        return _emit_error(args, f"council '{name}' has no prompt history to render")
+
+    prompt_arg = getattr(args, "prompt", None) or "all"
+    prompt_ids: list[int] | None = None
+    if str(prompt_arg) != "all":
+        try:
+            prompt_ids = [int(prompt_arg)]
+        except (TypeError, ValueError):
+            return _emit_error(
+                args, f"--prompt must be a prompt id or 'all', got {prompt_arg!r}"
+            )
+        if prompt_ids[0] not in available:
+            return _emit_error(
+                args,
+                f"no prompt #{prompt_ids[0]} in council '{name}' "
+                f"(available: {', '.join(map(str, available))})",
+            )
+
+    path, opened = _render_minutes(
+        name, prompt_ids, synthesis=_synthesis_text(getattr(args, "synthesis", None))
     )
 
+    payload = {"success": True, "path": path, "opened": opened}
+    human = f"Minutes: {path}"
+    if opened:
+        human += "\nOpened as a portal artifact window."
+    return _emit(args, payload, human, council=name)
+
 
 def cmd_council_status(args) -> int:
     name, err = resolve_name(args)

agentwire_dev-1.56.0/agentwire/council/minutes.py

@@ -0,0 +1,174 @@
+"""Council minutes — deterministic HTML render of a sitting's persisted record.
+
+Handoff pattern (#708): everything verbatim (the question, the attributed
+take/ack/pass replies) already persists under
+``~/.agentwire/council/<name>/prompts/NNNN/``, so the renderer is a pure
+function of disk state. The synthesis exists only in the orchestrator's
+context, so it arrives as an *input* — omitted, the minutes render without a
+synthesis section.
+
+Output is one fully self-contained HTML file (inline CSS only — the portal's
+artifact CSP blocks external fetches), theme-aware via
+``prefers-color-scheme``, at::
+
+    ~/.agentwire/artifacts/council-<name>-minutes/index.html
+
+Works for live and dismissed sittings alike — prompt history is disk-derived,
+sitting metadata falls back from ``sitting.json`` to the preserved
+``archive.json``.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import jinja2
+
+from agentwire.council import inbox, state, view
+
+# --- paths ------------------------------------------------------------------
+
+
+def artifacts_dir() -> Path:
+    """The portal artifacts root (config override honored)."""
+    try:
+        from agentwire.config import load_config
+
+        return Path(str(load_config().artifacts.dir)).expanduser()
+    except Exception:
+        return Path.home() / ".agentwire" / "artifacts"
+
+
+def minutes_path(name: str) -> Path:
+    return artifacts_dir() / f"council-{name}-minutes" / "index.html"
+
+
+def artifact_url(name: str) -> str:
+    """Path relative to the artifacts root — what the portal iframe loads."""
+    return f"council-{name}-minutes/index.html"
+
+
+# --- gather -----------------------------------------------------------------
+
+
+def _fmt_ts(iso: str) -> str:
+    """ISO timestamp → compact display form (``2026-07-04 15:38 UTC``)."""
+    if not iso:
+        return ""
+    try:
+        dt = datetime.fromisoformat(iso)
+    except (ValueError, TypeError):
+        return iso
+    suffix = " UTC" if dt.tzinfo is not None else ""
+    return dt.strftime("%Y-%m-%d %H:%M") + suffix
+
+
+def gather(name: str, prompt_ids: list[int] | None = None) -> dict | None:
+    """Collect a sitting's persisted record into a render-ready dict.
+
+    ``prompt_ids`` filters to specific rounds (None = every prompt on disk).
+    Returns ``None`` when nothing matches — a sitting that never deliberated
+    has no minutes. Reply dicts carry only content (soul, kind, text,
+    timestamp), never local filesystem paths: the artifact is built to be
+    shared.
+    """
+    available = view.available_prompt_ids(name)
+    selected = (
+        available if prompt_ids is None else [p for p in prompt_ids if p in available]
+    )
+    if not selected:
+        return None
+
+    sitting = state.read_sitting(name)
+    archived = sitting is None
+    dismissed_at = ""
+    if archived:
+        raw = state.read_archive_dict(name)
+        dismissed_at = (raw or {}).get("dismissed_at", "")
+        sitting = (
+            state.Sitting.from_dict(raw)
+            if raw is not None
+            else state.Sitting(
+                orchestrator=state.orchestrator_for(name),
+                roster=[],
+                sessions={},
+                started_at="",
+            )
+        )
+
+    prompts = []
+    for pid in selected:
+        meta = inbox.read_meta(name, pid)
+        try:
+            question = (inbox.prompt_dir(name, pid) / "prompt.md").read_text()
+        except OSError:
+            question = ""
+        replies = [
+            {
+                "soul": r.soul,
+                "kind": r.kind,
+                "text": r.text.strip(),
+                "written_at": _fmt_ts(r.written_at),
+            }
+            for r in inbox.list_replies(name, pid)
+        ]
+        prompts.append(
+            {
+                "id": pid,
+                "question": question.strip(),
+                "created_at": _fmt_ts(meta.get("created_at", "")),
+                "roster": meta.get("roster") or list(sitting.roster),
+                "replies": replies,
+            }
+        )
+
+    roster = list(sitting.roster) or prompts[0]["roster"]
+    return {
+        "name": name,
+        "archived": archived,
+        "started_at": _fmt_ts(sitting.started_at),
+        "dismissed_at": _fmt_ts(dismissed_at),
+        "roster": roster,
+        "prompts": prompts,
+    }
+
+
+# --- render -----------------------------------------------------------------
+
+
+def _env() -> jinja2.Environment:
+    # autoescape=True explicitly: select_autoescape keys off the *final*
+    # extension, and ``.html.j2`` ends in ``.j2`` — verbatim soul takes are
+    # untrusted content, so escaping must never silently switch off.
+    templates = Path(__file__).resolve().parent.parent / "templates"
+    return jinja2.Environment(
+        loader=jinja2.FileSystemLoader(str(templates)),
+        autoescape=True,
+    )
+
+
+def render_html(record: dict, synthesis: str = "") -> str:
+    template = _env().get_template("council/minutes.html.j2")
+    return template.render(
+        record=record,
+        synthesis=(synthesis or "").strip(),
+        generated_at=_fmt_ts(state.now_iso()),
+    )
+
+
+def write_minutes(
+    name: str, prompt_ids: list[int] | None = None, synthesis: str = ""
+) -> Path | None:
+    """Render and write the minutes artifact; return its path.
+
+    Returns ``None`` (writes nothing) when the sitting has no matching prompt
+    history — a zero-prompt sitting leaves no minutes behind.
+    """
+    record = gather(name, prompt_ids)
+    if record is None:
+        return None
+    out = minutes_path(name)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(render_html(record, synthesis), encoding="utf-8")
+    return out

{agentwire_dev-1.54.0 → agentwire_dev-1.56.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).