agentwire-dev 1.78.0__tar.gz → 1.80.0__tar.gz

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/.github/workflows/pytest.yml

@@ -48,7 +48,7 @@ jobs:
       - name: Run test suite (full) + coverage
         if: github.event_name != 'pull_request'
         run: >
-          uv run --no-sync pytest -q -m "not requires_tmux"
+          uv run --no-sync pytest -q -m "not requires_tmux and not upgrade"
           --cov=agentwire --cov-report=term-missing --cov-report=xml
 
       - name: Publish coverage summary (report-only)
@@ -70,6 +70,29 @@ jobs:
           path: coverage.xml
           if-no-files-found: ignore
 
+  # Upgrade test (#1276): the previous release from PyPI, upgraded in place to this checkout, in a
+  # fresh HOME. Needs the network and builds two venvs, so it is NOT in the PR gate: it runs on
+  # pushes to main and on PRs into a release branch. Budget: ~10 min timeout, ~1 min typical.
+  # PyPI index lag is the one flake to rerun, not a reason to skip it.
+  upgrade:
+    name: upgrade from previous release
+    if: github.event_name == 'push' || startsWith(github.base_ref, 'release')
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+
+      - name: Sync dependencies
+        run: uv sync --extra dev
+
+      - name: Upgrade test
+        run: uv run --no-sync pytest -q -m upgrade tests/integration/test_upgrade_from_release.py
+
   # The hook is `python -I -m damage_control.hook` and runs under whatever `python3` the user
   # has; the package's declared floor is 3.9 (#1223: a 3.10-only construct made the hooks crash
   # non-blocking, i.e. fail OPEN). The main job runs 3.12 and cannot see that. agentwire itself

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentwire-dev
-Version: 1.78.0
+Version: 1.80.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
@@ -228,7 +228,7 @@ Requires-Dist: aiohttp-jinja2>=1.6
 Requires-Dist: aiohttp>=3.13.4
 Requires-Dist: av>=12.0.0
 Requires-Dist: certifi>=2026.10.23
-Requires-Dist: damage-control-dev<0.3,>=0.2.0
+Requires-Dist: damage-control-dev<0.4,>=0.3.0
 Requires-Dist: fastapi>=0.104.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kokoro-onnx>=0.4.9; python_version < '3.14'

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/RELEASING.md

@@ -6,17 +6,22 @@ Every release does **both** a PyPI publish and a GitHub release. The **GitHub re
 
 ## The engine is a separate project (single source)
 
-The damage-control engine has exactly one source: the `damage-control-dev` repo (<https://github.com/dotdevdotdev/damage-control-dev>), published on PyPI. `agentwire-dev` only *consumes* it through the range in `pyproject.toml` (currently `damage-control-dev>=0.2.0,<0.3`); a checkout and a PyPI install both resolve it from PyPI. There is no copy of the engine in this repo and nothing to release from here. `tests/unit/test_damage_control_pin.py` checks that the declared floor/ceiling parse and that the installed engine satisfies them.
+The damage-control engine has exactly one source: the `damage-control-dev` repo (<https://github.com/dotdevdotdev/damage-control-dev>), published on PyPI. `agentwire-dev` only *consumes* it through the range in `pyproject.toml` (currently `damage-control-dev>=0.3.0,<0.4`); a checkout and a PyPI install both resolve it from PyPI. There is no copy of the engine in this repo and nothing to release from here. `tests/unit/test_damage_control_pin.py` checks that the declared floor/ceiling parse and that the installed engine satisfies them.
 
 To ship an engine change:
 
 1. **Land it in the damage-control-dev repo**, tag and release it there (its own release flow). Do not tag or release from this repo.
-2. **Raise the floor here** in a normal agentwire PR: bump the `>=` in `pyproject.toml` (and the `<` ceiling too if the engine crossed it, e.g. `>=0.2.0,<0.3`), run `uv lock`, and re-run `scripts/golden_snapshot.py check` and `scripts/effective_rules.py --check` — re-record the golden only if the behavior change is intended, in that same PR.
+2. **Raise the floor here** in a normal agentwire PR: bump the `>=` in `pyproject.toml` (and the `<` ceiling too if the engine crossed it, e.g. `>=0.3.0,<0.4`), run `uv lock`, and re-run `scripts/golden_snapshot.py check` and `scripts/effective_rules.py --check` — re-record the golden only if the behavior change is intended, in that same PR.
 3. **Verify against the published wheel** before releasing agentwire: in a scratch venv, install the agentwire wheel (it pulls the engine from PyPI), then run the fast suite, `agentwire doctor` and a hook subprocess smoke under a temp `HOME`.
 4. **Then** bump and publish `agentwire-dev` (steps below), then the GitHub release.
 
 An `agentwire-dev` whose floor names an engine version PyPI doesn't have yet is uninstallable, so step 1 always completes (published) before step 2 merges.
 
+## Pre-release checklist
+
+- The **`upgrade from previous release`** job in `.github/workflows/pytest.yml` is green on the commit you are about to tag (it runs on pushes to main and on PRs into a `release*` branch, not on ordinary PRs). It installs the previous release from PyPI, upgrades it to this checkout in a fresh `HOME`, then asserts `safety migrate` and `doctor` behave. Details: [`docs/wiki/internals/upgrade-test.md`](docs/wiki/internals/upgrade-test.md). Rerun it if the only failure is PyPI index lag.
+- Engine bumps: also follow step 3 of the engine section above.
+
 ## Steps
 
 ### 1. Bump version

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/__init__.py

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

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/__main__.py

@@ -189,7 +189,7 @@ Command Categories:
     from . import doctor_cli, history_cli, machine_cli, safety_cli
     from . import handoff_cli, hooks_cli, mcp_cli, roles_cli, tunnels_cli
     from . import notify_cli, palette_cli, push_cli, repo_cli, system_cli, wiki_cli
-    from . import restart_cli, tabs_cli, wait_cli, worktree_cli
+    from . import fleet_cli, restart_cli, tabs_cli, wait_cli, worktree_cli
     from .council import cli as council_cli
 
     _REGISTRARS = [  # noqa: N806  # registry constant; Phase 1 of #495 appends here
@@ -226,6 +226,7 @@ Command Categories:
         palette_cli.register_palette_parser,
         tabs_cli.register_tabs_parser,
         wait_cli.register_wait_parser,
+        fleet_cli.register_fleet_parser,
         worktree_cli.register_helper_parser,
     ]
     for _reg in _REGISTRARS:

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/cohort.py

@@ -132,19 +132,43 @@ def ledger_path(parent: str) -> Path:
     return path
 
 
+def read(parent: str) -> tuple[dict | None, str | None]:
+    """``(ledger, problem)`` — exactly one is None.
+
+    ``problem`` is ``"missing"`` (no file) or ``"corrupt: <why>"``. The
+    distinction is for read-only reporters (``agentwire fleet``); the guard
+    paths use :func:`load`, which deliberately collapses both to "no cohort".
+    """
+    try:
+        text = ledger_path(parent).read_text()
+    except FileNotFoundError:
+        return None, "missing"
+    except (OSError, ValueError) as e:  # ValueError: invalid session name / undecodable bytes
+        return None, f"corrupt: {e}"
+    try:
+        data = json.loads(text)
+    except ValueError as e:
+        return None, f"corrupt: {e}"
+    if not isinstance(data, dict) or not isinstance(data.get("children"), list):
+        return None, "corrupt: not a cohort ledger (no children list)"
+    return data, None
+
+
 def load(parent: str) -> dict | None:
     """The parent's ledger, or None when absent/unreadable/malformed.
 
     Fails open on purpose: a corrupt ledger reads as "no cohort", so the guard
     stops suppressing and the parent resumes normal idle handling.
     """
-    try:
-        data = json.loads(ledger_path(parent).read_text())
-    except (OSError, ValueError):
-        return None
-    if not isinstance(data, dict) or not isinstance(data.get("children"), list):
-        return None
-    return data
+    return read(parent)[0]
+
+
+def ledger_parents() -> list[str]:
+    """Every parent session that has a ledger file, sorted (worktree names nest)."""
+    if not COHORT_ROOT.exists():
+        return []
+    return sorted(str(p.relative_to(COHORT_ROOT))[: -len(".json")]
+                  for p in COHORT_ROOT.rglob("*.json"))
 
 
 def _save(parent: str, data: dict) -> None:
@@ -301,6 +325,7 @@ def _mark(data: dict, child: str, state: str, report: str | None = None) -> None
     for entry in data["children"]:
         if entry.get("session") == child:
             entry["state"] = state
+            entry["resolved_at"] = _now()
             if report is not None:
                 entry["report"] = report
 
@@ -344,6 +369,7 @@ def record_delivery(parent: str, messages: list) -> None:
                 else:
                     continue
                 entry["delivered"] = True
+                entry["resolved_at"] = _now()
                 changed = True
                 log_event("delivered_by_drain", parent=parent, child=entry["session"],
                           state=entry["state"])

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/config.py

@@ -295,6 +295,27 @@ class AgentConfig:
     command: str = field(default_factory=_get_default_agent_command)
 
 
+@dataclass
+class SandboxConfig:
+    """Allowances for ``agentwire new --sandbox`` (#1279). Opt-in; nothing here
+    applies to a session launched without the flag. Writes are otherwise
+    limited to the session's working directory; ``~/.agentwire`` stays
+    read-only except the message-passing paths below, so a sandboxed agent
+    cannot edit ``damagecontrol.yml`` or ``.env``."""
+
+    allow_write: list[str] = field(default_factory=lambda: [
+        "~/.cache/uv",  # uv run / uv sync
+        "~/.agentwire/inbox", "~/.agentwire/inbox-events.jsonl",  # msg send / notify-parent --queued
+        "~/.agentwire/sent-ledger",
+    ])
+    allowed_domains: list[str] = field(default_factory=lambda: [
+        "github.com", "api.github.com", "pypi.org", "files.pythonhosted.org",
+    ])
+    allow_unix_sockets: list[str] = field(default_factory=list)  # tmux socket is always added
+    excluded_commands: list[str] = field(default_factory=lambda: ["gh *"])  # Go TLS fails under the proxy on macOS
+    allow_local_binding: bool = True  # macOS: needed to reach the local portal API
+
+
 @dataclass
 class MachinesConfig:
     """Remote machines registry configuration."""
@@ -618,6 +639,7 @@ class Config:
     tts: TTSConfig = field(default_factory=TTSConfig)
     stt: STTConfig = field(default_factory=STTConfig)
     agent: AgentConfig = field(default_factory=AgentConfig)
+    sandbox: SandboxConfig = field(default_factory=SandboxConfig)
     machines: MachinesConfig = field(default_factory=MachinesConfig)
     uploads: UploadsConfig = field(default_factory=UploadsConfig)
     artifacts: ArtifactsConfig = field(default_factory=ArtifactsConfig)
@@ -775,6 +797,14 @@ def _dict_to_config(data: dict) -> Config:
         command=agent_data.get("command", _get_default_agent_command()),
     )
 
+    # Sandbox allowances (#1279) — a key that is absent keeps its default.
+    sandbox_data = data.get("sandbox") or {}
+    sandbox_defaults = SandboxConfig()
+    sandbox = SandboxConfig(**{
+        key: sandbox_data.get(key, getattr(sandbox_defaults, key))
+        for key in SandboxConfig.__dataclass_fields__
+    })
+
     # Machines
     machines_data = data.get("machines", {})
     machines = MachinesConfig(
@@ -1017,6 +1047,7 @@ def _dict_to_config(data: dict) -> Config:
         tts=tts,
         stt=stt,
         agent=agent,
+        sandbox=sandbox,
         machines=machines,
         uploads=uploads,
         artifacts=artifacts,

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/core.py

@@ -254,6 +254,7 @@ class AgentCommand:
     roles: list[str] = field(default_factory=list)  # Role NAMES, in merge order
     model: str | None = None  # --model override, if the launch chose one
     effort: str | None = None  # --effort override, if the launch chose one
+    sandbox: bool = False  # launched under Claude Code's sandbox (--sandbox, #1279)
 
 
 _UNATTENDED_ENV_KEYS = ("AGENTWIRE_UNATTENDED", "AGENTWIRE_UNATTENDED_ALLOW")
@@ -626,9 +627,13 @@ def build_agent_command(
     model: str | None = None,
     resume_session_id: str | None = None,
     effort: str | None = None,
+    sandbox: bool = False,
 ) -> AgentCommand:
     """Build the shell command + injected env for the given posture.
 
+    ``sandbox`` adds ``--settings`` enabling Claude Code's native sandbox with
+    the allowances from ``config.yaml`` (#1279; see :mod:`agentwire.sandbox`).
+
     The ONE flag-builder (#729): fresh sessions AND history resume both route
     through here, so a posture always launches with the same flags — no
     create-vs-resume drift. Posture switches the permission-mode flags; ``bare``
@@ -687,6 +692,12 @@ def build_agent_command(
     if effort:
         parts.append(f"--effort {effort}")
 
+    if sandbox:
+        from . import sandbox as sandbox_mod
+        from .config import load_config as load_typed_config
+
+        parts.append(sandbox_mod.settings_flag(sandbox_mod.settings_for(load_typed_config())))
+
     # Role-based flags (merged roles always apply — no tool-locking posture left)
     role_prompt_path = None
     if merged:
@@ -712,6 +723,7 @@ def build_agent_command(
         roles=role_names,
         model=model,
         effort=effort,
+        sandbox=sandbox,
     )
 
 
@@ -1523,6 +1535,7 @@ def record_session_launch(
         # conversation back on a different model/effort than it was running on.
         "model": agent.model,
         "effort": agent.effort,
+        "sandbox": agent.sandbox,
         "role_prompt_path": agent.role_prompt_path,
         "launched_at": now,
         **({"repo": None, "branch": None, "worktree_path": None}
@@ -1550,6 +1563,40 @@ def record_session_launch(
     return metadata
 
 
+def record_conversation_change(session_name: str, conversation_id: str) -> bool:
+    """Make *conversation_id* the session's CURRENT conversation (#1271).
+
+    :func:`record_session_launch` writes the chain once, at launch. Claude
+    mints a new id inside a running session on ``/clear`` and switches ids on
+    ``/resume``, and nothing at launch can know — so the SessionStart hook
+    reports each change here, and ``restart``'s newest-first chain walk works
+    unchanged.
+
+    The id ends up LAST in the chain: a fresh id is appended, and an id already
+    recorded (a ``/resume`` back to an earlier conversation) is moved to the
+    tail, because the walk reads the tail as "what the session is in now".
+    Already-last is a no-op that writes nothing, so the hook is idempotent and
+    the launch's own record (which fires the same id) costs nothing.
+
+    Returns whether the record changed. A session with no launch record is left
+    alone (False) — this must never conjure a partial record that
+    ``recorded_sessions`` and ``doctor`` would then take for a launched
+    session. Raises ``OSError`` if the write doesn't land (see
+    :func:`store_session_metadata`); the hook decides what to do about that.
+    """
+    metadata = load_session_metadata(session_name)
+    if not metadata.get("cwd_at_launch"):
+        return False
+
+    chain = list(metadata.get("conversation_ids") or [])
+    if chain and chain[-1] == conversation_id:
+        return False
+
+    metadata["conversation_ids"] = [c for c in chain if c != conversation_id] + [conversation_id]
+    store_session_metadata(session_name, metadata)
+    return True
+
+
 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).
 

{agentwire_dev-1.78.0 → agentwire_dev-1.80.0}/agentwire/doctor_cli.py

@@ -497,6 +497,8 @@ def _render_damage_control_section(fix: bool = False) -> int:
             print(f"  [{mark}] {finding['message']}")
             if finding["level"] == "bad":
                 issues += 1
+            if finding["code"] == "stale-ruleset":
+                print("       Fix: agentwire safety install --refresh   (prints the diff and acknowledges it)")
         if not package_status["ok"]:
             print("       Fix: agentwire hooks install   (or: agentwire doctor --fix)")
             print("       Blocked outright? From a normal terminal (not through Claude Code):")
@@ -534,11 +536,9 @@ def _render_damage_control_section(fix: bool = False) -> int:
 
     # Rules and tooldefs ship inside the package; what lives on the machine is the host's
     # own overlay. A file there REPLACES the bundled one of the same name, so name each.
-    for section, groups in safety_migrate.classify().items():
-        named = groups["pristine"] + groups["edited"]
-        if named:
-            print(f"  [..] Your {section} overlay replaces bundled files: {', '.join(named)}")
-            print("       Fix: agentwire safety migrate   (removes pristine copies, keeps your edits)")
+    overlay_plan = safety_migrate.classify()
+    for line in safety_migrate.overlay_report_lines(overlay_plan):
+        print(line)
 
     # Rule groups and packs (#1141): informational only, never scored — a
     # disabled pack is a choice, not drift.
@@ -580,7 +580,7 @@ def _render_damage_control_section(fix: bool = False) -> int:
         print(f"  [!!] DUPLICATE rule ids in the loaded rule set: {', '.join(duplicates)}")
         print("       `disabled_rules` / `unattended_allow` naming one of these names")
         print("       BOTH rules. Usually a half-applied rule sync.")
-        print("       Fix: agentwire safety install --yes")
+        print(f"       Fix: {safety_migrate.duplicate_ids_fix(overlay_plan)}")
         issues += 1
     else:
         print("  [ok] Rule ids unique across the loaded rule set")
@@ -936,6 +936,56 @@ def scan_orphaned_history(sessions: list[str] | None = None) -> list[dict]:
     return findings
 
 
+def scan_unrecorded_transcripts(sessions: list[str] | None = None) -> list[dict]:
+    """Live sessions whose project dir holds transcripts newer than the recorded head (#1271).
+
+    The SessionStart hook keeps ``conversation_ids`` current across ``/clear``
+    and ``/resume``; a session that took one BEFORE the hook was installed has
+    a chain that stops at its launch id, and ``restart`` would resume that
+    stale conversation. The evidence is on disk: transcripts in the session's
+    history dir, absent from the chain, written after the head's own.
+
+    STATED, never scored, because it cannot be certain: the history dir is
+    keyed by cwd, so a second session sharing the directory writes transcripts
+    that look identical. The finding lists the candidates and says so. Live
+    sessions only — the ones you might actually restart.
+    """
+    from .core import load_session_metadata, recorded_sessions
+    from .history import claude_projects_dir, history_key_candidates
+
+    findings: list[dict] = []
+    for name in sessions if sessions is not None else recorded_sessions():
+        metadata = load_session_metadata(name)
+        ids = list(metadata.get("conversation_ids") or [])
+        cwd = metadata.get("cwd_at_launch")
+        if not ids or not cwd or not tmux_session_exists(name):
+            continue
+
+        for key in history_key_candidates(cwd):
+            project = claude_projects_dir() / key
+            try:
+                head = project / f"{ids[-1]}.jsonl"
+                baseline = head.stat().st_mtime if head.exists() else None
+                if baseline is None:
+                    continue  # no head transcript to be newer than
+                newer = sorted(
+                    (f for f in project.glob("*.jsonl")
+                     if f.stem not in ids and f.stat().st_mtime > baseline),
+                    key=lambda f: f.stat().st_mtime,
+                )
+            except OSError:
+                continue
+            if newer:
+                findings.append({
+                    "session": name,
+                    "head": ids[-1],
+                    "newer": [f.stem for f in newer],
+                    "project_dir": str(project),
+                })
+                break
+    return findings
+
+
 def _render_orphaned_history_section() -> int:
     """Doctor section: conversations a restart could not bring back (#871).
 
@@ -975,6 +1025,18 @@ def _render_orphaned_history_section() -> int:
         print("       Not a fault. Restarting these keeps the role and starts a fresh "
               "conversation.")
 
+    unrecorded = scan_unrecorded_transcripts()
+    if unrecorded:
+        print(f"  [..] {len(unrecorded)} live session(s) with transcripts newer than the "
+              "recorded conversation:")
+        for f in unrecorded:
+            print(f"       - {f['session']}: recorded head {f['head'][:8]}, newer "
+                  f"{', '.join(c[:8] for c in f['newer'])}")
+        print("       Likely a /clear or /resume taken before the session-start hook was "
+              "installed (`agentwire hooks install`): `agentwire restart` would resume the "
+              "recorded head, not the newer conversation. Not scored — another session in "
+              "the same directory writes transcripts that look the same.")
+
     return len(orphaned)
 
 
@@ -1066,13 +1128,11 @@ def _render_cohort_section() -> int:
     from . import cohort
 
     suspects = []
-    if cohort.COHORT_ROOT.exists():
-        for path in sorted(cohort.COHORT_ROOT.rglob("*.json")):
-            parent = str(path.relative_to(cohort.COHORT_ROOT))[: -len(".json")]
-            data = cohort.load(parent)
-            reason = cohort.suspect_reason(parent, data) if data else None
-            if reason:
-                suspects.append((parent, reason))
+    for parent in cohort.ledger_parents():
+        data = cohort.load(parent)
+        reason = cohort.suspect_reason(parent, data) if data else None
+        if reason:
+            suspects.append((parent, reason))
     if not suspects:
         print("  [ok] No suspect cohort ledgers")
         return 0
@@ -1084,6 +1144,28 @@ def _render_cohort_section() -> int:
     return 1
 
 
+def _render_fleet_section() -> int:
+    """Doctor section: delegation problems from ``agentwire fleet`` (#1277).
+
+    Renders :func:`fleet.build_fleet` and nothing else — the flags are decided
+    there, so doctor, the CLI and the portal cannot disagree.
+    """
+    from . import fleet
+
+    data = fleet.build_fleet(None)
+    problems = len(data["flagged"]) + len(data["broken_ledgers"])
+    if not problems:
+        print("  [ok] No stuck or silent children in any fan-out")
+        return 0
+    print(f"  [!!] {problems} fleet problem(s):")
+    for b in data["broken_ledgers"]:
+        print(f"       - {b['parent']}: cohort ledger {b['ledger']}")
+    for f in data["flagged"]:
+        print(f"       - {f['session']} (child of {f['parent']}): {f['flag']}")
+    print("       Details: agentwire fleet --all")
+    return 1
+
+
 def _render_auth_expired_section() -> int:
     """Doctor section: an active expired-login outage (#906).
 
@@ -1364,6 +1446,28 @@ def _render_role_prompt_store_section(
     return 1, 1
 
 
+def _render_sandbox_section() -> int:
+    """Which recorded sessions run under the Claude Code sandbox (#1279).
+
+    Reads the launch record — the flag is recorded, not guessed from a pane —
+    and flags a machine where a sandboxed session could not (re)start, since
+    ``failIfUnavailable`` makes that a hard refusal, not a silent downgrade.
+    """
+    from . import sandbox
+
+    names = sandbox.sandboxed_sessions()
+    problem = sandbox.platform_problem()
+    if not names:
+        print("  [ok] No session was launched with --sandbox")
+        return 0
+    for name in names:
+        print(f"  [ok] {name}: sandboxed (launch record)")
+    if problem:
+        print(f"  [!!] sandbox cannot start on this machine: {problem}")
+        return 1
+    return 0
+
+
 def _render_blocked_prompt_section() -> int:
     """Doctor section: agent alive, but the pane sits on an unanswered menu (#905).
 
@@ -2103,6 +2207,12 @@ def cmd_doctor(args) -> int:
     print("\nChecking for suspect cohort ledgers...")
     issues_found += _render_cohort_section()
 
+    print("\nChecking the fleet (stuck or silent children)...")
+    try:
+        issues_found += _render_fleet_section()
+    except Exception as e:
+        print(f"  [..] Could not check the fleet: {e}")
+
     # 10c. Expired Claude login (#906) — the state that made #867 cost two
     # hours. Nothing else on this list would surface it: the pane is alive and
     # the agent process is running, so every liveness check passes.
@@ -2189,6 +2299,12 @@ def cmd_doctor(args) -> int:
     except Exception as e:
         print(f"  [..] Could not check the role-prompt store: {e}")
 
+    print("\nChecking sandboxed sessions (#1279)...")
+    try:
+        issues_found += _render_sandbox_section()
+    except Exception as e:
+        print(f"  [..] Could not check sandboxed sessions: {e}")
+
     # 12c. Sessions blocked on an unanswered dialog (#905). The one state every
     # other check calls healthy: the agent process is running, so liveness
     # passes, while the pane sits on a menu and does nothing.