agentwire-dev 1.65.1__tar.gz → 1.65.3__tar.gz

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/PKG-INFO

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

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

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/mcp_core.py

@@ -162,11 +162,34 @@ def _delivery_result(data: dict, where: str) -> str:
     returns ``verified``: True (landed), False (sent but not seen — likely a
     busy/booting pane that dropped it), or None (remote — unverifiable across
     SSH). Surface that instead of a blind "sent".
+
+    A ``False`` verify from a *session*-level send no longer just hands the
+    problem back to whichever caller reads this string (#834) — the CLI
+    falls back to the durable msg inbox (retried across ticks, dead-lettered
+    + emailed on true exhaustion) when the direct paste can't be confirmed,
+    so report THAT outcome rather than telling the caller to notice and
+    resend by hand. A worker *pane* send has no such fallback (the msg inbox
+    only addresses sessions, not individual panes) — ``data`` won't carry a
+    ``fallback`` key at all in that case, distinguishing "not attempted"
+    from "attempted and failed" so this never claims a fallback that never
+    ran.
     """
     verified = data.get("verified")
     if verified is True:
         return f"Message delivered {where} (verified in pane)."
     if verified is False:
+        if "fallback" in data:
+            if data.get("fallback") == "already_delivered":
+                return (f"Message sent {where} — the pane confirmation was ambiguous, but the "
+                        f"message is already visible on scrollback, so it was in fact delivered. "
+                        f"No action needed.")
+            if data.get("fallback") == "inbox":
+                return (f"Message sent {where} but delivery could NOT be verified in the pane — "
+                        f"queued to its msg inbox instead, which guarantees delivery (retried "
+                        f"automatically, dead-lettered + emailed to the owner only if it truly "
+                        f"can't land). No action needed.")
+            return (f"Message sent {where} but delivery could NOT be verified, AND the msg-inbox "
+                    f"fallback also failed — this message may be lost. Check the pane or resend.")
         return (f"Message sent {where} but delivery could NOT be verified — it may "
                 f"have been dropped (busy/booting pane). Check the pane or resend.")
     if verified is None and "verified" in data:

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/mcp_session.py

@@ -227,6 +227,11 @@ def session_send(session: str, message: str) -> str:
             f"{message}"
         )
     args = ["send", "-s", session, "--verify", message]
+    if caller:
+        # Attributes a msg-inbox delivery fallback to the real caller instead
+        # of the generic "agentwire" (#835 review) — the CLI subprocess can't
+        # auto-detect the caller across the MCP boundary itself.
+        args.extend(["--caller-session", caller])
     data = run_agentwire_cmd(args)
     if not data.get("success"):
         return f"Failed to send message: {data.get('error', 'Unknown error')}"

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/routes/desktop.py

@@ -10,6 +10,22 @@ through the composed server's MRO.
 from aiohttp import web
 
 
+def _artifact_url_hash(url: str) -> str:
+    """FNV-1a 32-bit hash of ``url``, as 8 lowercase hex chars.
+
+    Must match ``artifactUrlHash`` in static/js/desktop.js byte-for-byte —
+    the server and frontend both derive the same fallback artifact id from
+    the same URL, and a naive char-substitution slug (the prior approach)
+    let distinct URLs like "reports/jan.html" and "reports-jan.html" collide
+    onto the same id. A hash isn't lossy the way substitution is.
+    """
+    h = 0x811C9DC5
+    for b in url.encode("utf-8"):
+        h ^= b
+        h = (h * 0x01000193) & 0xFFFFFFFF
+    return f"{h:08x}"
+
+
 class DesktopRoutesMixin:
     async def api_desktop_windows(self, request):
         """GET /api/desktop/windows — query browser clients for open windows."""
@@ -173,7 +189,7 @@ class DesktopRoutesMixin:
                 "url": url,
                 "title": title,
                 "artifact_id": artifact.get("artifact_id")
-                or f"artifact-{url.replace('/', '-').replace('.', '-')}",
+                or f"artifact-{_artifact_url_hash(url)}",
             }
             if not text:
                 text = f"**{title}** is ready — click to open"

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/send_cli.py

@@ -24,6 +24,60 @@ from .core import (
 )
 
 
+def _recover_unverified_send(session: str, prompt: str, sender: str) -> "str | None":
+    """Fallback when `send_verified` can't confirm delivery (#834, #835 review).
+
+    First checks whether the bare message is already on scrollback outside
+    the input box. A `send_verified` failure can mean the paste genuinely
+    never landed/submitted, OR that it fully submitted and only the
+    *confirm* read was ambiguous (an unparseable box frame, or a laggy host
+    blowing the submit budget). The msg-inbox drain's own dedup can't catch
+    the latter case on its own: it matches the WRAPPED ``[MSG from ... ]
+    ... <id>`` render (see ``inbox.Message.render``), never the bare text
+    this path pasted directly — enqueuing unconditionally would risk a real
+    duplicate delivery rather than the safe no-op the drain's dedup gives
+    its own messages. Checking here first avoids that duplicate in the
+    common case.
+
+    A message that lands only *after* this check runs (queued invisibly
+    mid-generation, per ``submit_confirmed``'s own docstring) can still
+    duplicate — accepted per this codebase's existing bias that a
+    recoverable duplicate beats a silently dropped message.
+
+    Known residual risk (#835 second-pass review): this is the same bare
+    whitespace-normalized substring match ``_deliver_once`` already uses for
+    its own internal idempotent-paste guard — not a new invention — but
+    reused here it trades in the *opposite* direction from most of this
+    file's checks. A false match reports "already delivered" and SKIPS the
+    inbox enqueue entirely: for a short or generic message (a bare "yes",
+    "continue", "approved") that happens to already sit in the last
+    ``VERIFY_SCROLLBACK_LINES`` for an unrelated reason, a send that
+    genuinely never landed could be silently dropped instead of queued —
+    the one outcome this whole fallback exists to prevent. Tracked as a
+    follow-up (a lightweight per-attempt marker, mirroring
+    ``send_verified``'s own ``marker`` param, would close this precisely);
+    not fixed here because it's strictly narrower than the bug this
+    function was written to close (needs a coincidental/repeated-text
+    match, not just any unverified send).
+
+    Returns ``"already_delivered"``, ``"inbox"``, or ``None`` (the inbox
+    fallback itself failed).
+    """
+    from agentwire.session_ready import message_on_scrollback, recover_failed_seed, scrollback
+
+    if message_on_scrollback(scrollback(session), prompt):
+        return "already_delivered"
+    return recover_failed_seed(session, prompt, sender=sender)
+
+
+def _fallback_suffix(fallback: "str | None") -> str:
+    if fallback == "already_delivered":
+        return " — already delivered directly (the confirmation read was just ambiguous); no action needed"
+    if fallback == "inbox":
+        return " — queued to its msg inbox for guaranteed delivery"
+    return " and could not be queued — resend manually"
+
+
 def cmd_send(args) -> int:
     """Send a prompt to a tmux session or pane (adds Enter automatically).
 
@@ -36,6 +90,13 @@ def cmd_send(args) -> int:
     json_mode = getattr(args, 'json', False)
     wait_ready = getattr(args, 'wait_ready', False)
     verify = getattr(args, 'verify', False)
+    # Candidate sender for a msg-inbox fallback's attribution (#835 review):
+    # prefer the real calling session over the generic "agentwire" so
+    # dead-letter emails and the rendered [MSG from ...] header stay
+    # meaningful. MCP forwards --caller-session explicitly (can't reliably
+    # auto-detect the caller across that boundary); a bare CLI invocation
+    # falls back to auto-detecting its own tmux session.
+    fallback_sender = getattr(args, 'caller_session', None) or pane_manager.get_current_session() or "agentwire"
 
     if wait_ready and pane_index is not None:
         return _output_result(False, json_mode, "--wait-ready targets a session's pane 0; it can't be combined with --pane")
@@ -173,13 +234,22 @@ def cmd_send(args) -> int:
         if not wait_for_session_ready(session, timeout=timeout):
             return _output_result(False, json_mode, f"Agent in '{session}' not ready after {timeout:.0f}s")
         if not send_verified(session, prompt):
+            # A caller acting on "not verified" text is optional, not
+            # guaranteed — under load this is exactly the class of message
+            # that must never depend on an LLM noticing and manually
+            # resending. Fall back to the durable msg inbox (retried across
+            # ticks, dead-lettered + emailed on true exhaustion) instead of
+            # returning inert advisory text (#834).
+            fallback = _recover_unverified_send(session, prompt, fallback_sender)
             if json_mode:
-                print(json.dumps({"success": False, "session": session_full, "verified": False, "error": "Delivery not verified"}))
+                print(json.dumps({"success": False, "session": session_full, "verified": False,
+                                  "fallback": fallback, "error": "Delivery not verified"}))
             else:
-                print(f"Sent to {session} but delivery could not be verified", file=sys.stderr)
+                print(f"Sent to {session} but delivery could not be verified{_fallback_suffix(fallback)}", file=sys.stderr)
             return 1
         if json_mode:
-            print(json.dumps({"success": True, "session": session_full, "machine": None, "verified": True, "message": "Prompt sent"}))
+            print(json.dumps({"success": True, "session": session_full, "machine": None,
+                              "verified": True, "fallback": None, "message": "Prompt sent"}))
         else:
             print(f"Sent to {session} (verified)")
         return 0
@@ -197,12 +267,19 @@ def cmd_send(args) -> int:
         from agentwire.session_ready import send_verified
 
         ok = send_verified(session, prompt, retries=1)
+        fallback = None
+        if not ok:
+            # Same durable fallback as --wait-ready (#834).
+            fallback = _recover_unverified_send(session, prompt, fallback_sender)
         if json_mode:
             print(json.dumps({"success": True, "session": session_full, "machine": None,
-                              "verified": ok,
+                              "verified": ok, "fallback": fallback,
                               "message": "Prompt sent" if ok else "Prompt sent but delivery could not be verified"}))
         else:
-            print(f"Sent to {session}" + (" (verified)" if ok else " (delivery NOT verified)"))
+            if ok:
+                print(f"Sent to {session} (verified)")
+            else:
+                print(f"Sent to {session} (delivery NOT verified){_fallback_suffix(fallback)}")
         return 0
 
     # Delegate paste + Enter handling to the shared pane_manager helper so
@@ -313,6 +390,11 @@ def register_send_parser(subparsers) -> None:
                                   "report verified vs unconfirmed instead of blind success")
     send_parser.add_argument("--timeout", type=float, default=30.0,
                              help="Readiness wait timeout in seconds (with --wait-ready, default: 30)")
+    send_parser.add_argument("--caller-session", dest="caller_session",
+                             help="Internal: attribute a msg-inbox delivery fallback to this sender "
+                                  "instead of auto-detecting the calling tmux session. MCP forwards "
+                                  "this explicitly, since the CLI subprocess can't reliably "
+                                  "auto-detect the caller across that boundary.")
     send_parser.add_argument("--json", action="store_true", help="Output as JSON")
     send_parser.set_defaults(func=cmd_send)
 

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/server.py

@@ -33,7 +33,7 @@ import jinja2
 import yaml
 from aiohttp import web
 
-from . import prompt_router, security
+from . import __version__, prompt_router, security
 from .cached_status import CachedStatusChecker
 from .config import Config, load_config
 from .routes.artifacts import ArtifactsRoutesMixin, register_artifacts_routes
@@ -66,8 +66,6 @@ from .security import (
 from .ssh import ssh_base_opts
 from .worktree import parse_session_name
 
-__version__ = "1.3.0"
-
 logger = logging.getLogger(__name__)
 
 # Static asset serving (#488): gzip text on the fly + Cache-Control headers.
@@ -2479,6 +2477,19 @@ class AgentWireServer(
             ["send", "-s", session_name, "--wait-ready", "--timeout", "60", "--", message]
         )
         if not success:
+            if result.get("fallback") in ("inbox", "already_delivered"):
+                # #835: an unverified send now recovers on its own -- either
+                # it was already delivered and the confirm read was just
+                # ambiguous, or it's queued to the durable msg inbox. Either
+                # way the old "paste it manually" toast would be stale,
+                # actively wrong advice.
+                logger.info(f"First message for {session_name} recovered via {result.get('fallback')} fallback")
+                await self._post_toast(
+                    f"First message to {session_name} queued for guaranteed delivery"
+                    if result.get("fallback") == "inbox" else
+                    f"First message to {session_name} delivered (confirmation was just delayed)",
+                    session=session_name, priority="normal", id_prefix="firstmsg")
+                return
             logger.warning(f"First message delivery failed for {session_name}: {result.get('error')}")
             await self._post_toast(
                 f"First message not delivered to {session_name} — paste it manually",

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/session_cli.py

@@ -62,6 +62,7 @@ from .worktree import (
     default_base_branch,
     ensure_worktree,
     git_root,
+    is_registered_worktree,
     is_valid_branch_name,
     parse_session_name,
     remove_worktree,
@@ -1561,7 +1562,17 @@ def _teardown_entry(
     Never reports worktree_removed=True while the dir is still on disk: if
     `git worktree remove --force` can't clear it, this fails LOUDLY
     (success: False) and leaves the registry entry in place, instead of
-    silently "unregistering" an orphan.
+    silently "unregistering" an orphan — UNLESS git *already had no record of
+    the path before we touched it* (see `is_registered_worktree`), in which
+    case there's no registered worktree left to protect and the leftover
+    directory (a stale build-tool cache, typically) is hard-deleted instead.
+
+    That pre-check matters: `git worktree prune` below runs unconditionally
+    and clears any entry git marks "prunable" (e.g. one whose linked `.git`
+    file was deleted) as a side effect of THIS call — checking registration
+    after prune would misread a worktree that was real and registered right
+    up until this attempt as a pre-existing orphan, and hard-delete content
+    the fail-loud path exists to protect.
 
     The worktree removal is attempted BEFORE the session is killed, and the
     session is only killed once removal is confirmed — never the reverse.
@@ -1569,10 +1580,17 @@ def _teardown_entry(
     disk with no session left to notice, on any removal failure (bad
     project_path, a stuck worktree, ...) (#740).
     """
+    was_registered = is_registered_worktree(project_path, worktree_path)
+
     # Force-remove the git worktree, then prune admin files either way.
     _, remove_error = remove_worktree(project_path, worktree_path, force=True)
     subprocess.run(["git", "-C", str(project_path), "worktree", "prune"], capture_output=True)
 
+    hard_deleted_orphan = False
+    if worktree_path.exists() and not was_registered:
+        shutil.rmtree(worktree_path, ignore_errors=True)
+        hard_deleted_orphan = not worktree_path.exists()
+
     if worktree_path.exists():
         reason = remove_error or "worktree directory still present after `git worktree remove --force`"
         return {"success": False, "session": session_name, "path": str(worktree_path),
@@ -1605,7 +1623,7 @@ def _teardown_entry(
     return {"success": True, "session": session_name, "path": str(worktree_path),
             "killed": killed, "worktree_removed": True,
             "branch": branch, "branch_deleted": branch_deleted, "branch_note": branch_note,
-            "orphaned_tabs": orphaned_tabs}
+            "orphaned_tabs": orphaned_tabs, "hard_deleted_orphan": hard_deleted_orphan}
 
 
 def _worktree_remove(args, project_path: Path, worktree_dir: Path, json_mode: bool) -> int:
@@ -1641,7 +1659,9 @@ def _worktree_remove(args, project_path: Path, worktree_dir: Path, json_mode: bo
     else:
         msg = (f"Removed worktree session '{result['session']}'"
                + (" (killed live session)" if result["killed"] else "")
-               + f"; worktree {result['path']} removed")
+               + f"; worktree {result['path']} removed"
+               + (" (git had no registration for it — hard-deleted the leftover directory)"
+                  if result.get("hard_deleted_orphan") else ""))
         if result["branch"]:
             msg += f"; branch '{result['branch']}' " + ("deleted" if result["branch_deleted"] else f"kept ({result['branch_note']})")
         if result["orphaned_tabs"]:

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/session_ready.py

@@ -590,6 +590,19 @@ def clear_input_box(session: str, pane_index: int = 0) -> bool:
     text]`` chip) and confirms emptiness with the drain's own SGR-aware gate
     (``prompt_router.prompt_is_empty``), so "cleared" here means exactly
     "the drain will deliver". Returns True iff the box ends up empty.
+
+    Refuses to press Escape while the screen shows a live select-menu/dialog
+    (#835 review): this function was written for a brand-new session's
+    failed first-message seed, where nothing else could plausibly be on
+    screen. It is also reused for an already-running, independently-busy
+    session (``agentwire send --verify`` falling back after a failed
+    delivery) — there, "box not empty" can mean a permission dialog or
+    ``AskUserQuestion`` menu belonging to the recipient's own unrelated
+    work, not our stuck paste. Escape is the conventional cancel/decline key
+    for those, so pressing it blind would silently cancel a decision that
+    had nothing to do with us. Returns False without touching the pane in
+    that case; the caller's msg-inbox fallback still gets enqueued and
+    waits for the box to become genuinely idle on its own.
     """
     from agentwire import pane_manager, prompt_router
 
@@ -602,6 +615,8 @@ def clear_input_box(session: str, pane_index: int = 0) -> bool:
         try:
             if empty():
                 return True
+            if prompt_router.screen_shows_live_menu(_snapshot(session, pane_index)):
+                return False
             pane_manager.run_command(
                 ["tmux", "send-keys", "-t", target, "Escape"], timeout=5
             )

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/static/js/desktop.js

@@ -824,6 +824,24 @@ function _mountSessionWindow(session, mode, machine, id) {
     addTaskbarButton(id, sw);
 }
 
+/**
+ * FNV-1a 32-bit hash of `url`, as 8 lowercase hex chars. Must match
+ * `_artifact_url_hash` in routes/desktop.py byte-for-byte — server and
+ * frontend both derive the same fallback artifact id from the same URL. A
+ * hash isn't lossy the way the prior char-substitution slug was (distinct
+ * URLs like "reports/jan.html" and "reports-jan.html" collided onto the
+ * same id).
+ */
+function artifactUrlHash(url) {
+    let h = 0x811c9dc5;
+    const bytes = new TextEncoder().encode(url);
+    for (const b of bytes) {
+        h ^= b;
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
+}
+
 /**
  * Open an artifact window (agent-generated HTML or external URL).
  *
@@ -832,7 +850,7 @@ function _mountSessionWindow(session, mode, machine, id) {
  * @param {string|null} artifactId - Optional explicit window ID
  */
 export function openArtifactWindow(url, title = 'Artifact', artifactId = null) {
-    const id = artifactId || `artifact-${url.replace(/[\/\.]/g, '-')}`;
+    const id = artifactId || `artifact-${artifactUrlHash(url)}`;
 
     // Check if already open — restore if minimized, otherwise focus
     if (artifactWindows.has(id)) {

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/static/js/notifications-panel.js

@@ -86,10 +86,19 @@ class NotificationsPanel {
             this._removeToast(id, false);
         }
 
-        // Evict oldest if at capacity
+        // Evict the oldest toast NOT carrying an artifact notice, if at
+        // capacity. Artifact toasts are exempt regardless of priority: an
+        // unclicked deliverable must not silently fade (#817) — the cap
+        // only trims ordinary toasts (sticky `high`-priority ones included).
+        // If every current toast is an artifact notice, the panel
+        // temporarily exceeds MAX_TOASTS rather than dropping one.
         if (this.toasts.size >= MAX_TOASTS) {
-            const oldest = this.toasts.keys().next().value;
-            this._removeToast(oldest, false);
+            for (const id of this.toasts.keys()) {
+                if (!this.artifactNotices.has(id)) {
+                    this._removeToast(id, false);
+                    break;
+                }
+            }
         }
 
         // Resolve auto-fade: explicit timeout wins (0 = sticky); otherwise

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/agentwire/worktree.py

@@ -309,6 +309,39 @@ def remove_worktree(project_path: Path, worktree_path: Path, *, force: bool = Tr
     return False, (result.stderr or result.stdout).strip()
 
 
+def is_registered_worktree(project_path: Path, worktree_path: Path) -> bool:
+    """Does git's own worktree registry (still) know about ``worktree_path``?
+
+    A directory can outlive its registration — e.g. `git worktree remove`
+    succeeded on a prior teardown attempt but the `rm -rf` half crashed
+    before clearing a build-tool cache dir left inside, or the admin file
+    under `.git/worktrees/` was pruned independently. In that state git
+    reports "fatal: ... is not a working tree" for every future removal
+    attempt, forever — this lets a caller distinguish that from a real
+    registered worktree that `remove --force` merely failed to clear. It
+    says nothing about whether the directory holds valuable content — that
+    judgment (e.g. "orphaned + unregistered is safe to hard-delete") belongs
+    to the caller, not this function.
+
+    Fails closed on an inconclusive read: if `git worktree list` itself
+    errors (corrupt repo, I/O, lock contention), that's reported as
+    registered rather than not — a caller gating a destructive action on
+    this should default to "assume real" when unsure, not "assume orphan".
+    """
+    result = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=project_path, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return True
+    target = str(worktree_path.resolve())
+    for line in result.stdout.splitlines():
+        if line.startswith("worktree "):
+            if str(Path(line[len("worktree "):]).resolve()) == target:
+                return True
+    return False
+
+
 def worktree_status(worktree_path: Path) -> dict:
     """Read-only git status for a worktree. Local git only — no network, no gh.
 

{agentwire_dev-1.65.1 → agentwire_dev-1.65.3}/tests/integration/test_worktree_cmd.py

@@ -643,6 +643,38 @@ def test_remove_fails_loudly_when_dir_survives(tmp_path, monkeypatch, wt_env, ca
     assert payload["error"]
 
 
+def test_remove_hard_deletes_unregistered_orphan_directory(tmp_path, monkeypatch, wt_env, capsys):
+    """A directory git no longer registers as a worktree at all (its
+    `.git/worktrees/<name>` admin entry is gone, e.g. from a prior teardown
+    that crashed mid-way) must not get stuck failing `git worktree remove`
+    forever — since git has nothing left to lose, the leftover directory is
+    hard-deleted and teardown proceeds and succeeds."""
+    import shutil
+
+    _, clone = _origin_and_clone(tmp_path, default_branch="develop")
+    wt_dir = tmp_path / "worktrees"
+    cfg = _config(wt_dir)
+    assert _run(monkeypatch, cfg, name="orphan", project=str(clone)) == 0
+    wt_path = wt_dir / "clone-repo" / "orphan"
+    assert wt_path.exists()
+
+    # Simulate the crashed-partial-teardown state: git's own registration is
+    # gone, but the directory (with leftover content) survives on disk.
+    shutil.rmtree(clone / ".git" / "worktrees" / "orphan")
+    (wt_path / "stale-cache-file").write_text("leftover\n")
+
+    capsys.readouterr()
+    rc = _run(monkeypatch, cfg, name="orphan", project=str(clone), remove=True)
+    assert rc == 0
+    assert not wt_path.exists()
+    assert reg.entries(clone.resolve()) == []
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["success"] is True
+    assert payload["worktree_removed"] is True
+    assert payload["hard_deleted_orphan"] is True
+
+
 def test_remove_kills_alive_session(tmp_path, monkeypatch, wt_env, capsys):
     _, clone = _origin_and_clone(tmp_path, default_branch="develop")
     wt_dir = tmp_path / "worktrees"