agentwire-dev 1.61.0__tar.gz → 1.63.0__tar.gz

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.61.0
+Version: 1.63.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.61.0 → agentwire_dev-1.63.0}/agentwire/__init__.py

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

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/core.py

@@ -740,6 +740,54 @@ def _record_session_creator(session_name: str, created_by: str | None, via: str)
     store_session_metadata(session_name, metadata)
 
 
+def _record_session_role(session_name: str, role: str | None) -> None:
+    """Record the session's ROLE axis (orchestrator/worker) to disk (merge-preserving).
+
+    Distinct from the etiquette/persona ``roles:`` list in ``.agentwire.yml`` —
+    this is the fundamental authority axis derived at creation time (``kind``
+    in cmd_new, ``effective_kind`` in cmd_worktree, "worker" for cmd_spawn).
+    Read back by list_local_sessions() and the session_created notify lookup.
+    """
+    if not role:
+        return
+    metadata = load_session_metadata(session_name)
+    metadata["role"] = role
+    store_session_metadata(session_name, metadata)
+
+
+def notify_portal_session_created(session_name: str, parent: str | None, role: str | None) -> None:
+    """Tell the portal a session was just created, with topology context (#747).
+
+    Fires immediately from the creating process instead of relying solely on
+    the global tmux ``session-created`` hook, which only knows the bare
+    session name (no parent/role) and can race a slow first-message delivery
+    before metadata is written. Fire-and-forget — failures are silently
+    ignored since the portal may not be running.
+    """
+    import ssl
+
+    payload: dict = {"event": "session_created", "session": session_name}
+    if parent:
+        payload["parent"] = parent
+    if role:
+        payload["role"] = role
+
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+        req = urllib.request.Request(
+            f"{_default_portal_url()}/api/notify",
+            data=json.dumps(payload).encode(),
+            headers={"Content-Type": "application/json", **_portal_auth_headers()},
+            method="POST",
+        )
+        urllib.request.urlopen(req, timeout=3, context=ctx)
+    except Exception:
+        pass
+
+
 def _display_parent(session_name: str, path: str = "") -> "str | None":
     """The session that should visually own this one in the sidebar.
 

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/mcp_worktree.py

@@ -225,6 +225,7 @@ def worktree_remove(
     project_dir: str = "",
     keep_branch: bool = False,
     force_delete_branch: bool = False,
+    close_pr_branch: bool = False,
 ) -> str:
     """Tear down a worktree session: kill the session, remove the worktree + branch, unregister.
 
@@ -245,7 +246,12 @@ def worktree_remove(
         project_dir: Path to the git repo (default: server cwd).
         keep_branch: Skip branch cleanup entirely (leave the branch as-is).
         force_delete_branch: Delete the branch even if not confirmed merged —
-            use only when you're sure the work is safe to discard.
+            use only when you're sure the work is safe to discard. Still
+            refuses a branch with an OPEN PR (deleting it would silently
+            close the PR) unless close_pr_branch is also set.
+        close_pr_branch: Combined with force_delete_branch, also delete a
+            branch that has an OPEN PR, closing it. Explicit escape hatch —
+            only set this when you mean to close that PR.
 
     Returns:
         Success message describing what was removed, or a loud failure
@@ -258,6 +264,8 @@ def worktree_remove(
         args += ["--keep-branch"]
     if force_delete_branch:
         args += ["--force-delete-branch"]
+    if close_pr_branch:
+        args += ["--close-pr-branch"]
     data = run_agentwire_cmd(args)
     session = data.get("session", name)
     killed = " (killed live session)" if data.get("killed") else ""

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/pane_cli.py

@@ -37,6 +37,7 @@ from .core import (
     build_agent_command,
     inject_session_env,
     load_config,
+    load_session_metadata,
     parse_env_args,
     tmux_session_exists,
 )
@@ -172,6 +173,7 @@ def list_local_sessions(show_context: bool = False) -> list[dict]:
             "posture": cfg.get("posture"),
             "roles": cfg.get("roles", []),
             "parent": _display_parent(parts[0], path),
+            "role": load_session_metadata(parts[0]).get("role"),
         }
         if usage_limit_parked(parts[0]):
             session_info["usage_limit"] = True

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/routes/notify.py

@@ -66,9 +66,20 @@ class NotifyRoutesMixin:
                 await self.broadcast_dashboard("sessions_update", {"sessions": sessions_data})
 
             elif event == "session_created":
+                # #747: name/parent/role travel in the payload when the
+                # creating process (cmd_new et al.) posts this explicitly —
+                # that's authoritative, no race. The bare global tmux hook
+                # (session-created, any tmux session) carries only the name,
+                # so fall back to a fresh lookup for that case (metadata may
+                # not be written yet on a very fast reattach — best-effort).
                 self._invalidate_session_caches()
-                await self.broadcast_dashboard("session_created", {"session": session})
                 sessions_data = await self._get_sessions_data()
+                entry = next((s for s in sessions_data if s.get("name") == session), None)
+                parent = data.get("parent") or (entry.get("parent") if entry else None)
+                role = data.get("role") or (entry.get("role") if entry else None)
+                await self.broadcast_dashboard("session_created", {
+                    "session": session, "name": session, "parent": parent, "role": role,
+                })
                 await self.broadcast_dashboard("sessions_update", {"sessions": sessions_data})
 
             elif event == "pane_died":

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/routes/projects.py

@@ -379,6 +379,66 @@ class ProjectsRoutesMixin:
 
         return web.json_response({"existing": result.get("existing", [])})
 
+    async def api_worktree_cleanup(self, request: web.Request) -> web.Response:
+        """Tear down an orphaned worktree (Session HUD ghost card "Clean up").
+
+        Thin wrapper over the plain `agentwire worktree --remove` form — the
+        CLI's own merge/open-PR guard decides whether the branch is also
+        deleted; this never escalates to --force-delete-branch.
+
+        Body: {"name": "<branch or session>", "project": "/path/to/repo"}
+        Returns whatever the CLI returns verbatim: on success
+        {success, session, path, killed, worktree_removed, branch,
+        branch_deleted, branch_note, orphaned_tabs}; on failure
+        {success: false, error}.
+        """
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({"success": False, "error": "Invalid JSON body"}, status=400)
+
+        name = (data.get("name") or "").strip()
+        project = (data.get("project") or "").strip()
+        if not name or not project:
+            return web.json_response({"success": False, "error": "name and project are required"}, status=400)
+
+        # Thin wrapper: the git/registry/branch-safety logic lives in the CLI (SSOT).
+        success, result = await self.run_agentwire_cmd(
+            ["worktree", "--remove", name, "-p", project]
+        )
+        return web.json_response(result, status=200 if success else 400)
+
+    async def api_worktree_adopt(self, request: web.Request) -> web.Response:
+        """Spawn a session into an existing worktree (Session HUD ghost card "Adopt").
+
+        Thin wrapper over `agentwire worktree <name> -p <project> --existing
+        [--created-by <createdBy>]` — checks out the branch already on disk
+        (no new branch) and, when the dead session's recorded creator is
+        known, roots the new session under that same parent so it reports
+        back the way the original session would have.
+
+        Body: {"name": "<branch>", "project": "/path/to/repo", "createdBy": "<session>"}
+        Returns whatever the CLI returns verbatim (same shape as `agentwire new`'s
+        json — success/session/path/... — or {success: false, error}).
+        """
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({"success": False, "error": "Invalid JSON body"}, status=400)
+
+        name = (data.get("name") or "").strip()
+        project = (data.get("project") or "").strip()
+        created_by = (data.get("createdBy") or "").strip()
+        if not name or not project:
+            return web.json_response({"success": False, "error": "name and project are required"}, status=400)
+
+        args = ["worktree", name, "-p", project, "--existing"]
+        if created_by:
+            args += ["--created-by", created_by]
+
+        success, result = await self.run_agentwire_cmd(args)
+        return web.json_response(result, status=200 if success else 400)
+
 
 def register_projects_routes(server, app):
     """Wire the projects domain's routes onto ``app``."""
@@ -389,3 +449,5 @@ def register_projects_routes(server, app):
     app.router.add_get("/api/session/defaults", server.api_session_defaults)
     app.router.add_get("/api/check-path", server.api_check_path)
     app.router.add_get("/api/check-branches", server.api_check_branches)
+    app.router.add_post("/api/worktree/cleanup", server.api_worktree_cleanup)
+    app.router.add_post("/api/worktree/adopt", server.api_worktree_adopt)

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/routes/sessions_admin.py

@@ -183,10 +183,10 @@ class SessionsAdminRoutesMixin:
                 yaml_config["voice"] = voice
                 await self._write_agentwire_yaml(session_path, yaml_config, machine_id)
 
-            # Broadcast session created to dashboard clients
-            await self.broadcast_dashboard("session_created", {"session": session_name})
-            sessions_data = await self._get_sessions_data()
-            await self.broadcast_dashboard("sessions_update", {"sessions": sessions_data})
+            # No manual broadcast here (#747): the `agentwire new` subprocess
+            # just awaited above already posted the enriched session_created
+            # (name/parent/role) + sessions_update to this same portal from
+            # inside cmd_new, before returning.
 
             # Wait until the tmux pane has actually rendered something. The CLI
             # returns the moment `tmux send-keys` *queues* the agent command, so

{agentwire_dev-1.61.0 → agentwire_dev-1.63.0}/agentwire/session_cli.py

@@ -29,12 +29,14 @@ from .core import (
     _output_json,
     _output_result,
     _record_session_creator,
+    _record_session_role,
     _resolve_posture_from_args,
     _resolve_posture_or_config,
     _run_remote,
     _set_session_name_env,
     build_agent_command,
     load_config,
+    notify_portal_session_created,
     parse_env_args,
     resolve_default_created_by,
     tmux_session_exists,
@@ -504,6 +506,14 @@ def cmd_new(args) -> int:
     # into place, and start the agent (skipped when bare).
     _launch_tmux_session(session_name, session_path, agent.env, agent_cmd)
 
+    # Record creator/role and push the enriched session_created event (#747)
+    # as early as possible — before the potentially slow first-message wait
+    # below — so the portal broadcast carries real parent/role instead of
+    # racing the metadata write against the async global tmux hook.
+    _record_session_creator(session_name, created_by, via="new")
+    _record_session_role(session_name, kind)
+    notify_portal_session_created(session_name, created_by, kind)
+
     # Update project config (.agentwire.yml) - only if --persist is given.
     # Persist USER roles (--roles) only — the intrinsic etiquette and soul are
     # derived/auto-appended each run, never written into project config.
@@ -567,8 +577,6 @@ def cmd_new(args) -> int:
                         file=sys.stderr,
                     )
 
-    _record_session_creator(session_name, created_by, via="new")
-
     if json_mode:
         result = {
             "success": True,
@@ -1119,6 +1127,10 @@ def _worktree_list(args, project_path: Path, json_mode: bool) -> int:
             r["git"] = worktree_status(Path(r.get("worktree_path", "")))
         dead_msgs = inbox.list_dead(r.get("session", ""))
         r["dead_reports"] = [m.to_dict() for m in dead_msgs if m.kind in ("done", "escalation")]
+        # Recorded creator/parent (persists after the session dies) — lets a
+        # dead orphan entry still be placed in its family and re-adopted with
+        # the same reporting relationship it had before (#781 ghost cards).
+        r["created_by"] = _display_parent(r.get("session", ""), r.get("worktree_path", ""))
 
     if json_mode:
         _output_json({"success": True, "entries": rows})
@@ -1454,10 +1466,40 @@ def _branch_merge_state(project_path: Path, branch: str, base: str | None) -> st
     return "unknown"
 
 
-def _delete_branch_if_safe(project_path: Path, branch: str, base: str | None, force: bool = False) -> tuple[bool, str]:
+def _open_pr_number(project_path: Path, branch: str) -> int | None:
+    """Best-effort: the OPEN PR number for `branch`, or None if there isn't one
+    (or `gh` is unavailable/unauthenticated) — never hard-fails, matching
+    `_branch_merge_state`'s best-effort posture.
+    """
+    if not shutil.which("gh"):
+        return None
+    result = subprocess.run(
+        ["gh", "pr", "view", branch, "--json", "state,number"],
+        cwd=project_path, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return None
+    try:
+        pr = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if str(pr.get("state", "")).upper() == "OPEN":
+        return pr.get("number")
+    return None
+
+
+def _delete_branch_if_safe(
+    project_path: Path, branch: str, base: str | None, force: bool = False, close_pr_branch: bool = False,
+) -> tuple[bool, str]:
     """Best-effort local + remote branch cleanup. Never touches an unmerged branch
     unless `force` — deleting an unmerged branch would silently drop real work.
 
+    `force` bypasses the merge-state check but NOT an open PR: deleting the
+    remote head branch of an OPEN PR silently closes it (GitHub loses the head
+    ref), which is a different, more surprising destruction than "dropping
+    unmerged local work" — so it needs its own explicit override,
+    `close_pr_branch` (#756).
+
     Returns (deleted, note) — note explains a skip, or names the confirmed state
     on delete.
     """
@@ -1465,6 +1507,13 @@ def _delete_branch_if_safe(project_path: Path, branch: str, base: str | None, fo
         state = _branch_merge_state(project_path, branch, base)
         if state != "merged":
             return False, f"not confirmed merged (state={state}); kept — pass --force-delete-branch to override"
+    elif not close_pr_branch:
+        open_pr = _open_pr_number(project_path, branch)
+        if open_pr is not None:
+            return False, (
+                f"branch {branch} has OPEN PR #{open_pr} — force-deleting closes it. "
+                "Merge/close the PR first, or pass --close-pr-branch to override."
+            )
 
     local = subprocess.run(
         ["git", "-C", str(project_path), "branch", "-D", branch],
@@ -1486,6 +1535,7 @@ def _delete_branch_if_safe(project_path: Path, branch: str, base: str | None, fo
 def _teardown_entry(
     project_path: Path, worktree_dir: Path, session_name: str, worktree_path: Path,
     branch: str | None, base: str | None, *, keep_branch: bool = False, force_branch: bool = False,
+    close_pr_branch: bool = False,
 ) -> dict:
     """Core atomic teardown: force-remove the worktree + prune, kill session,
     unregister, best-effort branch cleanup. Shared by --remove and
@@ -1522,7 +1572,9 @@ def _teardown_entry(
 
     branch_deleted, branch_note = (False, "")
     if branch and not keep_branch:
-        branch_deleted, branch_note = _delete_branch_if_safe(project_path, branch, base, force=force_branch)
+        branch_deleted, branch_note = _delete_branch_if_safe(
+            project_path, branch, base, force=force_branch, close_pr_branch=close_pr_branch,
+        )
 
     # Only unregister once the dir is confirmed gone (see docstring).
     worktree_registry.unregister(project_path, session=session_name, worktree_path=worktree_path)
@@ -1561,6 +1613,7 @@ def _worktree_remove(args, project_path: Path, worktree_dir: Path, json_mode: bo
         project_path, worktree_dir, session_name, worktree_path, branch, base,
         keep_branch=getattr(args, 'keep_branch', False),
         force_branch=getattr(args, 'force_delete_branch', False),
+        close_pr_branch=getattr(args, 'close_pr_branch', False),
     )
 
     if json_mode:
@@ -2012,7 +2065,8 @@ def register_session_parser(subparsers) -> None:
                                  "remnant) — this flags a LIVE session no one is watching.")
         parser.add_argument("--remove", action="store_true", help="Atomic teardown: force-remove the worktree, kill the session, delete the branch once merged, and unregister (cleanup/recovery)")
         parser.add_argument("--keep-branch", action="store_true", help="With --remove: skip branch cleanup entirely (default: best-effort delete once confirmed merged)")
-        parser.add_argument("--force-delete-branch", action="store_true", help="With --remove: delete the branch (local + remote) even if not confirmed merged")
+        parser.add_argument("--force-delete-branch", action="store_true", help="With --remove: delete the branch (local + remote) even if not confirmed merged. Refuses if the branch has an OPEN PR (would silently close it) unless --close-pr-branch is also given")
+        parser.add_argument("--close-pr-branch", action="store_true", help="With --remove --force-delete-branch: also delete a branch that has an OPEN PR, closing it (explicit escape hatch for #756's guard)")
         parser.add_argument("--prune", action="store_true", help="Drop registry entries whose worktree is gone + git worktree prune")
         parser.add_argument("--gc-merged", action="store_true", help="Tear down (session/worktree/branch) any registered entry whose branch is confirmed merged; implies --prune (runs standalone too)")
         parser.add_argument("--all", action="store_true", help="With --list/--dangling: include worktree sessions across every repo")